|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Uses of Node in netkit.classifiers |
|---|
| Methods in netkit.classifiers that return Node | |
|---|---|
Node[][][] |
DataSampler.crossValidate(int numSplits)
Create full cross-validation node sets in the form result[numsplit][0][...]
is the training set for split numsplit and result[numsplit][1][...]
is the test set for split numsplit. |
Node[] |
DataSplit.getTestSet()
|
Node[] |
DataSplit.getTrainSet()
|
Node[] |
DataSplit.getUnknownSet()
|
Node[] |
DataView.sample(double ratio)
|
Node[][] |
DataSampler.sample(int... sizes)
Sample sets of the given size from the underlying distribution of nodes and return them in a a list of lists. |
Node[] |
DataView.sample(int size)
|
Node[] |
DataSampler.sample(int size)
Sample the given number of nodes and return a new array filled with the samples. |
| Methods in netkit.classifiers that return types with arguments of type Node | |
|---|---|
java.util.Iterator<Node> |
Estimate.iterator()
|
java.util.Iterator<Node> |
DataView.iterator()
|
java.util.Iterator<Node> |
Classification.iterator()
|
| Methods in netkit.classifiers with parameters of type Node | |
|---|---|
void |
Incremental.addTrainingLabel(Node node,
int label)
After the model has been induced, use this method to add a new training label. |
int |
ClassifierImp.classify(Node node)
|
int |
Classifier.classify(Node node)
|
boolean |
ClassifierImp.classify(Node node,
Classification result)
|
boolean |
Classifier.classify(Node node,
Classification result)
|
void |
Estimate.classify(Node node,
int clsVal)
|
void |
ClassifierListener.classify(Node node,
int label)
|
double[] |
ClassifierImp.estimate(Node node)
|
double[] |
Classifier.estimate(Node node)
|
void |
Estimate.estimate(Node node,
double[] estimate)
|
void |
ClassifierListener.estimate(Node node,
double[] estimate)
|
boolean |
Classifier.estimate(Node node,
double[] result)
Estimate the probabilities that a given node into belongs to any given class. |
boolean |
ClassifierImp.estimate(Node node,
Estimate result)
|
boolean |
Classifier.estimate(Node node,
Estimate result)
|
int |
Estimate.getClassification(Node node)
|
int |
Estimate.getClassificationIdx(Node node,
int defaultValue)
|
int |
Classification.getClassValue(Node node)
|
double |
IncrementalAssessment.getEmpiricalRisk(Node node)
What is the empirical risk if this node is labeled (after the initial model has been induced)? |
double[] |
Estimate.getEstimate(Node node)
|
double[] |
Estimate.getEstimate(Node node,
double[] defaultValue)
|
double |
IncrementalAssessment.getIncrementalAccuracy(Node n,
Classification truth)
What would be the new accuracy if this node is labeled (after the initial model has been induced)? |
double |
Estimate.getScore(Node node,
int clsVal)
|
int |
DataView.getTrueClassValue(Node node)
|
void |
DataView.hideClassValue(Node node)
|
boolean |
NetworkLearner.inTrainingSet(Node n)
|
boolean |
Classification.isUnknown(Node node)
|
protected void |
ClassifierImp.makeVector(Node node,
double[] vector)
|
void |
Estimate.normalize(Node node)
|
void |
ClassifierImp.notifyListeners(Node node,
double[] estimate)
|
void |
Classifier.notifyListeners(Node node,
double[] estimate)
|
void |
ClassifierImp.notifyListeners(Node node,
int classification)
|
void |
Classifier.notifyListeners(Node node,
int classification)
|
void |
DataSampler.sample(Node[]... result)
Fill the given list of arrays with sample nodes, ensuring that there is no overlap between nodes sampled in each of the sub-arrays (unless you are sampling with replacement). |
void |
DataSampler.sample(Node[] result)
Fill the array with sampled data |
int |
Estimate.sampleEstimateIdx(Node node)
|
void |
NetworkLearner.saveIterationPredictions(java.lang.String stem,
PrintEstimateWriter pe,
boolean append,
Node[] eval,
java.lang.String header)
|
void |
Classification.set(Node node,
double clsValue)
|
void |
Classification.set(Node node,
int clsValue)
|
void |
Classification.setUnknown(Node node)
|
void |
DataView.showClassValue(Node node)
|
protected int |
DataView.showNeighbors(Node n,
int depth)
|
| Constructors in netkit.classifiers with parameters of type Node | |
|---|---|
DataSampler(Node[] nodes,
int attribIdx)
|
|
DataSampler(Node[] nodes,
int attribIdx,
long seed)
|
|
DataSampler(Node[] nodes,
int attribIdx,
long seed,
boolean replacement,
boolean stratified,
boolean sampleUnknown)
|
|
DataSplit(DataView view,
Node[] test,
Node[] train)
|
|
DataSplit(DataView view,
Node[] test,
Node[] train)
|
|
| Uses of Node in netkit.classifiers.active |
|---|
| Fields in netkit.classifiers.active declared as Node | |
|---|---|
Node |
PickLabelStrategy.LabelNode.node
|
| Methods in netkit.classifiers.active with parameters of type Node | |
|---|---|
double |
UncertaintyLabeling.getRank(DataSplit split,
Estimate predictions,
Node node)
|
double |
PickLabelStrategyImp.getRank(DataSplit currentSplit,
Estimate currentPredictions,
Node node)
|
double |
PickLabelStrategy.getRank(DataSplit currentSplit,
Estimate currentPredictions,
Node node)
Get the rank of the given node if the strategy were to pick the node. |
double |
GreedyTruth.getRank(DataSplit split,
Estimate predictions,
Node node)
|
double |
GraphCentralityLabeling.getRank(DataSplit split,
Estimate predictions,
Node node)
|
double |
EmpiricalRiskMinimizationHarmonic.getRank(DataSplit split,
Estimate predictions,
Node node)
|
| Constructors in netkit.classifiers.active with parameters of type Node | |
|---|---|
PickLabelStrategy.LabelNode(Node node,
double score)
|
|
| Uses of Node in netkit.classifiers.active.graphfunctions |
|---|
| Methods in netkit.classifiers.active.graphfunctions with parameters of type Node | |
|---|---|
double |
WeightedCloseness.score(ModularityClusterer.Cluster c,
Node n)
|
double |
WeightedBetweenness.score(ModularityClusterer.Cluster c,
Node n)
|
abstract double |
ScoringFunction.score(ModularityClusterer.Cluster c,
Node n)
|
double |
LabelWeightedClosenessRank.score(ModularityClusterer.Cluster c,
Node n)
|
double |
LabelClosenessRank.score(ModularityClusterer.Cluster c,
Node n)
|
double |
ERMRank.score(ModularityClusterer.Cluster c,
Node n)
|
double |
ClusterWeightedCloseness.score(ModularityClusterer.Cluster c,
Node n)
|
double |
ClusterSizeRank.score(ModularityClusterer.Cluster c,
Node n)
|
double |
ClusterCloseness.score(ModularityClusterer.Cluster c,
Node n)
|
double |
Closeness.score(ModularityClusterer.Cluster c,
Node n)
|
double |
Betweenness.score(ModularityClusterer.Cluster c,
Node n)
|
double |
ScoringFunction.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
Return the new score of a node given its old score and a newly labeled node. |
double |
ScoringFunction.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
Return the new score of a node given its old score and a newly labeled node. |
double |
LabelWeightedClosenessRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
double |
LabelWeightedClosenessRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
double |
LabelClosenessRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
double |
LabelClosenessRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
double |
ERMRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
double |
ERMRank.update(ModularityClusterer.Cluster c,
double currentScore,
Node n,
Node[] newPicks)
|
| Uses of Node in netkit.classifiers.aggregators |
|---|
| Methods in netkit.classifiers.aggregators with parameters of type Node | |
|---|---|
double[] |
SharedNodeInfo.countNeighbors(Node n,
Estimate prior)
Count, for all relevant neighbors, how many of the neighboring attributes took on each of the possible values (weighted by the edge weight). |
HistogramDiscrete |
SharedNodeInfo.getHistogram(Node n)
Get the histogram of observed values (of the neighbors of the source node) of the discrete attribute that is being aggregated over. |
double |
SharedNodeInfo.getMax(Node n)
Get the maximum observed value (of the neighbors of the source node) of the discrete or continuous attribute that is being aggregated over. |
double |
SharedNodeInfo.getMean(Node n)
Get the mean observed value (of the neighbors of the source node) of the discrete or continuous attribute that is being aggregated over. |
double |
SharedNodeInfo.getMin(Node n)
Get the minium observed value (of the neighbors of the source node) of the discrete or continuous attribute that is being aggregated over. |
protected SharedNodeInfo |
AggregatorImp.getNodeInfo(Node node)
This is cached aggregation information about the node as is relevant to the relationship that this aggregator uses. |
double |
SharedNodeInfo.getSum(Node n,
Estimate prior)
Get the (weighted) sum of all relevant neighbors. |
double |
AggregatorImp.getValue(Node n)
Aggregate around the given node in the graph and return the result. |
double |
Aggregator.getValue(Node n)
Gets the value stored in this object for the supplied Node. |
double |
Ratio.getValue(Node n,
Estimate prior)
|
double |
Mode.getValue(Node n,
Estimate prior)
|
double |
Min.getValue(Node n,
Estimate prior)
|
double |
Mean.getValue(Node n,
Estimate prior)
|
double |
Max.getValue(Node n,
Estimate prior)
|
double |
Exist.getValue(Node n,
Estimate prior)
|
double |
Count.getValue(Node n,
Estimate prior)
|
double |
Aggregator.getValue(Node n,
Estimate prior)
Gets the value stored in this object for the supplied Node. |
| Uses of Node in netkit.classifiers.io |
|---|
| Methods in netkit.classifiers.io with parameters of type Node | |
|---|---|
void |
PrintEstimateWriter.print(Node node,
Estimate e)
Print an estimate of the given node using the given output format and the given current estimates. |
void |
PrintEstimateWriter.print(Node node,
Estimate e,
Classification known)
Print an estimate of the given node using the given output format and the given current estimates and true labels. |
void |
PrintEstimateWriter.println(Node node,
Estimate e)
Print an estimate line of the given node using the given output format and the given current estimates. |
void |
PrintEstimateWriter.println(Node node,
Estimate e,
Classification known)
Print an estimate line of the given node using the given output format and the given current estimates and true labels. |
java.lang.String |
PrintEstimateWriter.toString(Node node,
Estimate e)
The equivalent of a print, where the output has been set to a string to be returned. |
java.lang.String |
PrintEstimateWriter.toString(Node node,
Estimate e,
Classification known)
The equivalent of a print, where the output has been set to a string to be returned. |
| Uses of Node in netkit.classifiers.nonrelational |
|---|
| Methods in netkit.classifiers.nonrelational with parameters of type Node | |
|---|---|
boolean |
UniformPrior.estimate(Node node,
double[] result)
Fills the result array with all the same values---each class is equally likely. |
boolean |
NullPrior.estimate(Node node,
double[] result)
|
boolean |
MetaMultiplicative.estimate(Node node,
double[] result)
Get the estimates from each of the underlying classifiers, multiply their respective predictions together and return a normalized distribution. |
boolean |
LocalWeka.estimate(Node node,
double[] result)
Predict class labels for the given node. |
boolean |
ExternalPrior.estimate(Node node,
double[] result)
Estimate class probabilities for the given node--returns the read in estimates. |
boolean |
ClassPrior.estimate(Node node,
double[] result)
Copies the class marginals into the 'result' array. |
| Uses of Node in netkit.classifiers.relational |
|---|
| Methods in netkit.classifiers.relational with parameters of type Node | |
|---|---|
int |
NetworkClassifierImp.classify(Node node,
Estimate prior,
boolean updatePrior)
Classify a given node into one of the given classes. |
int |
NetworkClassifier.classify(Node node,
Estimate prior,
boolean updatePrior)
Classify a given node into one of the given classes. |
boolean |
WeightedVoteRelationalNeighbor.doEstimate(Node node,
double[] estimation)
|
boolean |
ProbRelationalNeighbor.doEstimate(Node node,
double[] estimation)
Estimate the label of this node by using a naive Bayesian combination of the neighbor nodes. |
boolean |
NetworkWeka.doEstimate(Node node,
double[] result)
Predict class labels for the given node. |
boolean |
NetworkOnlyBayes.doEstimate(Node node,
double[] estimation)
compute class estimates. |
protected abstract boolean |
NetworkClassifierImp.doEstimate(Node node,
double[] result)
This is the final estimation method that will be called and the only estimation method that sub-classes should implement. |
protected boolean |
MetaMultiplicative.doEstimate(Node node,
double[] result)
Get the estimates from each of the underlying classifiers, multiply their respective predictions together and return a normalized distribution. |
boolean |
Harmonic.doEstimate(Node node,
double[] estimation)
Returns the prediction computer in the induceModel call. |
boolean |
ClassDistribRelNeighbor.doEstimate(Node node,
double[] result)
Estimate how near this node's neighborhood is to each of the class vectors using a user-specified distance function (cosine by default) and normalize to produce a pseudo distribution. |
boolean |
NetworkClassifierImp.estimate(Node node,
double[] result)
Estimate the probabilities that a given node into belongs to any given class. |
double[] |
NetworkClassifierImp.estimate(Node node,
Estimate prior,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
double[] |
NetworkClassifier.estimate(Node node,
Estimate prior,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
boolean |
NetworkClassifierImp.estimate(Node node,
Estimate prior,
double[] result,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
boolean |
NetworkClassifier.estimate(Node node,
Estimate prior,
double[] result,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
boolean |
NetworkClassifierImp.estimate(Node node,
Estimate prior,
Estimate result,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
boolean |
NetworkClassifier.estimate(Node node,
Estimate prior,
Estimate result,
boolean updatePrior)
Estimate the probabilities that a given node into belongs to any given class It may use the class estimations of other nodes and may update the prior of the given node. |
double |
Harmonic.getERM(Node n)
|
double[] |
Harmonic.getERM(Node n,
Classification truth)
|
void |
WeightedVoteRelationalNeighbor.initializeRun(Estimate currPrior,
Node[] unknowns)
This initializes wvRN for the next collective inference iteration by setting up the laplace correction, if needed, for the current iteration. |
void |
NetworkClassifierImp.initializeRun(Estimate currPrior,
Node[] unknowns)
This is called prior to predicting labels for the unknown labels in the graph, in case the classifier needs to initialize itself. |
void |
NetworkClassifier.initializeRun(Estimate currPrior,
Node[] unknowns)
This is called prior to predicting labels for the unknown labels in the graph, in case the classifier needs to initialize itself. |
void |
Harmonic.initializeRun(Estimate currPrior,
Node[] unknowns)
This initializes Harmonic function for the next collective inference iteration by doing absolutely nothing. |
protected void |
NetworkClassifierImp.makeVector(Node node,
double[] vector)
|
| Uses of Node in netkit.graph |
|---|
| Methods in netkit.graph that return Node | |
|---|---|
Node |
Graph.addNode(java.lang.String nodeName,
Attributes a)
Adds a new Node to the Graph using the supplied node name and Attributes container. |
Node |
Node.copy(int index)
The constructor must be provided with a name, an Attributes container and an index. |
Node |
Edge.getDest()
Get the destination node of this object. |
Node[] |
Node.getNeighbors()
Gets the adjacent nodes connected to this node irrespective of the EdgeType; the order is unspecified. |
Node[] |
Node.getNeighbors(java.lang.String edgeTypeName)
Gets the adjacent nodes connected to this node through an Edge with the supplied EdgeType name; the order is unspecified. |
Node |
Graph.getNode(int index)
Gets the node corresponding to the supplied int index. |
Node |
Graph.getNode(java.lang.String nodeName,
java.lang.String nodeType)
Gets the node coresponding to the supplied node name and node type. |
Node[] |
Graph.getNodes()
Gets all of the nodes in the graph; the order is unspecified. |
Node[] |
Graph.getNodes(Attributes attrs)
Gets all of the Nodes whose Attributes container matches the supplied parameter. |
Node[] |
Graph.getNodes(java.lang.String type)
Gets all of the Nodes matching the supplied node type. |
Node[] |
Graph.getNodes(java.lang.String nodeType,
NodeFilter nf)
Gets all of the Nodes matching the supplied node type and which also are accepted by the supplied NodeFilter. |
Node |
Edge.getSource()
Get the source node of this object. |
| Methods in netkit.graph with parameters of type Node | |
|---|---|
boolean |
NodeFilter.accept(Node node)
Tests whether or not the specified Node should be included. |
Edge |
Graph.addEdge(EdgeType et,
Node source,
Node dest,
double weight)
Add an edge created from the supplied parameters to the graph; if the nodes are already connected, then simply add the weight to the existing Edge. |
int |
Node.compareTo(Node n)
Specifies a natural ordering for Nodes; compare node types first, then node names. |
Edge |
Node.getEdge(java.lang.String edgeTypeName,
Node neighbor)
Gets the edge connecting this node to a neighbor node. |
Edge |
Graph.getEdge(java.lang.String edgeTypeName,
Node source,
Node dest)
Gets the edge connecting two nodes in the graph; if the nodes aren't connected return null. |
Edge[] |
Node.getEdgesToNeighbor(Node destinationNode)
Get all the edges of this Node whose destination Node is the supplied node; the order is unspecified. |
Edge |
Node.removeEdge(java.lang.String edgeTypeName,
Node destNode)
Removes the Edge to the supplied destination Node via the supplied EdgeType name. |
void |
Graph.removeEdge(java.lang.String edgeTypeName,
Node source,
Node dest)
Removes the Edge connecting the supplied source Node and destination Node through the supplied EdgeType. |
| Method parameters in netkit.graph with type arguments of type Node | |
|---|---|
Graph |
Graph.subGraph(java.util.Collection<Node> nodeSet)
Create a sub-graph consisting only of the given nodes and the edges between those nodes. |
| Constructors in netkit.graph with parameters of type Node | |
|---|---|
Edge(EdgeType edgeType,
Node source,
Node dest,
double weight)
The constructor requires an EdgeType, a source and destination Node and a weight. |
|
| Uses of Node in netkit.graph.edgecreator |
|---|
| Fields in netkit.graph.edgecreator declared as Node | |
|---|---|
Node |
EdgeCreatorImp.NbrEntry.dest
|
Node |
EdgeCreatorImp.NbrEntry.source
|
| Fields in netkit.graph.edgecreator with type parameters of type Node | |
|---|---|
protected java.util.Map<Node,java.lang.Integer> |
BaseNumericEdgeCreator.nat
|
| Methods in netkit.graph.edgecreator with parameters of type Node | |
|---|---|
Edge |
EdgeCreatorImp.NbrEntry.asEdge(Node src)
|
Edge[] |
EdgeCreatorImp.getEdgesToNearestNeighbors(Node node)
Get the edges to the K nearest nodes (highest weight using this edge creator), where max-k was provided during initialization. |
Edge[] |
BaseNumericEdgeCreator.getEdgesToNearestNeighbors(Node node)
|
Edge[] |
BaseCategoricalEdgeCreator.getEdgesToNearestNeighbors(Node node)
|
protected double |
NormalizedNumericEdgeCreator.getValue(Node n)
|
protected double |
BaseNumericEdgeCreator.getValue(Node n)
|
double |
NormalizedNumericEdgeCreator.getWeight(Node src,
Node dest)
|
double |
MahalanobisDistanceEdgeCreator.getWeight(Node src,
Node dest)
|
double |
EuclideanDistanceEdgeCreator.getWeight(Node src,
Node dest)
|
double |
EdgeCreator.getWeight(Node src,
Node dest)
Calculate the edgeweight from node src to node dest. |
double |
CosineDistanceEdgeCreator.getWeight(Node src,
Node dest)
|
double |
BayesCategoricalEdgeCreator.getWeight(Node src,
Node dest)
|
double |
BaseNumericEdgeCreator.getWeight(Node src,
Node dest)
|
double |
BaseCategoricalEdgeCreator.getWeight(Node src,
Node dest)
|
protected double |
NormalizedNumericEdgeCreator.getWeightFast(Node src,
Node dest)
|
protected double |
GaussianNumericEdgeCreator.getWeightFast(Node src,
Node dest)
|
protected double |
BaseNumericEdgeCreator.getWeightFast(Node src,
Node dest)
|
| Constructors in netkit.graph.edgecreator with parameters of type Node | |
|---|---|
EdgeCreatorImp.NbrEntry(Node src,
Node dest,
double score)
|
|
| Uses of Node in netkit.graph.io |
|---|
| Methods in netkit.graph.io with parameters of type Node | |
|---|---|
static java.lang.String |
NetkitGraph.getNodeStatistics(GraphMetrics metrics,
Node node)
|
static void |
NodeWriter.writeNodes(Node[] nodes,
java.io.Writer writer)
This static method does the work of writing output data for the class. |
| Uses of Node in netkit.inference |
|---|
| Fields in netkit.inference declared as Node | |
|---|---|
protected Node[] |
InferenceMethod.unknown
|
| Methods in netkit.inference with parameters of type Node | |
|---|---|
void |
InferenceMethod.savePredictions(java.lang.String outPredict,
PrintEstimateWriter pe,
boolean append,
Node[] eval,
java.lang.String header)
|
| Method parameters in netkit.inference with type arguments of type Node | |
|---|---|
Classification |
InferenceMethod.classify(NetworkClassifier networkClassifier,
java.util.Iterator<Node> unknowns)
|
void |
InferenceMethod.classify(NetworkClassifier networkClassifier,
java.util.Iterator<Node> unknowns,
Classification result)
|
Estimate |
InferenceMethod.estimate(NetworkClassifier networkClassifier,
java.util.Iterator<Node> unknowns)
|
void |
InferenceMethod.estimate(NetworkClassifier networkClassifier,
java.util.Iterator<Node> unknowns,
Estimate result)
|
void |
RelaxationLabeling.reset(java.util.Iterator<Node> unknowns)
|
void |
NullInference.reset(java.util.Iterator<Node> unknowns)
|
void |
IterativeClassification.reset(java.util.Iterator<Node> unknowns)
|
void |
InferenceMethod.reset(java.util.Iterator<Node> unknowns)
|
void |
GibbsSampling.reset(java.util.Iterator<Node> unknowns)
|
| Uses of Node in netkit.util |
|---|
| Methods in netkit.util that return Node | |
|---|---|
Node |
ModularityClusterer.Cluster.getNode()
|
| Methods in netkit.util that return types with arguments of type Node | |
|---|---|
java.util.List<java.util.Set<Node>> |
ModularityClusterer.getConnectedClusterNodeSets()
|
java.util.List<java.util.Set<Node>> |
ModularityClusterer.getIsolatedClusterNodeSets()
|
java.util.Iterator<Node> |
ModularityClusterer.Cluster.iterator()
|
| Methods in netkit.util with parameters of type Node | |
|---|---|
double |
GraphMetrics.getBetweennessCentrality(Node n)
Get the betweenness centrality for the given node. |
double |
ApproximateCentralities.ApproximateCentrality.getCentrality(Node n)
Get the centrality for the given node. |
double |
GraphMetrics.getClosenessCentrality(Node n)
Get the closeness centrality for the given node. |
int |
GraphMetrics.getCluster(Node node)
|
int |
GraphMetrics.getComponent(Node node)
|
double |
GraphMetrics.getDist(Node src,
Node dst)
|
double |
GraphMetrics.getGraphCentrality(Node n)
Get the graph centrality for a specific node. |
double |
GraphMetrics.getInformationCentrality(Node n)
Not implemented yet. |
int |
GraphMetrics.getNodeIndex(Node n)
|
double |
GraphMetrics.getWeightedBetweennessCentrality(Node n)
Get the betweenness centrality for the given node. |
double |
GraphMetrics.getWeightedClosenessCentrality(Node n)
Get the closeness centrality for the given node. |
double |
GraphMetrics.getWeightedDist(Node src,
Node dst)
|
double |
GraphMetrics.getWeightedGraphCentrality(Node n)
Get the graph centrality for a specific node. |
double |
GraphMetrics.getWeightedInformationCentrality(Node n)
Not implemented yet. |
| Method parameters in netkit.util with type arguments of type Node | |
|---|---|
static void |
ModularityClusterer.buildNodeCluster(java.util.Set<Node> nodeCluster,
ModularityClusterer.Cluster c)
|
| Constructors in netkit.util with parameters of type Node | |
|---|---|
Histogram(Node[] nodes,
Attribute attribute,
int minOccurance)
This constructor creates a histogram object given an array of nodes and an attribute from which to get the values. |
|
HistogramCategorical(Node[] nodes,
AttributeCategorical attribute)
This constructor is a convenience for accepting all node values without any minimum occurance. |
|
HistogramCategorical(Node[] nodes,
AttributeCategorical attribute,
int minOccurance)
This constructor creates a histogram object given an array of nodes and an attribute from which to get the values. |
|
HistogramDiscrete(Node[] nodes,
AttributeDiscrete attribute)
This constructor is a convenience for accepting all node values without any minimum occurance. |
|
HistogramDiscrete(Node[] nodes,
AttributeDiscrete attribute,
int minOccurance)
This constructor creates a histogram object given an array of nodes and an attribute from which to get the values. |
|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||