public void SpeedTest()
{
Func <PointInt, IEnumerable <PointInt> > getNeighbors = p => new[]
{
new PointInt(p.X - 1, p.Y + 0), // L
new PointInt(p.X + 1, p.Y + 0), // R
new PointInt(p.X + 0, p.Y - 1), // B
new PointInt(p.X + 0, p.Y + 1), // T
new PointInt(p.X - 1, p.Y + 1), // TL
new PointInt(p.X + 1, p.Y + 1), // TR
new PointInt(p.X - 1, p.Y - 1), // BL
new PointInt(p.X + 1, p.Y - 1), // BR
};
Func <PointInt, PointInt, double> getScoreBetween = (p1, p2) =>
{
var dx = p1.X - p2.X;
var dy = p1.Y - p2.Y;
return(Math.Sqrt(dx * dx + dy * dy));
};
var rand = new Random(42);
for (int j = 0; j < 3; j++)
{
var start = new PointInt(rand.Next(1000), rand.Next(1000));
var destination = new PointInt(rand.Next(1000), rand.Next(1000));
for (int i = 0; i < 4; i++)
{
RandomMeldablePriorityTree <AStarUtilities.EncapsulatedSearchNode <PointInt> > .ChildrenCount = i + 2;
_output.WriteLine("Starting run with {0} children.", i + 2);
Func <PointInt, double> getHeuristicScore = p =>
{
var dx = p.X - destination.X;
var dy = p.Y - destination.Y;
return(Math.Sqrt(dx * dx + dy * dy));
};
_output.WriteLine("Going from {0} to {1}", start, destination);
var sw = Stopwatch.StartNew();
double distance; bool success;
var results = AStarUtilities.FindMinimalPath(start, destination, getNeighbors, getScoreBetween, getHeuristicScore, out distance, out success);
_output.WriteLine("Done in {0}s.", sw.Elapsed.TotalSeconds);
_output.WriteLine("Expansions: {0}", AStarUtilities.LastExpansionCount);
_output.WriteLine("Result Count: {0}", results.Count);
_output.WriteLine("Distance: {0}", distance);
Assert.True(success);
Assert.Equal(start, results.First());
Assert.Equal(destination, results.Last());
}
}
RandomMeldablePriorityTree <AStarUtilities.EncapsulatedSearchNode <PointInt> > .ChildrenCount = 4;
}
public void VerifyBidirectional()
{
Func <PointInt, IEnumerable <PointInt> > getNeighbors = p => new[]
{
new PointInt(p.X - 1, p.Y + 0), // L
new PointInt(p.X + 1, p.Y + 0), // R
new PointInt(p.X + 0, p.Y - 1), // B
new PointInt(p.X + 0, p.Y + 1), // T
};
Func <PointInt, PointInt, double> getScoreBetween = (p1, p2) =>
{
// Manhatten Distance
return(Math.Abs(p1.X - p2.X) + Math.Abs(p1.Y - p2.Y));
};
var rand = new Random(42);
var start = new PointInt(0, 0);
var destination = new PointInt(400, 400);
Func <PointInt, bool, double> getHeuristicScore = (p, backward) =>
{
var dx = backward ? (p.X - start.X) : (p.X - destination.X);
var dy = backward ? (p.Y - start.Y) : (p.Y - destination.Y);
return(Math.Sqrt(dx * dx + dy * dy));
};
_output.WriteLine("Going from {0} to {1}", start, destination);
var sw = Stopwatch.StartNew();
double distance, distanceControl; bool success;
var results = AStarUtilities.BidirectionalFindMinimalPath(start, destination, getNeighbors, getScoreBetween, getHeuristicScore, out distance, out success);
_output.WriteLine("Done in {0}s.", sw.Elapsed.TotalSeconds);
_output.WriteLine("Expansions: {0}", AStarUtilities.LastExpansionCount);
_output.WriteLine("Result Count: {0}", results.Count);
_output.WriteLine("Distance: {0}", distance);
Assert.True(success);
Assert.Equal(start, results.First());
Assert.Equal(destination, results.Last());
sw.Restart();
var resultsControl = AStarUtilities.FindMinimalPath(start, destination, getNeighbors, getScoreBetween, p => getHeuristicScore(p, false), out distanceControl, out success);
_output.WriteLine("Control Done in {0}s.", sw.Elapsed.TotalSeconds);
_output.WriteLine("Expansions: {0}", AStarUtilities.LastExpansionCount);
_output.WriteLine("Result Count: {0}", resultsControl.Count);
_output.WriteLine("Distance: {0}", distanceControl);
Assert.True(success);
Assert.Equal(start, resultsControl.First());
Assert.Equal(destination, resultsControl.Last());
Assert.Equal(distanceControl, distance);
}
public IEnumerable <State> PlanAssembly(State initial)
{
var target = new State(initial.FloorCount - 1, TargetFloors(initial.FloorCount, initial.MaterialCount),
TargetFloors(initial.FloorCount, initial.MaterialCount));
Func <State, double> heuristic =
s =>
Enumerable.Range(0, s.FloorCount - 1)
.Sum(i => s.ChipFloors[i].Cardinality() + s.GeneratorFloors[i].Cardinality());
return
(AStarUtilities.FindMinimalPath(initial, target, s => s.PossibleMoves().Where(move => move.IsSafe()),
(s1, s2) => 1, heuristic).Result);
}
public void RunSmallGrid()
{
// |_|_|X|_|_|
// |S|_|X|_|E|
// |_|_|X|_|_|
// |_|_|_|_|_|
var start = new PointInt(0, 2);
Func <PointInt, IEnumerable <PointInt> > getNeighbors = p => new List <PointInt>(4)
{
new PointInt(p.X - 1, p.Y),
new PointInt(p.X + 1, p.Y),
new PointInt(p.X, p.Y - 1),
new PointInt(p.X, p.Y + 1),
};
Func <PointInt, PointInt, double> getScoreBetween = (p1, p2) =>
{
if (p2.X == 2 && p2.Y > 0)
{
return(double.PositiveInfinity);
}
return(Math.Abs(p1.X - p2.X) + Math.Abs(p1.Y - p2.Y));
};
var destination = new PointInt(4, 2);
Func <PointInt, double> getHeuristicScore = p =>
{
var dx = p.X - destination.X;
var dy = p.Y - destination.Y;
return(Math.Sqrt(dx * dx + dy * dy));
};
double distance; bool success;
var results = AStarUtilities.FindMinimalPath(start, destination, getNeighbors, getScoreBetween, getHeuristicScore, out distance, out success);
Assert.True(success);
Assert.Equal(9, results.Count);
Assert.Equal(start, results[0]);
Assert.Equal(new PointInt(2, 0), results[4]);
Assert.Equal(destination, results[8]);
}
public void ReadmeExample()
{
Func <PointInt, IEnumerable <PointInt> > getNeighbors = p => new[]
{
new PointInt(p.X - 1, p.Y + 0), // L
new PointInt(p.X + 1, p.Y + 0), // R
new PointInt(p.X + 0, p.Y - 1), // B
new PointInt(p.X + 0, p.Y + 1), // T
};
Func <PointInt, PointInt, double> getScoreBetween = (p1, p2) =>
{
// Manhatten Distance
return(Math.Abs(p1.X - p2.X) + Math.Abs(p1.Y - p2.Y));
};
var rand = new Random(42);
var start = new PointInt(rand.Next(1000), rand.Next(1000));
var destination = new PointInt(rand.Next(1000), rand.Next(1000));
Func <PointInt, double> getHeuristicScore = p =>
{
return(Math.Abs(p.X - destination.X) + Math.Abs(p.Y - destination.Y));
};
_output.WriteLine("Going from {0} to {1}", start, destination);
var sw = Stopwatch.StartNew();
double distance; bool success;
var results = AStarUtilities.FindMinimalPath(start, destination, getNeighbors, getScoreBetween, getHeuristicScore, out distance, out success);
_output.WriteLine("Done in {0}s.", sw.Elapsed.TotalSeconds);
_output.WriteLine("Expansions: {0}", AStarUtilities.LastExpansionCount);
_output.WriteLine("Result Count: {0}", results.Count);
_output.WriteLine("Distance: {0}", distance);
Assert.True(success);
Assert.Equal(start, results.First());
Assert.Equal(destination, results.Last());
}
public IEnumerable <Cubicle> ShortestPath(Cubicle start, Cubicle destination)
{
return(AStarUtilities.FindMinimalPath(start, destination, cubicle => this.Maze.Neighbors(cubicle),
(c1, c2) => 1, c => c.ManhattanDistance(destination)).Result);
}
