RandomGen.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;
using AdvanceMath;
using System.Collections.Generic;

namespace Jypeli
{
    public static class RandomGen
    {
        private static Random rand = new Random();

        public static bool NextBool()
        {
            return ( rand.NextDouble() >= 0.5 );
        }

        public static int NextInt( int maxValue )
        {
            return rand.Next( maxValue );
        }

        public static int NextInt( int min, int max )
        {
            return rand.Next( min, max );
        }        

        public static double NextDouble(double min, double max)
        {
            return min + rand.NextDouble() * ( max - min );
        }

        public static char NextLetter(bool upperCase = false)
        {
            int startCode = upperCase ? (int)'A' : (int)'a';
            int endCode = upperCase ? (int)'Z' : (int)'z';
            return (char)NextInt( startCode, endCode + 1 );
        }

        public static Direction NextDirection()
        {
            double randdir = rand.NextDouble();

            if ( randdir <= 0.25 )
                return Direction.Up;

            if ( randdir <= 0.5 )
                return Direction.Down;

            if ( randdir <= 0.75 )
                return Direction.Left;

            return Direction.Right;
        }

        public static double[] NextDoubleArray( double min, double max, int size )
        {
            double[] array = new double[size];

            for ( int i = 0; i < size; i++ )
            {
                array[i] = NextDouble( min, max );
            }

            return array;
        }

        public static double[] NextDoubleArray( double min, double max, int size, int maxchange )
        {
            double[] array = new double[size];
            double curmin = min;
            double curmax = max;

            for ( int i = 0; i < size; i++ )
            {
                array[i] = NextDouble( curmin, curmax );

                curmin = AdvanceMath.MathHelper.Max((float)min, (float)(array[i] - maxchange));
                curmax = AdvanceMath.MathHelper.Min((float)max, (float)(array[i] + maxchange));
            }

            return array;
        }

        public static Color NextColor()
        {
            return new Color( (float)rand.NextDouble(), (float)rand.NextDouble(), (float)rand.NextDouble(), 1 );
        }

        public static Color NextLightColor()
        {
            return Color.Mix( NextColor(), Color.White );
        }

        public static Color NextDarkColor()
        {
            return Color.Mix( NextColor(), Color.Black );
        }

        public static Color NextColor( Color first, Color second )
        {
            return Color.Lerp( first, second, (float)rand.NextDouble());
        }

        public static Angle NextAngle()
        {
            return Angle.FromRadians( NextDouble( 0, 2 * Math.PI ) );
        }

        public static Vector NextVector( double minLength, double maxLength )
        {
            return Vector.FromLengthAndAngle( NextDouble( minLength, maxLength ), NextAngle() );
        }

        public static Vector NextVector( double minX, double minY, double maxX, double maxY )
        {
            return new Vector( NextDouble( minX, maxX ), NextDouble( minY, maxY ) );
        }


        public static Vector NextVector(BoundingRectangle rect, int r=0)
        {
            return new Vector(NextDouble(rect.Left+r, rect.Right-r), NextDouble(rect.Bottom+r, rect.Top-r));
        }


        public static Angle NextAngle( Angle max )
        {
            return Angle.FromRadians( NextDouble( 0, max.Radians ) );
        }

        public static Angle NextAngle( Angle min, Angle max )
        {
            double a1 = min.Radians;
            double a2 = max.Radians;
            while ( a2 < a1 ) a2 += 2 * Math.PI;
            return Angle.FromRadians( NextDouble( a1, a2 ) );
        }

        public static int NextIntWithProbabilities( params double[] p )
        {
            double randomNum = rand.NextDouble();
            double accumulator = 0;

            for ( int i = 0; i < p.Length; i++ )
            {
                accumulator += p[i];
                if ( randomNum < accumulator ) return i;
            }

            return p.Length;
        }


        public static void Shuffle<T>(IList<T> list)
        {
            for (int i = list.Count; i > 1; i--)
            {
                // Pick random element to swap.
                int j = rand.Next(i); // 0 <= j <= i-1
                // Swap.
                T tmp = list[j];
                list[j] = list[i - 1];
                list[i - 1] = tmp;
            }
        }

        public static T SelectOne<T>( params T[] choices )
        {
            int i = NextInt( choices.Length );
            return choices[i];
        }

        public static T SelectOne<T>( IList<T> choices )
        {
            int i = NextInt( choices.Count );
            return choices[i];
        }

    }
}