C# NormalDistribution.NextDouble方法代码示例

        //---------------------------------------------------------------------

        private static double GenerateRandomNum(Distribution dist, double parameter1, double parameter2)
        {
            double randomNum = 0.0;
            if(dist == Distribution.normal)
            {
                NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
                randVar.Mu = parameter1;      // mean
                randVar.Sigma = parameter2;   // std dev
                randomNum = randVar.NextDouble();
            }
            if(dist == Distribution.lognormal)
            {
                LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
                randVar.Mu = parameter1;      // mean
                randVar.Sigma = parameter2;   // std dev
                randomNum = randVar.NextDouble();
            }
            if(dist == Distribution.gamma)
            {
                GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
                randVar.Alpha = parameter1;      // mean
                randVar.Theta = parameter2;   // std dev
                randomNum = randVar.NextDouble();
            }
            if(dist == Distribution.Weibull)
            {
                WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
                randVar.Alpha = parameter1;      // mean
                randVar.Lambda = parameter2;   // std dev
                randomNum = randVar.NextDouble();
            }
            return randomNum;
        }

        //---------------------------------------------------------------------
        ///<summary>
        /// Run the Biomass Insects extension at a particular timestep.
        ///</summary>
        public override void Run()
        {

            running = true;
            UI.WriteLine("   Processing landscape for Biomass Insect events ...");

            foreach(IInsect insect in manyInsect)
            {

                if(insect.MortalityYear == Model.Core.CurrentTime)
                    Outbreak.Mortality(insect);

                // Copy the data from current to last
                foreach (ActiveSite site in Model.Core.Landscape)
                    insect.LastYearDefoliation[site] = insect.ThisYearDefoliation[site];

                insect.ThisYearDefoliation.ActiveSiteValues = 0.0;
                //SiteVars.BiomassRemoved.ActiveSiteValues = 0;

                insect.ActiveOutbreak = false;
                insect.SingleOutbreakYear = false;

                NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
                randVar.Mu = 0;      // mean
                randVar.Sigma = 1;   // std dev
                double randomNum = randVar.NextDouble();

                ExponentialDistribution randVarE = new ExponentialDistribution(RandomNumberGenerator.Singleton);
                randVarE.Lambda = insect.MeanDuration;      // rate
                double randomNumE = randVarE.NextDouble();

                // First, has enough time passed since the last outbreak?
                double timeBetweenOutbreaks = insect.MeanTimeBetweenOutbreaks + (insect.StdDevTimeBetweenOutbreaks * randomNum);
                //double duration = insect.MeanDuration + (insect.StdDevDuration * randomNum);
                double duration = Math.Round(randomNumE + 1);
                
                if (duration > 5) // Limit maximum outbreak duration to 5 years for now.
                    duration = duration - 3;

                double timeAfterDuration = timeBetweenOutbreaks - duration;

                //UI.WriteLine("Calculated time between = {0}.  inputMeanTime={1}, inputStdTime={2}.", timeBetweenOutbreaks, insect.MeanTimeBetweenOutbreaks, insect.StdDevTimeBetweenOutbreaks);
                //UI.WriteLine("Calculated duration     = {0}.  inputMeanDura={1}, inputStdDura={2}.", duration, insect.MeanDuration, insect.StdDevDuration);
                //UI.WriteLine("Insect Start Time = {0}, Stop Time = {1}.", insect.OutbreakStartYear, insect.OutbreakStopYear);


                if(Model.Core.CurrentTime == 1)
                {
                    //UI.WriteLine("   Year 1:  Setting initial start and stop times.");
                    insect.OutbreakStartYear = (int) (timeBetweenOutbreaks / 2.0) + 1;
                    insect.OutbreakStopYear  = insect.OutbreakStartYear + (int) duration - 1;
                    UI.WriteLine("   {0} is not active.  StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);
                }
                else if(insect.OutbreakStartYear <= Model.Core.CurrentTime
                    && insect.OutbreakStopYear > Model.Core.CurrentTime)
                {
                    //UI.WriteLine("   An outbreak starts or continues.  Start and stop time do not change.");
                    insect.ActiveOutbreak = true;
                    UI.WriteLine("   {0} is active.  StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);

                    insect.MortalityYear = Model.Core.CurrentTime + 1;

                }
                //Special case for single year outbreak.
                else if(insect.OutbreakStartYear <= Model.Core.CurrentTime
                    && insect.OutbreakStopYear <= Model.Core.CurrentTime)
                {
                    insect.ActiveOutbreak = true;
                    UI.WriteLine("   {0} is active.  StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);

                    if (insect.OutbreakStartYear == insect.OutbreakStopYear)
                        insect.SingleOutbreakYear = true;
                    insect.MortalityYear = Model.Core.CurrentTime + 1;
                    insect.OutbreakStartYear = Model.Core.CurrentTime + (int)timeBetweenOutbreaks;
                    insect.OutbreakStopYear = insect.OutbreakStartYear + (int)duration - 1;
                }

                else if(insect.OutbreakStopYear <= Model.Core.CurrentTime
                    && timeAfterDuration > Model.Core.CurrentTime - insect.OutbreakStopYear)
                {
                    //UI.WriteLine("   In between outbreaks, reset start and stop times.");
                    insect.ActiveOutbreak = true;
                    UI.WriteLine("   {0} is active.  StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);

                    insect.MortalityYear = Model.Core.CurrentTime + 1;
                    insect.OutbreakStartYear = Model.Core.CurrentTime + (int) timeBetweenOutbreaks;
                    insect.OutbreakStopYear = insect.OutbreakStartYear + (int) duration - 1;
                }
                //UI.WriteLine("  Insect Start Time = {0}, Stop Time = {1}.", insect.OutbreakStartYear, insect.OutbreakStopYear);

                if(insect.ActiveOutbreak)
                {
                    //UI.WriteLine("   OutbreakStartYear={0}.", insect.OutbreakStartYear);

                    if(insect.OutbreakStartYear == Model.Core.CurrentTime || insect.SingleOutbreakYear)
                        // Initialize neighborhoodGrowthReduction with patches
//.........这里部分代码省略.........

        // TWO FUNCTIONS BELOW USED FOR LANDSCAPE TESTING
        /*private IOutputRaster<UShortPixel> CreateUShortMap(int currentTime, string agentName)
        {
            string path = MapNames.ReplaceTemplateVars("./tests/BDA/{agentName}/vulnerability-{timestep}.gis", agentName, currentTime);
//            string path = MapNames.ReplaceTemplateVars("./tests/BDA/{agentName}/outbreakzones-{timestep}.gis", agentName, currentTime);
            UI.WriteLine("Writing BDA output (with ushort values) map to {0} ...", path);
            return Util.Raster.Create<UShortPixel>(path,
                                                     Model.LandscapeMapDims,
                                                     Model.LandscapeMapMetadata);
        }
        private IOutputRaster<UShortPixel> CreateUShortMap2(int currentTime, string agentName)
        {
            string path = MapNames.ReplaceTemplateVars("./tests/BDA/{agentName}/neighbor_resources-{timestep}.gis", agentName, currentTime);
            UI.WriteLine("Writing BDA output (with ushort values) map to {0} ...", path);
            return Util.Raster.Create<UShortPixel>(path,
                                                     Model.LandscapeMapDims,
                                                     Model.LandscapeMapMetadata);
        }*/
        //---------------------------------------------------------------------
        private static int TimeToNext(IAgent activeAgent, int Timestep)
        {
            int timeToNext = 0;
            if (activeAgent.RandFunc == RandomFunction.RFuniform){
                int MaxI = (int) Math.Round(activeAgent.RandomParameter1);
                int MinI = (int) Math.Round(activeAgent.RandomParameter2);
                timeToNext =
                   (MinI - activeAgent.TimeSinceLastEpidemic) +
                   (int) (Landis.Util.Random.GenerateUniform() * (MaxI - MinI));

                //UI.WriteLine("RFuniform: TimeSince={0}, TimeToNext={1}", activeAgent.TimeSinceLastEpidemic, timeToNext);
                //    (activeAgent.TimeSinceLastEpidemic + timeToNext));

            }
            else if (activeAgent.RandFunc == RandomFunction.RFnormal){
                /*NormalRandomVar randVar = new NormalRandomVar(activeAgent.RandomParameter1, activeAgent.RandomParameter2);
                int randNum = (int)randVar.GenerateNumber();
                timeToNext = randNum - activeAgent.TimeSinceLastEpidemic ;
                */

                NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
                randVar.Mu = activeAgent.RandomParameter1;
                randVar.Sigma = activeAgent.RandomParameter2;
                int randNum = (int)randVar.NextDouble();
                timeToNext = randNum - activeAgent.TimeSinceLastEpidemic;


                // Interval times are always rounded up to the next time step increment.
                // This bias can be removed by reducing times by half the time step.
                timeToNext = timeToNext - (Timestep / 2);

                //UI.WriteLine("RFnormal: TimeSince={0}, TimeToNext={1}", activeAgent.TimeSinceLastEpidemic, timeToNext);
                    //(activeAgent.TimeSinceLastEpidemic + timeToNext));
                if (timeToNext < 0) timeToNext = 0;
            }
            return timeToNext;
        }