示例#1
0
        private void chengjiao(ref weimai3Shuju zhudongdan, weimai4Shuju weituodan)
        {
            if (zhudongdan.jiage < weituodan.jiage)
            {
                throw new ArgumentOutOfRangeException("成交的委买价格小于委卖价格");
            }

            uint zdbianhao = zhudongdan.bianhao;
            uint wtbianhao = weituodan.bianhao;

            geti.chigushujuJg zhudongchigushuju =
                moniqunti.Getishuzu[zdbianhao].chigushuju;
            geti.chigushujuJg weituochigushuju =
                moniqunti.Getishuzu[zdbianhao].chigushuju;
            //确定数量和价格
            uint   chengjiaoliang;
            double chengjiaojia;

            chengjiaojia = weituodan.jiage;
            if (zhudongdan.shuliang < weituodan.shuliang)
            {
                chengjiaoliang = zhudongdan.shuliang;
            }
            else
            {
                chengjiaoliang = weituodan.shuliang;
            }
            //主动数据修改
            zhudongdan.shuliang -= chengjiaoliang;

            zhudongchigushuju.Chengbenjia = (zhudongchigushuju.Chengbenjia * zhudongchigushuju.chigushu +
                                             chengjiaoliang * chengjiaojia) / (zhudongchigushuju.chigushu + chengjiaoliang);
            zhudongchigushuju.chigushu    += chengjiaoliang;
            zhudongchigushuju.Zijin       -= chengjiaojia * chengjiaoliang;
            zhudongchigushuju.Cangwei      = zhudongchigushuju.chigushu * chengjiaojia / (zhudongchigushuju.chigushu * chengjiaojia + zhudongchigushuju.Zijin);
            zhudongchigushuju.Keyongzijin += (chengjiaojia - zhudongdan.jiage) * chengjiaoliang;


            //委托数据修改
            weituodan.shuliang -= chengjiaoliang;

            weituochigushuju.Chengbenjia = (weituochigushuju.Chengbenjia * weituochigushuju.chigushu -
                                            chengjiaoliang * chengjiaojia) / (weituochigushuju.chigushu - chengjiaoliang);
            weituochigushuju.chigushu    -= chengjiaoliang;
            weituochigushuju.Zijin       += chengjiaojia * chengjiaoliang;
            weituochigushuju.Cangwei      = weituochigushuju.chigushu * chengjiaojia / (weituochigushuju.chigushu * chengjiaojia + weituochigushuju.Zijin);
            weituochigushuju.Keyongzijin += chengjiaoliang * chengjiaojia;
        }
示例#2
0
        public override void chigushujuBujian(canshulei canshu)
        {
            zhengtaicanshu zz          = (zhengtaicanshu)canshu;
            double         cangwei     = -1;
            double         chengbenjia = -1;
            uint           chigushu    = 0;
            double         keyongzijin = -1;
            double         zijin       = -1;

            //cangwei赋值
            switch (jiaoyishuxing.duokong)
            {
            case duokongMj.duo:
                cangwei = 0.55 + 0.3 * 0.01 * suijishu.Next(100);
                break;

            case duokongMj.kong:
                cangwei = 0.85 - 0.6 * 0.01 * suijishu.Next(100);
                break;

            case duokongMj.guanwang:
                cangwei = 0;
                break;

            case duokongMj.jiancang:
                cangwei = 0.5 * 0.01 * suijishu.Next(100);
                break;
            }
            //成本价赋值
            chengbenjia = zz.gujia * (1 + 0.05 / 100.0 * suijishu.Next(-100, 101));

            //资金赋值,要读取资金分布,总额和其他由指导者部分完成,这里只负责根据参数创建,以及判断创建出的数据是否服从规范
            double shizhi;
            double suijishubb = zz.shizhifenbugailv[zz.shizhifenbugailv.Length - 1] * suijishu.NextDouble();
            int    count      = 0;
            //计算市值在哪一个分布内
            double taaa = 0;

            foreach (var vbbb in zz.shizhifenbugailv)
            {
                if (suijishubb < vbbb && suijishubb > taaa)
                {
                    break;
                }
                taaa = vbbb;
                count++;
            }
            //根据类型赋值
            shizhi = suijishu.Next(zz.shizhibiao[count, 0], zz.shizhibiao[count, 1]);


            switch (jiaoyishuxing.duokong)
            {
            case duokongMj.duo:    //
                chigushu    = (uint)(shizhi / zz.gujia);
                zijin       = shizhi / cangwei * (1 - cangwei);
                keyongzijin = zijin;
                break;

            case duokongMj.guanwang:
                zijin       = shizhi;
                chigushu    = 0;
                keyongzijin = zijin;
                break;

            case duokongMj.jiancang:    //市值即总资金
                chigushu    = (uint)(shizhi / zz.gujia);
                zijin       = shizhi * (1 - cangwei);
                keyongzijin = zijin;
                break;

            case duokongMj.kong:
                chigushu    = (uint)(shizhi / zz.gujia);
                zijin       = shizhi / cangwei * (1 - cangwei);
                keyongzijin = zijin;
                break;
            }
            chigushuju = new geti.chigushujuJg(cangwei, chengbenjia, chigushu, keyongzijin, zijin);
        }