internal static bool SelectionIsReadOnly(IDocument document, ISelection sel)
		{
			if (document.TextEditorProperties.SupportReadOnlySegments)
				return document.MarkerStrategy.GetMarkers(sel.Offset, sel.Length).Exists(m=>m.IsReadOnly);
			else
				return false;
		}

        static Population AdvanceGeneration(Population population, ISelection selection, ICrossover crossover, IMutation mutation)
        {
            var chromosomes = new List<Chromosome>();
            population = new Population(population.Take((int)(truncationRate * population.Count()))); // TRUNCATION
            chromosomes.AddRange(population.Take((int)(elitismRate * chromosomeCount)));  //ELITE (assuming that the chromosomes in the population are sorted by fitness (the fitter are at the top of the list)

            do
            {
                Chromosome chosen1 = selection.Select(population),
                           chosen2 = selection.Select(population);

                if (random.NextDouble() < crossoverRate)
                {
                    var children = crossover.Crossover(chosen1, chosen2); // CROSSOVER
                    chosen1 = children.Item1;
                    chosen2 = children.Item2;
                }

                if (random.NextDouble() < mutationRate)
                {
                    chosen1 = mutation.Mutate(chosen1); // MUTATION
                }

                if (random.NextDouble() < mutationRate)
                {
                    chosen2 = mutation.Mutate(chosen2); // MUTATION
                }

                chromosomes.Add(chosen1);
                chromosomes.Add(chosen2);
            } while (chromosomes.Count < chromosomeCount);

            return new Population(chromosomes);
        }

		public FindJumpInstructionsVisitor(MethodDeclaration method, ISelection selection)
		{
			this.method = method;
			this.selection = selection;
			this.labels = new List<LabelStatement>();
			this.cases = new List<CaseLabel>();
		}

        public Population(int size, IFitnessFunction fitnessFunction, IReproduction reproductionFunction, INodeMutator mutator, ISelection selection)
        {
            this.populationSize = size;
            this.fitnessFunction = fitnessFunction;
            this.reproductionFunction = reproductionFunction;
            this.mutator = mutator;
            this.selector = selection;

            this.fitnessFunction.Initialise();

            // Create the initial population
            for (int i = 0; i < size; i++)
            {
                try
                {
                    NodeContext zeroContext = new NodeContext();
                    zeroContext.AvailableCollections = fitnessFunction.GetCollections();
                    zeroContext.AvailableInputs = fitnessFunction.GetInputs();

                    INode candidateNode = NodeFactory.GenerateNode(zeroContext);

                    // Make sure we have a decent candidate (i.e. not too large)
                    double fitness = this.fitnessFunction.CalculateFitness(candidateNode);
                    if (fitness == Double.MaxValue) continue;

                    this.population.Add(NodeFactory.GenerateNode(zeroContext));
                }
                catch (StackOverflowException)
                {
                }
            }
        }

 /// <summary>
 /// Constructor
 /// </summary>
 public Population(int size,
     IIndividual ancestor,
     IFitnessFunction fitnessFunction,
     ISelection selectionMethod,
     int numberIterations)
 {
     FitnessFunction = fitnessFunction;
     Selection = Replacement = selectionMethod;
     PopulationSize = size;
     firstSelectionCount = size;
     firstReplacementCount = ((int)(size / 2)) % 2 == 0 ? (int)(size / 2) : (int)(size / 2) + 1;
     iterations = numberIterations;
     // Agregar el ancestro a la poblacion
     ancestor.Evaluate(fitnessFunction);
     Individuals.Add(ancestor);
     // Se agregan mas cromosomas a la poblacion
     for (int i = 1; i < size; i++)
     {
         // Se crea un nuevo cromosoma al azar
         IIndividual c = ancestor.CreateRandomIndividual();
         // se calcula su aptitud
         c.Evaluate(fitnessFunction);
         // Se lo agrega a la poblacion
         Individuals.Add(c);
     }
 }

 public ProxySelection(ISelection selection)
 {
     _selection = selection;
     _numberOfGoodStarts = 0;
     _numberOfBadStarts = 0;
     _progressList = new List<double> { 1 };
     _progress = OneHundredPercent;
 }

		public MethodExtractorBase(ICSharpCode.TextEditor.TextEditorControl textEditor, ISelection selection)
		{
			this.currentDocument = textEditor.Document;
			this.textEditor = textEditor;
			this.currentSelection = selection;
			
			this.start = new Location(this.currentSelection.StartPosition.Column + 1, this.currentSelection.StartPosition.Line + 1);
			this.end = new Location(this.currentSelection.EndPosition.Column + 1, this.currentSelection.EndPosition.Line + 1);
		}

        public DecreaseSelection(IDocument document, ISelection selection)
        {
            if (document == null) throw new ArgumentNullException("document");
            if (selection == null) throw new ArgumentNullException("selection");
            this.itsDocument = document;
            itsOffset = selection.Offset + 1;
            itsEndOffset = selection.EndOffset - 1;;

            itsSelectedText = document.TextContent.Substring(Offset, EndOffset-Offset);
        }

		public static IProject getProjectFromSelection(ISelection selection) {
			var resource = getResourceFromSelection(selection);
			if (resource == null) {
				return null;
			}
			if (resource.getType() == IResource.PROJECT) {
				return (IProject)resource;
			} else {
				return resource.getProject();
			}
		}

		public static Complex[] GetComplexArrayFrom1DSelection(ISelection selection) {
			int size = selection.Size;

			var result = new Complex[size];
			var i = 0;
			foreach(var v in selection){
				result[i] = new Complex(v[0], 0);
				i++;
			}

			return result;
		}

		internal static bool SelectionIsReadOnly(IDocument document, ISelection sel)
		{
            //johnny
            //if (document.TextEditorProperties.SupportReadOnlySegments)
            //    return document.MarkerStrategy.GetMarkers(sel.Offset, sel.Length).Exists(m=>m.IsReadOnly);
            if (document.TextEditorProperties.SupportReadOnlySegments)
            {
                return document.MarkerStrategy.GetMarkers(sel.Offset, sel.Length).Exists(delegate(TextMarker m) { return m.IsReadOnly; });
            }
            else
                return false;
		}

 internal static void CallAllProperties(ISelection selection)
 {
     selection.ContainsOffset(0);
     selection.ContainsPosition(TextLocation.Empty);
     int offset = selection.EndOffset;
     TextLocation position = selection.EndPosition;
     bool empty = selection.IsEmpty;
     bool rectangularSelection = selection.IsRectangularSelection;
     int length = selection.Length;
     int offset2 = selection.Offset;
     string text = selection.SelectedText;
     TextLocation startPosition = selection.StartPosition;
 }

        /// <summary>
        /// Initialize a new instance of the ExtendBlockSelection class.
        /// </summary>
        /// <param name="document">Object that implements the IDocument interface.</param>
        /// <param name="selection">The current selection.</param>
        public ExtendBlockSelection(IDocument document, ISelection selection)
        {
            if (document == null)
                throw new ArgumentNullException("document");

            if (selection == null)
                throw new ArgumentNullException("selection");

            itsDocument = document;
            itsOffset = selection.Offset;
            itsEndOffset = selection.EndOffset;

            ExtendCurrentSelection();
        }

        private static ISelection ReverseSelection(ISelection selection)
        {
            var list = new ArrayList();

            if (selection != null && selection.Items != null)
            {
                foreach (object o in selection.Items)
                    list.Add(o);

                list.Reverse();
            }

            return new Selection(list);
        }

        public TwoIslandsPopulation(int size, IFitnessFunction fitnessFunction, IReproduction reproductionFunction, INodeMutator mutator, ISelection selection)
        {
            this.populationSize = size;
            this.fitnessFunction = fitnessFunction;
            this.reproductionFunction = reproductionFunction;
            this.mutator = mutator;
            this.selector = selection;

            this.fitnessFunction.Initialise();

            // The main population needs initializing
            this.IntialisePopulation(this.mainPopulation);

            this.IntialisePopulation(this.secondaryPopulation);
        }

 public GEngine(AbstractTrack[] tracks, int pCrossingover, int pMutation, IFitnessFunction fitnessFunction, IMutation mutation, ICrossingover crossingover, ISelection selection)
 {
     _countOfPerson = tracks.Length;
     _tracks = new AbstractTrack[_countOfPerson];
     _tracks = tracks;
     _pCrossingover = pCrossingover;
     _pMutation = pMutation;
     _fitnessFunction = fitnessFunction;
     _mutation = mutation;
     _crossingover = crossingover;
     _selection = selection;
     _geneticsDataSet = new DB_GeneticsDataSet();
     _launchId = Guid.NewGuid();
     _launchTableAdapter = new DB_GeneticsDataSetTableAdapters.LaunchesTableAdapter();
     _personsTableAdapter = new DB_GeneticsDataSetTableAdapters.PersonsTableAdapter();
 }

        public GeneticAlgorithm(double crossoverRate, double mutationRate, double elitism, double truncation, double chromosomeCount, ISelection selection, ICrossover crossover, IMutation mutation, FitnessCalculator fitnessCalculator)
        {
            CrossoverRate = crossoverRate;
            MutationRate = mutationRate;
            ElitismRate = elitism;
            TruncationRate = truncation;
            ChromosomeCount = chromosomeCount;

            this.selection = selection;
            this.mutation = mutation;
            this.crossover = crossover;

            this.fitnessCalculator = fitnessCalculator;

            random = new Random();
        }

		/// <remarks>
		/// Clears the selection and sets a new selection
		/// using the given <see cref="ISelection"/> object.
		/// </remarks>
		public void SetSelection(ISelection selection)
		{
			if (selection != null) {
				if (SelectionCollection.Count == 1 && 
				    selection.StartPosition == SelectionCollection[0].StartPosition &&
				    selection.EndPosition == SelectionCollection[0].EndPosition ) {
					return;
				}
				ClearWithoutUpdate();
				selectionCollection.Add(selection);
				document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.LinesBetween, selection.StartPosition.Y, selection.EndPosition.Y));
				document.OnUpdateCommited();
				OnSelectionChanged(EventArgs.Empty);
			} else {
				ClearSelection();
			}
		}

		void InsertTabs(IDocument document, ISelection selection, int y1, int y2)
		{
			string indentationString = GetIndentationString(document);
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (i == y2 && i == selection.EndPosition.Y && selection.EndPosition.X  == 0) {
					continue;
				}
				
				// this bit is optional - but useful if you are using block tabbing to sort out
				// a source file with a mixture of tabs and spaces
//				string newLine = document.GetText(line.Offset,line.Length);
//				document.Replace(line.Offset,line.Length,newLine);
				
				document.Insert(line.Offset, indentationString);
			}
		}

		void InsertTabs(IDocument document, ISelection selection, int y1, int y2)
		{
			int    redocounter = 0;
			string indentationString = GetIndentationString(document);
			for (int i = y2; i >= y1; --i) {
				LineSegment line = document.GetLineSegment(i);
				if (i == y2 && i == selection.EndPosition.Y && selection.EndPosition.X  == 0) {
					continue;
				}
				
				document.Insert(line.Offset, indentationString);
				++redocounter;
			}
			
			if (redocounter > 0) {
				document.UndoStack.UndoLast(redocounter); // redo the whole operation (not the single deletes)
			}
		}