//--------------------------------------------------------------------- private void AssertAreEqual(Location[] expected, Location[] actual) { Assert.AreEqual(expected.Length, actual.Length); for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], actual[i]); }
public void ActiveSiteIndexer_Location() { int index = 0; Location? nextActiveSite; if (index < activeSites.Count) nextActiveSite = activeSites[index]; else nextActiveSite = null; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { Location location = new Location(row, col); ActiveSite site = landscape[location]; if (nextActiveSite != null && nextActiveSite == location) { Assert.AreEqual(location, site.Location); Assert.AreEqual(index, site.DataIndex); Assert.AreEqual(landscape, site.Landscape); Assert.AreEqual(true, site.IsActive); index++; if (index < activeSites.Count) nextActiveSite = activeSites[index]; else nextActiveSite = null; } else Assert.IsNull(site); } }
public void Init() { string[] rows = new string[] { "....X..", "...XX.X", ".......", "...XXX.", "X.X.X.X", "XXXXXXX" }; bool [,] activeSites = Bool.Make2DimArray(rows, "X"); mixedGrid = new DataGrid<bool>(activeSites); mixedMap = new ActiveSiteMap(mixedGrid); bool found_1stActive = false; bool found_1stInactive = false; for (uint row = 1; row <= mixedGrid.Rows; ++row) { for (uint column = 1; column <= mixedGrid.Columns; ++column) { if (mixedGrid[row, column]) { if (! found_1stActive) { mixed_1stActive = new Location(row, column); found_1stActive = true; } } else { if (! found_1stInactive) { mixed_1stInactive = new Location(row, column); found_1stInactive = true; } } } } }
//--------------------------------------------------------------------- /// <summary> /// Initializes a new instance for a site on a landscape. /// </summary> /// <param name="landscape"> /// The landscape where the site is located. /// </param> /// <param name="location"> /// The location of the site. /// </param> /// <param name="dataIndex"> /// The index of the site's data for site variables. /// </param> internal protected Site(ILandscape landscape, Location location, uint dataIndex) { Debug.Assert( landscape.IsValid(location) ); this.landscape = landscape; this.locationAndIndex = new LocationAndIndex(location, dataIndex); }
//--------------------------------------------------------------------- internal MutableSite(ILandscape landscape, Location location, bool isActive, uint dataIndex) : base(landscape, location, dataIndex) { this.isActive = isActive; }
//--------------------------------------------------------------------- /// <summary> /// Initializes a new instance for a site on a landscape. /// </summary> /// <param name="landscape"> /// The landscape where the site is located. /// </param> /// <param name="location"> /// The location of the site. /// </param> /// <param name="dataIndex"> /// The index of the site's data for site variables. /// </param> internal protected Site(ILandscape landscape, Location location, uint dataIndex) { Debug.Assert( landscape.IsValid(location) ); this.landscape = landscape; this.location = location; this.index = dataIndex; }
//--------------------------------------------------------------------- private void CheckNeighbor(Site neighbor, Location expectedLocation) { Assert.IsNotNull(neighbor); Assert.AreEqual(expectedLocation, neighbor.Location); Assert.AreEqual(activeSites[expectedLocation.Row - 1, expectedLocation.Column - 1], neighbor.IsActive); }
//--------------------------------------------------------------------- internal void SetAll(Landscape landscape, Location location, bool isActive, uint dataIndex) { this.Landscape = landscape; this.LocationAndIndex.Location = location; this.LocationAndIndex.Index = dataIndex; this.isActive = isActive; }
//--------------------------------------------------------------------- public static List<Location> ReadLocations(string path) { List<Location> sites = new List<Location>(); Util.FileLineReader reader = new Util.FileLineReader(path); string line; while ((line = reader.ReadLine()) != null) { string[] rowAndCol = line.Split(null); Assert.AreEqual(2, rowAndCol.Length); uint row = uint.Parse(rowAndCol[0]); uint col = uint.Parse(rowAndCol[1]); Location loc = new Location(row, col); sites.Add(loc); } reader.Close(); return sites; }
public void MixedLandscape() { // columns: 123456789 ILandscape landscape = MakeLandscape( "---------", // row 1 "---XXXX--", // row 2 "--XXXXX--", // row 3 "--XXXXXX-", // row 4 "-XXX--XX-", // row 5 "-XX---XXX", // row 6 "--XX--X--"); // row 7 ISiteVar<bool> disturbed = landscape.NewSiteVar<bool>(); Location[] disturbedLocs = new Location[] { new Location(2,6), new Location(3,4), new Location(3,5), new Location(5,7), new Location(5,8), new Location(6,2), new Location(7,7) }; foreach (Location loc in disturbedLocs) { ActiveSite site = landscape[loc]; Assert.IsNotNull(site); disturbed[site] = true; } DisturbedSiteEnumerator disturbedSites; disturbedSites = new DisturbedSiteEnumerator(landscape, disturbed); int count = 0; foreach (ActiveSite site in disturbedSites) { count++; Assert.IsTrue(count <= disturbedLocs.Length); Assert.AreEqual(disturbedLocs[count-1], site.Location); } Assert.AreEqual(count, disturbedLocs.Length); }
//--------------------------------------------------------------------- public uint this[Location location] { get { uint? rowOffset = Interval.Search(rowIntervals, location.Row); if (rowOffset == null) return this.count; ActiveRow activeRow = activeRows[(int)rowOffset.Value]; List<Interval> colIntervalsInRow = columnIntervals.GetRange((int) activeRow.FirstIntervalOffset, (int) activeRow.IntervalCount); uint? colOffset = Interval.Search(colIntervalsInRow, location.Column); if (colOffset == null) return this.count; else return colOffset.Value; } }
public void Enumerator() { int cellCount = 0; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { cellCount++; Location loc = new Location(row, col); grid[loc] = cellCount; } cellCount = 0; foreach (int i in grid) { cellCount++; Assert.AreEqual(cellCount, i); } }
public void LocationIndexerColumnTooBig() { Location badLoc = new Location(1, dimensions.Columns + 1); grid[badLoc] = 0; }
public void LocationIndexerRowTooBig() { Location badLoc = new Location(dimensions.Rows + 1, 1); grid[badLoc] = 0; }
public void LocationIndexerColumn0() { Location badLoc = new Location(1, 0); grid[badLoc] = 0; }
//--------------------------------------------------------------------- internal ImmutableInactiveSite(ILandscape landscape, Location location, uint dataIndex) : base(landscape, location, dataIndex) { }
public void Grid5x3True() { bool[,] array = new bool[,] { {true, true, true}, {true, true, true}, {true, true, true}, {true, true, true}, {true, true, true} }; DataGrid<bool> grid = new DataGrid<bool>(array); ActiveSiteMap map = new ActiveSiteMap(grid); Assert.AreEqual(grid.Count, map.Count); int index = 0; Location location = new Location(1,1); foreach (LocationAndIndex entry in map) { index++; Assert.IsTrue(index <= map.Count); Assert.AreEqual(location, entry.Location); Assert.AreEqual((uint) index, entry.Index); location = RowMajor.Next(location, grid.Columns); } Assert.AreEqual(map.Count, index); Assert.AreEqual(new Location(1,1), map.FirstActive.Location); Assert.AreEqual(1, map.FirstActive.Index); Assert.IsNull(map.FirstInactive); }
public void Enumerator() { bool cellValue = false; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { cellValue = !cellValue; Location loc = new Location(row, col); grid[loc] = cellValue; } cellValue = false; foreach (bool b in grid) { cellValue = !cellValue; Assert.AreEqual(cellValue, b); } }
public void Test15_SetRow() { Location myLoc = new Location(98, 321); myLoc.Row = 44; Assert.AreEqual(44, myLoc.Row); Assert.AreEqual(new Location(44, 321), myLoc); }
public void IndexerLocation() { int index = 0; Location? nextActiveSite; if (index < activeSites.Count) nextActiveSite = activeSites[index]; else nextActiveSite = null; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { Location location = new Location(row, col); if (nextActiveSite != null && nextActiveSite == location) { Assert.AreEqual(index+1, map[location]); index++; if (index < activeSites.Count) nextActiveSite = activeSites[index]; else nextActiveSite = null; } else Assert.AreEqual(ActiveSiteMap.InactiveSiteDataIndex, map[location]); } }
public void Test16_SetColumn() { Location myLoc = new Location(98, 321); myLoc.Column = 7; Assert.AreEqual(7, myLoc.Column); Assert.AreEqual(new Location(98, 7), myLoc); }
public void Init() { loc_1234_987 = new Location(1234, 987); }
//--------------------------------------------------------------------- /// <summary> /// Computes the absolute location of a site's neighbor. /// </summary> /// <param name="siteLoc"> /// The site's location. /// </param> /// <param name="neighborRelLoc"> /// The location of the neighbor relative to the site. /// </param> /// <param name="neighborLoc"> /// The neighbor's location on the landscape. /// </param> /// <returns> /// true if the neighbor is on the landscape; false otherwise (in /// which case the /// </returns> public Location? ComputeNeighborLocation(Location siteLoc, RelativeLocation neighborRelLoc) { long neighborRow = siteLoc.Row + neighborRelLoc.Row; long neighborColumn = siteLoc.Column + neighborRelLoc.Column; if (neighborRow < 0 || neighborRow > uint.MaxValue || neighborColumn < 0 || neighborColumn > uint.MaxValue) return null; else return new Location((uint) neighborRow, (uint) neighborColumn); }
//----------------------------------------------------------------- public Entry(Location location, uint index) { this.location = location; this.index = index; }
//--------------------------------------------------------------------- public uint this[Location location] { get { uint? rowOffset = Interval.Search(location.Row, rowIntervals, 0, rowIntervals.Count); if (rowOffset == null) return this.count; ActiveRow activeRow = activeRows[(int)rowOffset.Value]; uint? colOffset = Interval.Search(location.Column, columnIntervals, (int) activeRow.FirstIntervalOffset, (int) activeRow.IntervalCount); if (colOffset == null) return this.count; else return colOffset.Value; } }
public void LocationIndexer() { int cellCount = 0; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { cellCount++; Location loc = new Location(row, col); grid[loc] = cellCount; Assert.AreEqual(cellCount, grid[loc]); } }
public void LocationIndexerRow0() { Location badLoc = new Location(0, 1); grid[badLoc] = 0; }
//--------------------------------------------------------------------- public static bool Algorithm(ISpecies species, ActiveSite site) { if (species.EffectiveSeedDist == EffectiveSeedDist.Universal) return UniversalDispersal.Algorithm(species, site); if (! Reproduction.SufficientLight(species, site) || ! Reproduction.Establish(species, site)) return false; if (Reproduction.MaturePresent(species, site)) return true; int row = (int) site.Location.Row; int col = (int) site.Location.Column; int cellDiam = (int) Model.CellLength; int EffD = species.EffectiveSeedDist; int MaxD = species.MaxSeedDist; double ratio = 0.95;//the portion of the probability in the effective distance //lambda1 parameterized for effective distance double lambda1 = Math.Log((1-ratio)/EffD); //lambda2 parameterized for maximum distance double lambda2 = Math.Log(0.01)/MaxD; double lowBound=0, upBound=0; //bool suitableDist=false;//flag to trigger if seed (plural) can get to a site based on distance probability double distanceProb=0.0; int pixRange = Math.Max((int) ((float) MaxD / (float) cellDiam), 1); int maxrow = (int) Math.Min(row+pixRange, Model.Landscape.Rows); int minrow = Math.Max(row-pixRange, 1); for (int i=minrow; i<=maxrow; i++) { int x1, x2; //float b = 5.0; findX1X2(out x1, out x2, col, row, i, pixRange); for (int j=x1; j<=x2;j++) { Location loc = new Location((uint) i, (uint) j); if (Model.Landscape.GetSite(loc, ref neighbor) && neighbor.IsActive) { if (Reproduction.MaturePresent(species, neighbor)) { float distance=(float)Math.Sqrt((float)((row-i)*(row-i)+(col-j)*(col-j))) * cellDiam; //Pythag //set lower boundary to the theoretical (straight-line) edge of parent cell lowBound = distance - cellDiam; if(lowBound < 0) lowBound=0; //set upper boundary to the outer theoretical boundary of the cell upBound = distance; if(cellDiam<=EffD) {//Draw probabilities from either EffD or MaxD curves if(distance<=(float)EffD) {//BCW May 04 distanceProb = Math.Exp(lambda1*lowBound) - Math.Exp(lambda1*upBound); } else {//BCW May 04 distanceProb = (1-ratio)*Math.Exp(lambda2*(lowBound-EffD)) - (1-ratio)*Math.Exp(lambda2*(upBound-EffD)); } } else { if(distance<=cellDiam) {//Draw probabilities from both EffD and MaxD curves distanceProb = Math.Exp(lambda1*lowBound)-(1-ratio)*Math.Exp(lambda2*(upBound-EffD)); } else { distanceProb = (1-ratio)*Math.Exp(lambda2*(lowBound-EffD)) - (1-ratio)*Math.Exp(lambda2*(upBound-EffD)); } } if (distanceProb > Landis.Util.Random.GenerateUniform())// && frand() < l->probRepro(speciesNum)) Modified BCW May '04 { // success = sites(row,col)->addNewCohort(s, sa, 10); return true; } } } // if neighor is active } // for each column, j, of current row in neighborhood } // for each row, i, in the neighborhood // Search failed. return false; }
//--------------------------------------------------------------------- /// <summary> /// The data index for a particular site. /// </summary> /// <exception cref="System.IndexOutOfRangeException"> /// The location's row is 0 or > the # of rows in the map, or the /// location's column is 0 or > the # of columns in the map. /// </exception> public uint this[Location location] { get { return indexes[location.Row-1, location.Column-1]; } }
public void LocationIndexer() { bool cellValue = false; for (uint row = 1; row <= grid.Rows; ++row) for (uint col = 1; col <= grid.Columns; ++col) { cellValue = !cellValue; Location loc = new Location(row, col); grid[loc] = cellValue; Assert.AreEqual(cellValue, grid[loc]); } }