public FrequencySelecter(int frequency, int iFrequency, int counter, int insuranceIndex, int insuranceCounter)
            : base(iFrequency, counter)
        {
            Frequency = frequency;

            if (iFrequency > 1 && frequency > 1)
            {
                var ajustedIFrequency = (frequency - 1) * iFrequency;
                InsuranceSampler = new SystematicCounter(ajustedIFrequency, insuranceIndex, insuranceCounter);
            }
        }
        public FrequencySelecter(int frequency, int iFrequency)
            : base(iFrequency)
        {
            Frequency = frequency;

            if (iFrequency > 1 && frequency > 1)
            {
                var ajustedIFrequency = (frequency - 1) * iFrequency;
                InsuranceSampler = new SystematicCounter(ajustedIFrequency, SystematicCounter.CounterType.ON_RANDOM, Rand);
            }
        }
        public SRSSelecter(int frequency,
            int iTreeFrequency)
            : base(iTreeFrequency)
        {
            this.Frequency = frequency;

            if( base.IsSelectingITrees )
            {
                InsuranceCounter = 
                    new SystematicCounter(Frequency * base.ITreeFrequency,
                        SystematicCounter.CounterType.ON_RANDOM, this.Rand);
            }
        }
        public ThreePSelecter(
            int kz,
            int iTreeFrequency)
            : base(iTreeFrequency)
        {
            KZ = kz;

            if (IsSelectingITrees)
            {
                ajustedKZ        = CalcAjustedKZ(kz, iTreeFrequency);
                InsuranceSampler =
                    new SystematicCounter(iTreeFrequency + 1, // ajust i frequency because we were getting slightly too many i samples
                                          SystematicCounter.CounterType.ON_RANDOM, Rand);
            }
        }
        public ThreePSelecter(
            int kz,
            int iTreeFrequency,
            int counter,
            int insuranceIndex, int insuranceCounter)
            : base(iTreeFrequency, counter)
        {
            KZ = kz;

            if (IsSelectingITrees)
            {
                ajustedKZ        = CalcAjustedKZ(kz, iTreeFrequency);
                InsuranceSampler =
                    new SystematicCounter(iTreeFrequency + 1, // ajust i frequency because we were getting slightly too many i samples
                                          insuranceIndex, insuranceCounter);
            }
        }
        public ThreePSelecter(
            int kz,
            int maxKPI,
            int iTreeFrequency)
            : base(iTreeFrequency)
        {
            this.KZ = kz;
            this.MaxKPI = maxKPI;

            if (base.IsSelectingITrees)
            {
                ajustedKZ = CalcAjustedKZ(kz, iTreeFrequency);
                InsuranceCounter =
                    new SystematicCounter(base.ITreeFrequency,
                        SystematicCounter.CounterType.ON_RANDOM, this.Rand);
            }
        }
예제 #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="iTreeFrequency">if the number of items you wish is known
        /// use an iTreeFrequency = (populationSize / numberOfSamples) * iTreeFrequency</param>
        public ListSelecter(
            int populationSize,
            int iTreeFrequency)
            : base(iTreeFrequency)
        {
            this.Deck           = new List <ListItem>();
            this.PopulationSize = populationSize;

            if (base.IsSelectingITrees)
            {
                InsuranceCounter =
                    new SystematicCounter(base.ITreeFrequency,
                                          SystematicCounter.CounterType.ON_RANDOM, this.Rand);
            }

            PopulateDeck();
            ShuffleDeck();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="iTreeFrequency">if the number of items you wish is known
        /// use an iTreeFrequency = (populationSize / numberOfSamples) * iTreeFrequency</param>
        public ListSelecter(
            int populationSize,
            int iTreeFrequency)
            : base( iTreeFrequency)
        {
            this.Deck = new List<ListItem>();
            this.PopulationSize = populationSize;

            if (base.IsSelectingITrees)
            {
                InsuranceCounter =
                    new SystematicCounter(base.ITreeFrequency,
                        SystematicCounter.CounterType.ON_RANDOM, this.Rand);
            }

            PopulateDeck();
            ShuffleDeck();

        }
        public BlockSelecter(int frequency,
            int iTreeFrequency)
            : base(iTreeFrequency)
        {
            this.Frequency = frequency;

            if (base.IsSelectingITrees)
            {
                //create a systematicCounter for insurance trees
                //that will select an insurance tree at random
                //with the probability of 1 / (frequency * iTreeFrequency)
                InsuranceCounter = new SystematicCounter(
                    (frequency * base.ITreeFrequency),
                    SystematicCounter.CounterType.ON_RANDOM, base.Rand); 
                //alternative method where iTree is selected every nth tally
                //and frequency is n
                //InsuranceCounter = new Utility.SystematicCounter( n , Utility.SystematicCounter.CounterType.ON_RANDOM)
            }

            this.Block = new BlockState();
            Block.initBlock(this);
            BlockIndex = 0;
        }