Beispiel #1
0
 public PriceAdapter(Double step)
 {
     Rule    = PriceMappingRules.Natural;
     IndexOf = new PriceToIndexValueDelegate(steppedIndexOf);
     Zero    = 0;
     Step    = step;
 }
Beispiel #2
0
        private PriceAdapter(PriceMappingRules rule)
        {
            if (rule != PriceMappingRules.Natural)
            {
                throw new Exception();
            }

            Rule    = rule;
            IndexOf = new PriceToIndexValueDelegate(NatureIndexOf);
            Zero    = 0;
            Step    = 1;
        }
Beispiel #3
0
        public PriceAdapter(PriceMappingRules rule, Double floor, double ceiling)
        {
            Rule = rule;

            switch (rule)
            {
            default:
                throw new Exception();

            case PriceMappingRules.Natural:
                //double range = ceiling - floor;
                //Step = StepOf(range, 3);
                if (ceiling >= 36000)
                {
                    Step = 100;
                }
                else if (ceiling >= 18000)
                {
                    Step = 50;
                }
                else if (ceiling >= 7200)
                {
                    Step = 10;
                }
                else if (ceiling >= 1800)
                {
                    Step = 5;
                }
                else if (ceiling >= 720)
                {
                    Step = 2;
                }
                else if (ceiling >= 180)
                {
                    Step = 1;
                }
                else if (ceiling >= 72)
                {
                    Step = 0.5;
                }
                else if (ceiling >= 18)
                {
                    Step = 0.1;
                }
                else if (ceiling >= 9)
                {
                    Step = 0.05;
                }
                else
                {
                    Step = 0.01;
                }
                Zero = 0;
                break;

            case PriceMappingRules.FilledPivots:
            case PriceMappingRules.Filled:
                Zero = gracefulOf(floor, true);
                Double max = gracefulOf(ceiling, false);
                Step = (max - Zero) / 360;
                break;

            case PriceMappingRules.Contained:
                double temp = ceiling - floor;
                Step = StepOf(temp * 3, 2);
                Zero = Math.Round(floor / Step) * Step;
                break;

            case PriceMappingRules.FloorNatural:
                Step = StepOf(floor, 2);
                Zero = Math.Round(floor / Step) * Step;
                break;

            case PriceMappingRules.CeilingNatural:
                Step = StepOf(ceiling, 3);
                Zero = 0;
                break;

            case PriceMappingRules.FloorStep:
                Step = gracefulOf(floor);
                Zero = Math.Round(floor / Step) * Step;
                break;
            }

            IndexOf = new PriceToIndexValueDelegate(relativeIndexOf);
        }