public static bool Algorithm(ISpecies species,
                              ActiveSite site)
 {
     return(Reproduction.SufficientResources(species, site) &&
            Reproduction.Establish(species, site) &&
            Reproduction.MaturePresent(species, site));
 }
        //---------------------------------------------------------------------

        public static bool Algorithm(ISpecies species,
                                     ActiveSite site)
        {
            if (species.EffectiveSeedDist == Universal)
            {
                return(UniversalDispersal.Algorithm(species, site));
            }

            if (!Reproduction.SufficientResources(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: insufficient light",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (!Reproduction.Establish(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: cannot establish",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (Reproduction.MaturePresent(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} seeded on site",
                                    site.Location, species.Name);
                }
                return(true);
            }

            if (isDebugEnabled)
            {
                log.DebugFormat("site {0}: search neighbors for {1}",
                                site.Location, species.Name);
            }

            foreach (RelativeLocationWeighted reloc in Seeding.MaxSeedQuarterNeighborhood)
            {
                double distance = reloc.Weight;
                int    rRow     = (int)reloc.Location.Row;
                int    rCol     = (int)reloc.Location.Column;

                double EffD = (double)species.EffectiveSeedDist;
                double MaxD = (double)species.MaxSeedDist;

                if (distance > MaxD + ((double)Model.Core.CellLength / 2.0 * 1.414))
                {
                    return(false);  //Check no further
                }
                double dispersalProb = GetDispersalProbability(EffD, MaxD, distance);

                //First check the Southeast quadrant:
                if (dispersalProb > Model.Core.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(reloc.Location);
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, (ActiveSite)neighbor))
                        {
                            return(true);
                        }
                    }
                }

                //Next, check all other quadrants:
                if (dispersalProb > Model.Core.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow * -1, rCol));
                    if (rCol == 0)
                    {
                        neighbor = site.GetNeighbor(new RelativeLocation(0, rRow));
                    }
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, (ActiveSite)neighbor))
                        {
                            return(true);
                        }
                    }
                }

                if (dispersalProb > Model.Core.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow * -1, rCol * -1));
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, (ActiveSite)neighbor))
                        {
                            return(true);
                        }
                    }
                }

                if (dispersalProb > Model.Core.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow, rCol * -1));
                    if (rCol == 0)
                    {
                        neighbor = site.GetNeighbor(new RelativeLocation(0, rRow * -1));
                    }
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, (ActiveSite)neighbor))
                        {
                            return(true);
                        }
                    }
                }
            }  // end foreach relativelocation

            return(false);
        }