public NodePair(NodePair p) : this(NQuantLibcPINVOKE.new_NodePair__SWIG_2(NodePair.getCPtr(p)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
private void MultithreadedOverlap(int i)
{
NodePair overlap = multithreadingSourceOverlaps.Elements[i];
//Note: It's okay not to check to see if a and b are equal and leaf nodes, because the systems which added nodes to the list already did it.
overlap.a.GetOverlaps(overlap.b, this);
}
/* This is the recursive function that converts the binary tree to linked list and returns the Nodepair containaining the head and tail */
public NodePair ConvertMethod1(BiNode root)
{
if (root == null)
{
return(null);
}
//Part1 maintains the head and builds the list forward ..adding tail
NodePair part1 = ConvertMethod1(root.Node1);
//part2 maintains the tail and build the list backwards..adding head
NodePair part2 = ConvertMethod1(root.Node2);
//remember part1 will be nodepair with head and tail
if (part1 != null)
{
//we want to merge and form linked list in this fashion Head--->Tail + root
Concat(part1.Tail, root);
}
if (part2 != null)
{
//part2 maintains the tail and build the list backwards..adding head
//in this fashion root + head ---> tail
Concat(root, part2.Head);
}
NodePair result = new NodePair(part1 == null ? root : part1.Head,
part2 == null ? root : part2.Tail);
return(result);
}
//增加點和線到 chart data
public void AddNodeLink(ChartData chartData, NodePair pair)
{
//確認線不存在，新增node 和 link
bool ExistLinkFlag = CheckExistedLink(chartData, pair.Link);
if (ExistLinkFlag)
{
//string imageUrl = "../Image/person.png";
Color color = Color.FromArgb(ImportHelper.RandColor.Next(256), ImportHelper.RandColor.Next(170, 256), ImportHelper.RandColor.Next(200, 256));
string colorStr = "#" + color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2");
//確認點不存在，新增node
if (!CheckExistedNode(chartData, pair.Node1.ID))
{
pair.Node1.Color = colorStr;
chartData.Items.Add(pair.Node1);
}
//確認點不存在，新增node
if (!CheckExistedNode(chartData, pair.Node2.ID))
{
pair.Node2.Color = colorStr;
chartData.Items.Add(pair.Node2);
}
//加入線
pair.Link.Color = colorStr;
pair.Link.ID1 = pair.Node1.ID;
pair.Link.ID2 = pair.Node2.ID;
chartData.Items.Add(pair.Link);
}
}
NodePair GetRandomPair()
{
NodePair pair = new NodePair(Random.Range(0, 8), Random.Range(0, 8));
if (pair.first == pair.second)
{
pair = GetRandomPair();
}
bool foundMatchingPair = false;
foreach (NodePair n in currentPairs)
{
if (n.first == pair.first && n.second == pair.second)
{
foundMatchingPair = true;
}
}
if (foundMatchingPair)
{
return(GetRandomPair());
}
else
{
return(pair);
}
}
private void WriteWrongDelta(NodePair np)
{
_sw.WriteLine("Перемещения в узле в мoдели и в ПЕ различны");
_sw.WriteLine("\tМодель:");
_sw.WriteLine($"\tX: {np.DeltaMain.X}");
_sw.WriteLine($"\tY: {np.DeltaMain.Y}");
_sw.WriteLine($"\tZ: {np.DeltaMain.Z}");
_sw.WriteLine($"\tUX: {np.DeltaMain.UX}");
_sw.WriteLine($"\tUY: {np.DeltaMain.UY}");
_sw.WriteLine($"\tUZ: {np.DeltaMain.UZ}\n");
_sw.WriteLine("\tПЕ:");
_sw.WriteLine($"\tX: {np.DeltaPU.X}");
_sw.WriteLine($"\tY: {np.DeltaPU.Y}");
_sw.WriteLine($"\tZ: {np.DeltaPU.Z}");
_sw.WriteLine($"\tUX: {np.DeltaPU.UX}");
_sw.WriteLine($"\tUY: {np.DeltaPU.UY}");
_sw.WriteLine($"\tUZ: {np.DeltaPU.UZ}\n");
_sw.WriteLine("\tОтклонение:");
_sw.WriteLine($"\tX: {Math.Abs(np.DeltaMain.X - np.DeltaPU.X)}");
_sw.WriteLine($"\tY: {Math.Abs(np.DeltaMain.Y - np.DeltaPU.Y)}");
_sw.WriteLine($"\tZ: {Math.Abs(np.DeltaMain.Z - np.DeltaPU.Z)}");
_sw.WriteLine($"\tUX: {Math.Abs(np.DeltaMain.UX - np.DeltaPU.UX)}");
_sw.WriteLine($"\tUY: {Math.Abs(np.DeltaMain.UY - np.DeltaPU.UY)}");
_sw.WriteLine($"\tUZ: {Math.Abs(np.DeltaMain.UZ - np.DeltaPU.UZ)}\n");
_sw.WriteLine($"ПЕ № {np.PuParams.Item1}, загружение № {np.PuParams.Item2}, узел № {np.PuParams.Item3}");
_sw.WriteLine($"В модели загружение № {np.MainParams.Item1}, узел № {np.MainParams.Item2}");
_sw.WriteLine("--------------------------------------------------------\n");
_countWrongDelta++;
}
private void SelectForStack(IEnumerable <NodePair> stackable, PieceType mostPieceType, PieceType secondMostPieceType, PieceType stackType)
{
//get tallest stack for this type
var bigStack = stackable.Where(s => s.Select.TopPiece.Type == stackType)
.OrderByDescending(o => o.Select.StackHeight)
.FirstOrDefault();
//tallest cannot stack
if (bigStack == null)
{
_selection = null;
return;
}
//can stack on most pieces type
_selection = stackable.Where(s => s.Select == bigStack.Select && s.Target.TopPiece.Type == mostPieceType)
.FirstOrDefault();
//stack on second most piece type
if (_selection == null)
{
_selection = stackable.Where(s => s.Select == bigStack.Select && s.Target.TopPiece.Type == secondMostPieceType)
.FirstOrDefault();
}
}
protected NodePair GetTwoClosestNodesFromTwoGraphs(List <Node> graphA, List <Node> graphB)
{
NodePair closestNodePair = null;
for (int i = 0; i < graphA.Count; i++)
{
for (int j = 0; j < graphB.Count; j++)
{
Node nodeA = graphA[i];
Node nodeB = graphB[j];
float distance = Vector3.Distance(nodeA.transform.position, nodeB.transform.position);
if (closestNodePair != null)
{
if (distance < closestNodePair.distance)
{
closestNodePair.nodeA = nodeA;
closestNodePair.nodeB = nodeB;
closestNodePair.distance = distance;
}
}
else
{
closestNodePair = new NodePair(nodeA, nodeB, distance);
}
}
}
return(closestNodePair);
}
public override Node GetSolution(out int expanded, out int frontier)
{
var found = new HashSet <State>();
var heap = new SortedSet <NodePair>(new NodeComparer(Heuristic));
NodePair current = null;
expanded = 0;
heap.Add(new (Root, 0));
found.Add(Root.State);
while (heap.Count > 0)
{
current = heap.Min;
heap.Remove(current);
if (current.Node.State.IsGoal)
{
break;
}
expanded++;
foreach (var action in current.Node.State.PosibleActions())
{
Node child = new(current.Node, action.Value, action.Key);
if (!found.Contains(child.State) && !child.State.IsDead())
{
found.Add(child.State);
heap.Add(new(child, current.Depth + 1));
}
}
}
frontier = heap.Count;
return(current?.Node);
}
private void SelectLeastCommonOpponentTypeForCapture(IEnumerable <NodePair> captures)
{
var leastType = captures.GroupBy(np => np.Target.TopPiece.Type)
.OrderBy(grp => grp.Count())
.FirstOrDefault();
_selection = leastType.ElementAt(Rng.Next(leastType.Count()));
}
public void Add(IFact fact, TElement element)
{
var nodePair = new NodePair(fact, element);
_facts.AddLast(nodePair.FactNode);
_elements.AddLast(nodePair.ElementNode);
_nodeLookup[fact] = nodePair;
}
public bool Equals(NodePair np)
{
if (np == null)
{
return(false);
}
return((this.n1.Equals(np.n1) && this.n2.Equals(np.n2)) ||
(this.n1.Equals(np.n2) && this.n2.Equals(np.n1)));
}
private void WriteWrongCoords(NodePair np)
{
_sw.WriteLine("Узел с указанными координатами не найден в модели:");
_sw.WriteLine($"\tX: {np.CoordPU.X}");
_sw.WriteLine($"\tY: {np.CoordPU.Y}");
_sw.WriteLine($"\tZ: {np.CoordPU.Z}");
_sw.WriteLine($"ПЕ № {np.PuParams.Item1}, узел № {np.PuParams.Item3}");
_sw.WriteLine("--------------------------------------------------------\n");
_countWrongCoords++;
}
private void SelectForWinningCapture(IEnumerable <NodePair> captures)
{
var winningCapture = captures.GroupBy(np => np.Target.TopPiece.Type)
.Where(grp => grp.Count() == 1)
.FirstOrDefault();
if (winningCapture != null)
{
_selection = winningCapture.FirstOrDefault();
}
}
private void AddRandomPair()
{
if (currentPairs.Count < 10)
{
NodePair pair = GetRandomPair();
pair.line.SetPosition(0, positions[pair.first] * positionOffset);
pair.line.SetPosition(1, positions[pair.second] * positionOffset);
pair.line.material = lineMaterial;
currentPairs.Add(pair);
}
}
//產生一對node
public NodePair MapNodePair(string node1ID, string node2ID)
{
NodePair pair = new NodePair();
pair.Node1.ID = node1ID;
pair.Node1.Text = node1ID;
pair.Node2.ID = node2ID;
pair.Node2.Text = node2ID;
pair.Link.ID = node1ID + "-" + node2ID;
return(pair);
}
public void ToString_ReturnsExpectedString()
{
// Arrange
var node1 = new Node(2, new Coordinates(-1, 4));
var node2 = new Node(1, new Coordinates(1, 8));
var nodePair = new NodePair(node1, node2);
// Act
var result = nodePair.ToString();
// Assert
Assert.Equal("[(1,8), (-1,4)]", result);
}
public void Constructor_WithNodesSuppliedInReverseIndexOrder_PopulatesNodesReversed()
{
// Arrange
var node1 = new Node(2, new Coordinates(-1, 4));
var node2 = new Node(1, new Coordinates(1, 8));
// Act
var nodePair = new NodePair(node1, node2);
// Assert
Assert.Equal(node2, nodePair.Node1);
Assert.Equal(node1, nodePair.Node2);
}
public void Add(T value)
{
NodePair pair = Split(root, value);
root = Merge(Merge(pair.Left, new Node(value)), pair.Right);
if (compare(Max, value) < 0)
{
Max = value;
}
if (compare(Min, value) > 0)
{
Min = value;
}
}
//用人 查詢 案件與共犯
public void GetCrimeRecord(ChartData chartData, int personID)
{
NodePair pair = null;
Person person = peoRep.Find(personID);
if (person != null)
{
List <Case> crimes = caseRep.Query(c => c.PersonID == person.PersonID).ToList();
foreach (var crime in crimes)
{
pair = MapNodePair(person.Name, crime.Title);
pair.Node1.Data.Category = "person";
pair.Node2.Data.Category = "crime";
pair.Node1.Data.PersonData.PersonID = person.PersonID.ToString();
pair.Link.Text = "犯案紀錄";
pair.Link.Arrow = true;
pair.Link.Arrow2 = true;
if (pair != null)
{
AddNodeLink(chartData, pair);
}
var relatedIDs = crime.Related.Split(',').ToList();
var relateds = peoRep.Query(p => relatedIDs.Contains(p.PersonID.ToString()));
foreach (var rel in relateds)
{
pair = MapNodePair(crime.Title, rel.Name);
pair.Node1.Data.Category = "crime";
pair.Node2.Data.Category = "person";
pair.Node2.Data.PersonData.PersonID = rel.PersonID.ToString();
pair.Link.Text = "共犯";
pair.Link.Arrow = true;
pair.Link.Arrow2 = true;
if (pair != null)
{
AddNodeLink(chartData, pair);
}
}
}
}
}
public void Equals_WhenOneNull_ReturnsFalse()
{
// Arrange
var nodePair = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 2)));
var comparer = NodePairCoordinatesEqualiyComparer.Default;
// Act
var result1 = comparer.Equals(nodePair, null);
var result2 = comparer.Equals(null, nodePair);
// Assert
Assert.False(result1);
Assert.False(result2);
}
public bool Select(Game game)
{
//get list of player nodes
var playerNodes = game.Board.Nodes.Where(n => !n.IsVacant && n.TopPiece.PieceColor == Color).ToList();
//get opposing players nodes
var opposingNodes = game.Board.Nodes.Where(n => !n.IsVacant && n.TopPiece.PieceColor != Color).ToList();
//get list of capturable nodes
var captures = playerNodes.Join(opposingNodes, s => true, n => true,
(s, n) => new NodePair {
Select = s, Target = n
})
.Where(a => game.IsValidMove(a.Select, a.Target) && a.Select.StackHeight >= a.Target.StackHeight);
//get list of stackable nodes
var stackable = playerNodes.Join(playerNodes, s => true, n => true,
(s, n) => new NodePair {
Select = s, Target = n
})
.Where(a => a.Select != a.Target && game.IsValidMove(a.Select, a.Target));
//todo random is slow
if (game.TurnStage == TurnStage.CaptureStackOrPass && stackable.Count() > 0)
{
//Console.WriteLine($"BOT: stacking");
_selection = stackable.ElementAt(Rng.Next(stackable.Count()));
}
else if (captures.Count() < 1 && game.TurnStage == TurnStage.CaptureStackOrPass)
{
//Console.WriteLine($"BOT: passing");
_willPass = true;
}
else
{
//Console.WriteLine($"BOT: capturing");
_selection = captures.ElementAt(Rng.Next(captures.Count()));
}
//Console.WriteLine($"BOT: selected {_selection.Select.Id}");
//Console.WriteLine($"BOT: target {_selection.Target.Id}");
return(game.SelectPiece(_selection.Select));
}
public void Equals_WhenCoordinatesDifferInNode2_ReturnsFalse()
{
// Arrange
var nodePair1 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 2)));
var nodePair2 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(2, 7)));
var comparer = NodePairCoordinatesEqualiyComparer.Default;
// Act
var result = comparer.Equals(nodePair1, nodePair2);
// Assert
Assert.False(result);
}
public void Equals_WhenBothHaveSameCoordinates_ReturnsTrue()
{
// Arrange
var nodePair1 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 2)));
var nodePair2 = new NodePair(
new Node(13, new Coordinates(7, 2)),
new Node(12, new Coordinates(10, 5)));
var comparer = NodePairCoordinatesEqualiyComparer.Default;
// Act
var result = comparer.Equals(nodePair1, nodePair2);
// Assert
Assert.True(result);
}
public void GetHashCode_WhenCoordinatesDifferInNode2_ReturnsDifferentValue()
{
// Arrange
var nodePair1 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 2)));
var nodePair2 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 3)));
var comparer = NodePairCoordinatesEqualiyComparer.Default;
// Act
var hashCode1 = comparer.GetHashCode(nodePair1);
var hashCode2 = comparer.GetHashCode(nodePair2);
// Assert
Assert.NotEqual(hashCode1, hashCode2);
}
public void GetHashCode_WhenBothHaveSameCoordinates_ReturnsSameValue()
{
// Arrange
var nodePair1 = new NodePair(
new Node(12, new Coordinates(10, 5)),
new Node(13, new Coordinates(7, 2)));
var nodePair2 = new NodePair(
new Node(13, new Coordinates(7, 2)),
new Node(12, new Coordinates(10, 5)));
var comparer = NodePairCoordinatesEqualiyComparer.Default;
// Act
var hashCode1 = comparer.GetHashCode(nodePair1);
var hashCode2 = comparer.GetHashCode(nodePair2);
// Assert
Assert.Equal(hashCode1, hashCode2);
}
// a List<Node> is a graph?? let's go for it
protected List <Node> ConnectTwoGraphs(List <Node> graphA, List <Node> graphB)
{
List <Node> connectedGraph = new List <Node>();
// find 2 closest nodes and connect them with a rail
NodePair twoClosestNodes = GetTwoClosestNodesFromTwoGraphs(graphA, graphB);
twoClosestNodes.nodeA.ConnectMeToNode(twoClosestNodes.nodeB);
twoClosestNodes.nodeA.name = string.Format("Hand Connected Node {0}", UnityEngine.Random.Range(0, 999));
twoClosestNodes.nodeB.name = string.Format("Hand Connected Node {0}", UnityEngine.Random.Range(0, 999));
Debug.LogFormat("Hand connected the nodes {0} and {1}! Enjoy!", twoClosestNodes.nodeA.name, twoClosestNodes.nodeB.name);
// put 2 graphs into 1 list
connectedGraph.AddRange(graphA);
connectedGraph.AddRange(graphB);
return(connectedGraph);
}
private NodePair Split(Node node, T value)
{
if (node == null)
{
return(new NodePair(null, null));
}
if (compare(node.Value, value) >= 0)
{
NodePair leftSplit = Split(node.Left, value);
node.Left = leftSplit.Right;
leftSplit.Right = node;
return(leftSplit);
}
else
{
NodePair rightSplit = Split(node.Right, value);
node.Right = rightSplit.Left;
rightSplit.Left = node;
return(rightSplit);
}
}
//找尋chart data 有相關的"人"
public void GetRelationship(ChartData chartData)
{
var NodeIDs = chartData.Items.OfType <Node>().Select(n => n.ID);
var people = peoRep.Query(p => NodeIDs.Contains(p.Name));
NodePair pair = null;
foreach (var person in people)
{
var rels = relRep.Query(r => r.PersonID1 == person.PersonID || r.PersonID2 == person.PersonID);
foreach (var rel in rels)
{
Person related = null;
if (rel.PersonID1 != person.PersonID)
{
related = peoRep.Find(rel.PersonID1);
}
else
{
related = peoRep.Find(rel.PersonID2);
}
pair = MapNodePair(person.Name, related.Name);
pair.Node1.Data.Category = "person";
pair.Node2.Data.Category = "person";
pair.Node1.Data.PersonData.PersonID = person.PersonID.ToString();
pair.Node2.Data.PersonData.PersonID = related.PersonID.ToString();
pair.Link.Text = rel.Relationship1;
pair.Link.Arrow = true;
pair.Link.Arrow2 = true;
if (pair != null)
{
AddNodeLink(chartData, pair);
}
}
}
}
private void DecorateEdge(Dot.Edge dotEdge, NodePair <Node, Edge> pair, Label?label, EdgeStatus edgeStatus, Recorder <Graph, Node, Edge, Label> .RecordOptions options)
{
if (EdgeDiff.Commons.TryGetValue(pair, out var common))
{
groupMap.TryGetValue(common.labelGroup.Group, out var labels);
// reverseGroupMap.TryGetValue(common.labelKey.Label, out var groups);
if (labels?.Count == 1)
{
dotEdge.Label = $"{common.labelGroup.Group}";
}
else
{
dotEdge.Label = $"{common.labelGroup.Group}:[{common.labelKey.Label}]";
dotEdge.FontColor = Visualizer.ErrorColor;
}
}
else if (EdgeDiff.ExpectedOnlys.TryGetValue(pair, out var expectedOnly))
{
dotEdge.Label = $"{expectedOnly.Group} / ?";
dotEdge.FontColor = Visualizer.ErrorColor;
}
}
private List<Match> SampleMatches(QueryGraph qg)
{
int matchNum = 20;
Random ra = new Random();
List<Match> res = new List<Match>();
for (int i = 0; i < matchNum; ++i)
{
Match m = new Match();
foreach (long cid in qg.CellIDSet)
{
NodePair np = new NodePair(cid, ra.Next());
m.PartialMatch.Add(np);
}
res.Add(m);
}
return res;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(NodePair obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public NodePair(NodePair p) : this(NQuantLibcPINVOKE.new_NodePair__SWIG_2(NodePair.getCPtr(p)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
