public void GetRandomIntOnDifferentThreadsGetsDifferentResults()
 {
     var numberToGenerate = 1000;
     var intRange = new IntRange(1, 10);
     var task1 = Task.Factory.StartNew(() =>
         {
             var taskResults = new List<int>();
             for (int i = 0; i < numberToGenerate; ++i)
             {
                 taskResults.Add(Randomizer<int>.Create(intRange));
             }
             return taskResults;
         },
         TaskCreationOptions.LongRunning
     );
     var task2 = Task.Factory.StartNew(() =>
         {
             var taskResults = new List<int>();
             for (int i = 0; i < numberToGenerate; ++i)
             {
                 taskResults.Add(Randomizer<int>.Create(intRange));
             }
             return taskResults;
         },
         TaskCreationOptions.LongRunning
     );
     var results = Task.WhenAll(task1, task2).Result;
     var firstResults = results[0].Sum();
     var secondResults = results[1].Sum();
     Assert.NotEqual(firstResults, secondResults);
 }

 protected override int GetNext(IntRange fromRange, int soFar)
 {
     Contract.Requires(!fromRange.IsFixed);
     Contract.Requires(soFar >= 0);
     Contract.Ensures(fromRange.IsIn(Contract.Result<int>()));
     return 0;
 }

 public LogicalConnectionOptUnit(string id, int resolution, IntRange indexRange)
     : base(id, resolution, indexRange, CreateOptUnit())
 {
     Contract.Requires(!string.IsNullOrEmpty(id));
     Contract.Requires(resolution > 1);
     Contract.Requires(!indexRange.IsFixed && indexRange.MinValue >= 0);
 }

        public static void Run()
        {
            // ExStart:ConvertRangeOfDjVuPagesToSeparateImages
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_DjVu();

            // Load a DjVu image
            using (DjvuImage image = (DjvuImage)Image.Load(dataDir + "Sample.djvu"))
            {
                // Create an instance of BmpOptions and Set BitsPerPixel for resultant images
                BmpOptions exportOptions = new BmpOptions();
                exportOptions.BitsPerPixel = 32;

                // Create an instance of IntRange and initialize it with range of pages to be exported
                IntRange range = new IntRange(0, 2);
                int counter = 0;
                foreach (var i in range.Range)
                {
                    // Save each page in separate file, as BMP do not support layering
                    exportOptions.MultiPageOptions = new DjvuMultiPageOptions(range.GetArrayOneItemFromIndex(counter));
                    image.Save(dataDir + string.Format("{0}_out.bmp", counter++), exportOptions);
                }
            }
            // ExEnd:ConvertRangeOfDjVuPagesToSeparateImages
        }

    public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows, IntRange evaluationPartition, int horizon, bool applyLinearScaling) {
      var horizions = rows.Select(r => Math.Min(horizon, evaluationPartition.End - r));
      IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows.Zip(horizions, Enumerable.Range).SelectMany(r => r));
      IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows, horizions).SelectMany(x => x);
      OnlineCalculatorError errorState;

      double mse;
      if (applyLinearScaling && horizon == 1) { //perform normal evaluation and afterwards scale the solution and calculate the fitness value        
        var mseCalculator = new OnlineMeanSquaredErrorCalculator();
        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, mseCalculator, problemData.Dataset.Rows * horizon);
        errorState = mseCalculator.ErrorState;
        mse = mseCalculator.MeanSquaredError;
      } else if (applyLinearScaling) { //first create model to perform linear scaling and afterwards calculate fitness for the scaled model
        var model = new SymbolicTimeSeriesPrognosisModel((ISymbolicExpressionTree)solution.Clone(), interpreter, lowerEstimationLimit, upperEstimationLimit);
        model.Scale(problemData);
        var scaledSolution = model.SymbolicExpressionTree;
        estimatedValues = interpreter.GetSymbolicExpressionTreeValues(scaledSolution, problemData.Dataset, rows, horizions).SelectMany(x => x);
        var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
        mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
      } else {
        var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
        mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
      }

      if (errorState != OnlineCalculatorError.None) return Double.NaN;
      else return mse;
    }

        public void IsOverlappingTest( int min1, int max1, int min2, int max2, bool expectedResult )
        {
            IntRange range1 = new IntRange( min1, max1 );
            IntRange range2 = new IntRange( min2, max2 );

            Assert.AreEqual( expectedResult, range1.IsOverlapping( range2 ) );
        }

 protected LogicalOptUnit(string id, int resolution, IntRange indexRange, IEnumerable<OptUnit> units)
     : base(id, ExtendOptUnits(units, resolution, indexRange))
 {
     Contract.Requires(!string.IsNullOrEmpty(id));
     Contract.Requires(resolution > 1);
     Contract.Requires(!indexRange.IsFixed && indexRange.MinValue >= 0);
 }

 ISet<int> ISelectionAlgorithm.Select(IntRange fromRange, int count)
 {
     Contract.Requires(!fromRange.IsFixed);
     Contract.Requires(count > 0 && fromRange.Size >= count);
     Contract.Ensures(Contract.Result<ISet<int>>() != null);
     Contract.Ensures(Contract.Result<ISet<int>>().Count == count);
     return null;
 }

        public void ToRangeTest( int iMin, int iMax, float fMin, float fMax )
        {
            IntRange iRange = new IntRange( iMin, iMax );
            Range range = iRange;

            Assert.AreEqual( fMin, range.Min );
            Assert.AreEqual( fMax, range.Max );
        }

 internal static unsafe double AverageDist(float* valueBuffer, IntRange errorBuffer)
 {
     double s = errorBuffer.Size;
     if (s == 0.0) return 0.0;
     double v = 0.0f;
     for (int i = errorBuffer.MinValue; i <= errorBuffer.MaxValue; i++) v += (float)Math.Pow(valueBuffer[i] * 0.5, 2.0);
     return v / s;
 }

 internal static unsafe double Average(float* valueBuffer, IntRange errorBuffer)
 {
     double s = errorBuffer.Size;
     if (s == 0.0) return 0.0;
     double v = 0.0f;
     for (int i = errorBuffer.MinValue; i <= errorBuffer.MaxValue; i++) v += valueBuffer[i];
     return v / s;
 }

        internal static void Zero(float[] valueBuffer, IntRange range)
        {
            Contract.Requires(valueBuffer != null);
            Contract.Requires(valueBuffer.Length >= range.MinValue);
            Contract.Requires(valueBuffer.Length >= range.MaxValue);

            Array.Clear(valueBuffer, range.MinValue, range.Size);
        }

	// This is an overload of the SetupRoom function and has a corridor parameter that represents the corridor entering the room.
	public void SetupRoom (IntRange widthRange, IntRange heightRange, int columns, int rows, Corridor corridor, bool hasKey)
	{
		this.hasKey = hasKey;

		// Set the entering corridor direction.
		enteringCorridor = corridor.direction;

		// Set random values for width and height.
		roomWidth = widthRange.Random;
		roomHeight = heightRange.Random;

		//set the location that the key will spawn in in the room.
		keyLocation.x = widthRange.Random;
		keyLocation.y = heightRange.Random;


		switch (corridor.direction)
		{
		// If the corridor entering this room is going north...
		case Direction.North:
			// ... the height of the room mustn't go beyond the board so it must be clamped based
			// on the height of the board (rows) and the end of corridor that leads to the room.
			roomHeight = Mathf.Clamp(roomHeight, 1, rows - corridor.EndPositionY);

			// The y coordinate of the room must be at the end of the corridor (since the corridor leads to the bottom of the room).
			yPos = corridor.EndPositionY;

			// The x coordinate can be random but the left-most possibility is no further than the width
			// and the right-most possibility is that the end of the corridor is at the position of the room.
			xPos = Random.Range (corridor.EndPositionX - roomWidth + 1, corridor.EndPositionX);

			// This must be clamped to ensure that the room doesn't go off the board.
			xPos = Mathf.Clamp (xPos, 0, columns - roomWidth);
			break;
		case Direction.East:
			roomWidth = Mathf.Clamp(roomWidth, 1, columns - corridor.EndPositionX);
			xPos = corridor.EndPositionX;

			yPos = Random.Range (corridor.EndPositionY - roomHeight + 1, corridor.EndPositionY);
			yPos = Mathf.Clamp (yPos, 0, rows - roomHeight);
			break;
		case Direction.South:
			roomHeight = Mathf.Clamp (roomHeight, 1, corridor.EndPositionY);
			yPos = corridor.EndPositionY - roomHeight + 1;

			xPos = Random.Range (corridor.EndPositionX - roomWidth + 1, corridor.EndPositionX);
			xPos = Mathf.Clamp (xPos, 0, columns - roomWidth);
			break;
		case Direction.West:
			roomWidth = Mathf.Clamp (roomWidth, 1, corridor.EndPositionX);
			xPos = corridor.EndPositionX - roomWidth + 1;

			yPos = Random.Range (corridor.EndPositionY - roomHeight + 1, corridor.EndPositionY);
			yPos = Mathf.Clamp (yPos, 0, rows - roomHeight);
			break;
		}
	}

    public int yPos; //y coordinate lower left tile of the room

    #endregion Fields

    #region Methods

    //setUp the first room
    public void SetUpRoom(IntRange widthRange, IntRange heightRange, int columns, int rows)
    {
        roomWidth = widthRange.Random;
        roomHeight = heightRange.Random;

        //set the x and y coordinates so that the first room is in the middle of the board
        xPos = Mathf.RoundToInt(columns / 2f - roomWidth / 2);
        yPos = Mathf.RoundToInt(rows / 2f - roomWidth / 2);
    }

 public LogicGateOptUnit(string id, int resolution, IntRange indexRange, ISet<LogicalOperation> operations)
     : base(id, resolution, IntRange.CreateInclusive(1, indexRange.MaxValue), CreateOptUnit(resolution, operations))
 {
     Contract.Requires(!string.IsNullOrEmpty(id));
     Contract.Requires(resolution > 1);
     Contract.Requires(!indexRange.IsFixed && indexRange.MinValue >= 0);
     Contract.Requires(operations != null);
     Contract.Requires(operations.Count > 0);
 }

        public void EqualityOperatorTest( int min1, int max1, int min2, int max2, bool areEqual )
        {
            IntRange range1 = new IntRange( min1, max1 );
            IntRange range2 = new IntRange( min2, max2 );

            Assert.AreEqual( range1.Equals( range2 ), areEqual );
            Assert.AreEqual( range1 == range2, areEqual );
            Assert.AreEqual( range1 != range2, !areEqual );
        }

        internal void Push(NeuralComputationContext context, IntRange errors)
        {
            Contract.Requires(context != null);

            IncIdx(context);

            var v = errorVectors[context.ErrorVectorStack_Index];
            network.CopyBuffer(context, errors, v);
            context.ErrorVectorStack_HasVectors[context.ErrorVectorStack_Index] = true;
        }

        public void enumerable_collection_has_expected_members()
        {
            var range = new IntRange(1, 5).ToArray();

            Assert.AreEqual(1, range[0]);
            Assert.AreEqual(2, range[1]);
            Assert.AreEqual(3, range[2]);
            Assert.AreEqual(4, range[3]);
            Assert.AreEqual(5, range[4]);
        }

 public void SetupRoom(IntRange widthRange, IntRange heightRange, int columns, int rows)
 {
     roomWidth = widthRange.Random;
     roomHeight = heightRange.Random;
     
     Debug.Log(Mathf.RoundToInt(Mathf.RoundToInt(columns / 2f - roomWidth / 2f)));
     Debug.Log(Mathf.RoundToInt((rows / 2f - roomHeight / 2f)));
     
     xPos = Mathf.RoundToInt(columns / 2f - roomWidth / 2f);
     yPos = Mathf.RoundToInt(rows / 2f - roomHeight / 2f);
 }

 protected override int GetNext(IntRange fromRange, int soFar)
 {
     if (Direction == SelectionDirection.FromTop)
     {
         return fromRange.MinValue + soFar;
     }
     else
     {
         return fromRange.MaxValue + soFar;
     }
 }