Пример #1
0
        /// <summary>
        /// Generates a random orbit in as similar a manner to stock as possible.
        /// </summary>
        /// <returns>The orbit of a randomly selected member of the population.</returns>
        ///
        /// <exception cref="InvalidOperationException">Thrown if cannot produce stockalike
        /// orbits. The program will be in a consistent state in the event of an exception.</exception>
        public Orbit drawOrbit()
        {
            CelestialBody kerbin = FlightGlobals.Bodies.Find(body => body.isHomeWorld);
            CelestialBody dres   = FlightGlobals.Bodies.Find(body => body.name.Equals("Dres"));

            if (dres != null && reachedBody(dres) && UnityEngine.Random.Range(0, 4) == 0)
            {
                // Drestroids
                double a     = RandomDist.drawLogUniform(0.55, 0.65) * dres.sphereOfInfluence;
                double e     = RandomDist.drawRayleigh(0.005);
                double i     = RandomDist.drawRayleigh(0.005); // lAn takes care of negative inclinations
                double lAn   = RandomDist.drawAngle();
                double aPe   = RandomDist.drawAngle();
                double mEp   = Math.PI / 180.0 * RandomDist.drawAngle();
                double epoch = Planetarium.GetUniversalTime();

                Debug.Log("[CustomAsteroids]: "
                          + Localizer.Format("#autoLOC_CustomAsteroids_LogOrbit",
                                             a, e, i, aPe, lAn, mEp, epoch));
                return(new Orbit(i, e, a, lAn, aPe, mEp, epoch, dres));
            }
            if (kerbin != null)
            {
                // Kerbin interceptors
                double delay = RandomDist.drawUniform(12.5, 55.0);
                Debug.Log("[CustomAsteroids]: "
                          + Localizer.Format("#autoLOC_CustomAsteroids_LogDefault", delay));
                return(Orbit.CreateRandomOrbitFlyBy(kerbin, delay));
            }
            throw new InvalidOperationException(
                      Localizer.Format("#autoLOC_CustomAsteroids_ErrorDefaultNoKerbin"));
        }
Пример #2
0
        /// <summary>
        /// Generates a random number consistent with the distribution. The program state shall be
        /// unchanged in the event of an exception.
        /// </summary>
        /// <returns>The desired random variate. The distribution depends on this object's internal
        /// data.</returns>
        ///
        /// <exception cref="ArgumentException">Thrown if the parameters are inappropriate
        /// for the distribution.</exception>
        /// <exception cref="InvalidOperationException">Thrown if the distribution is
        /// invalid.</exception>
        internal double draw()
        {
            switch (dist)
            {
            case Distribution.Uniform:
                return(RandomDist.drawUniform(min, max));

            case Distribution.LogUniform:
                return(RandomDist.drawLogUniform(min, max));

            case Distribution.Gaussian:
            case Distribution.Normal:
                return(RandomDist.drawNormal(avg, stdDev));

            case Distribution.LogNormal:
                if (avg <= 0.0)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorLogNormMean", avg));
                }
                if (stdDev <= 0.0)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorLogNormStd", stdDev));
                }
                double quad  = Math.Sqrt(avg * avg + stdDev * stdDev);
                double mu    = Math.Log(avg * avg / quad);
                double sigma = Math.Sqrt(2 * Math.Log(quad / avg));
                return(RandomDist.drawLognormal(mu, sigma));

            case Distribution.Rayleigh:
                return(RandomDist.drawRayleigh(avg * Math.Sqrt(2.0 / Math.PI)));

            case Distribution.Exponential:
                return(RandomDist.drawExponential(avg));

            case Distribution.Gamma:
                if (avg <= 0.0)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorGammaMean", avg));
                }
                if (stdDev <= 0.0)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorGammaStd", stdDev));
                }
                double k = (avg / stdDev);
                k = k * k;
                double theta = stdDev * stdDev / avg;
                return(RandomDist.drawGamma(k, theta));

            case Distribution.Beta:
                if (avg <= min || avg >= max)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorBetaMean", min, avg, max));
                }
                if (stdDev <= 0.0)
                {
                    throw new ArgumentException(
                              Localizer.Format("#autoLOC_CustomAsteroids_ErrorBetaStd", stdDev));
                }
                double scaledMean   = (avg - min) / (max - min);
                double scaledStdDev = stdDev / (max - min);
                double scaledVar    = scaledStdDev * scaledStdDev;
                double factor       = (scaledMean - scaledMean * scaledMean - scaledVar) / scaledVar;
                double alpha        = scaledMean * factor;
                double beta         = (1.0 - scaledMean) * factor;
                return(min + (max - min) * RandomDist.drawBeta(alpha, beta));

            case Distribution.Isotropic:
                return(RandomDist.drawIsotropic());

            default:
                throw new InvalidOperationException(
                          Localizer.Format("#autoLOC_CustomAsteroids_ErrorBadDistribution", dist));
            }
        }