public override Evaluation Evaluate(Path path, BranchState <double> state) { double nextState = state.State; if (path.Length() > 0) { nextState += CostEvaluator.getCost(path.LastRelationship(), OUTGOING); state.State = nextState; } return(Evaluation.EXCLUDE_AND_CONTINUE); }
public override Evaluation Evaluate(Path path, BranchState <double> state) { double nextState = state.State; if (path.Length() > 0) { nextState += CostEvaluator.getCost(path.LastRelationship(), OUTGOING); state.State = nextState; } if (path.EndNode().Equals(EndNode)) { ShortestSoFar.Value = Math.Min(ShortestSoFar.doubleValue(), nextState); return(Evaluation.INCLUDE_AND_PRUNE); } return(Evaluation.EXCLUDE_AND_CONTINUE); }
protected internal override double?CalculateValue(TraversalBranch next) { return(next.Length() == 0 ? 0d : _evaluator.getCost(next.LastRelationship(), OUTGOING)); }
/// <summary> /// Internal calculate method that will do the calculation. This can however /// be called externally to manually trigger the calculation. /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") public void calculate() public virtual void Calculate() { // Don't do it more than once if (DoneCalculation) { return; } DoneCalculation = true; // Build initial matrix int n = NodeSet.Count; //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: CostMatrix = (CostType[][]) new object[n][n]; CostMatrix = ( CostType[][] )RectangularArrays.RectangularObjectArray(n, n); //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: Predecessors = new System.Nullable<int>[n][n]; Predecessors = RectangularArrays.RectangularSystemNullableArray <int>(n, n); IndexedNodes = new Node[n]; NodeIndexes = new Dictionary <Node, int>(); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { CostMatrix[i][j] = InfinitelyBad; } CostMatrix[i][i] = StartCost; } int nodeIndex = 0; foreach (Node node in NodeSet) { NodeIndexes[node] = nodeIndex; IndexedNodes[nodeIndex] = node; ++nodeIndex; } // Put the relationships in there foreach (Relationship relationship in RelationshipSet) { int?i1 = NodeIndexes[relationship.StartNode]; int?i2 = NodeIndexes[relationship.EndNode]; if (i1 == null || i2 == null) { // TODO: what to do here? pretend nothing happened? cast // exception? continue; } if (RelationDirection.Equals(Direction.BOTH) || RelationDirection.Equals(Direction.OUTGOING)) { CostMatrix[i1][i2] = CostEvaluator.getCost(relationship, Direction.OUTGOING); Predecessors[i1][i2] = i1; } if (RelationDirection.Equals(Direction.BOTH) || RelationDirection.Equals(Direction.INCOMING)) { CostMatrix[i2][i1] = CostEvaluator.getCost(relationship, Direction.INCOMING); Predecessors[i2][i1] = i2; } } // Do it! for (int v = 0; v < n; ++v) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { CostType alternative = CostAccumulator.addCosts(CostMatrix[i][v], CostMatrix[v][j]); if (CostComparator.Compare(CostMatrix[i][j], alternative) > 0) { CostMatrix[i][j] = alternative; Predecessors[i][j] = Predecessors[v][j]; } } } } // TODO: detect negative cycles? }
protected internal override int?calculateValue(TraversalBranch next) { return(next.Length() == 0 ? 0 : evaluator.getCost(next.LastRelationship(), Direction.BOTH)); }