braph-software / braph-2 Goto Github PK

Add to test_Graph the tests for:

• Graph.nodeattack()
• Graph.edgeattack()

Calculate the global efficiency of the network, by averaging the nodal global efficiencies of each nodes.

• Add distance() to Graph as abstract method

Implement it in all kinds of graphs:

• GraphBU

• GraphBD

• GraphWU

• GraphWD

• add concrete method to Graph getDistance()

• add test

Restructure settings in Graph and Measure, and make deep copy

Code Degree as child of Measure for BU and WU (same obj.)

Code InDegree and OutDegree as child of Measure for BD and WD (two obj.)

Mite, please:

• check and add all measures (as separated) issues from
  https://sites.google.com/site/bctnet/measures/list
  Start with those already implemented in the Braph 1.0

• check that all measure can be either nodal (vector) or global (scalar) -- maybe we need to introduce new kinds of datatypes, in which case we need to discuss

Deep copy

• add function normalize(A, 'NormalizeRule', RULE) to graph
  RULE can be 'rescale' (A/max(A)) or 'one'|1 (A<0 = 0 and A>1 = 1).

• Comment function

• Check this i the constructors of GraphWD (and therefore WU)

• Explain this in the getDescription() of GraphWD and GraphWU

• create test_normalize

Implement TriangleBU

@mitemijalkov @annacanal

Triangles should be tested for all rules in the directed graphs.

Calculate the Betweeness centrality of a node.

The code in Braph 1 currently uses Kintali algorithm (same as BCT). Try to check if there is something else available, if not, the same algorithm can be implemented.

Add .getName() and .getDescription() to InDegree and OutDegree

The possible rules are

• 'zero', '0', 'null' (default)
• 'abs', 'absolute', 'modulus'

Implement

• Measure.tostring()
• Measure.disp()

Update remove_diagonal so that it works with varargin, e.g., remove_diagonal(A, 'RemoveDiagonalValue', value)

• update code
• update doc

Calculate the radius and diameter of a graph. These measures are very closely related to eccentricity.

Write test code for Graph.copy()
It should check that it does a deep copy of the graph, including all measures and references to the graph in the measures.

I was not sure where to submit this so I submit this bug as an issue.

When the BU/BD graphs are created, the matrix A associated with the graph is turned into logical matrix (accessed by the getA() method). This creates a problem with the performance of matrix multiplication in the measures (gives the following error: Error using *
Both logical arguments must be scalar. Use TIMES (.*) for elementwise multiplication.)
I double checked, and I think the problem is in the implementation of the function binarize.

What do you think? Should this be changed?

Write test_triangles

We are using this:
https://www.mathworks.com/help/matlab/script-based-unit-tests.html

Based on the distance matrix, calculate the global efficiency of the nodes (for BD and WD graphs, In and Out Global efficiencies).

Implement the degree assortativity coefficient.

Rewrite Distance as a Measure class.

• Add Distance

• add Distance test

missing Measure.copyElement()

Calculate the eccentricity of each node. Calculate the eccentricity of the graph.

Calculate Transitivity for a graph.

Transitivity can be calculated for BD, BU, WD and WU graphs. It is a global measure.

Write the associated test functions.

Add comments for remove_diagonal, remove_negative_weights, symmetrize

Follow style from Braph 1.0

After implementing the Global efficiency measure, implement local efficiency (which is defined as the global efficiency on the subgraph of node neighbors - nodal measure).

This needs to implemented with care, because the current algorithm in Braph is a bit slow, making the local efficiency generally a limiting factor for these calculations.

Implement also the In and Out Local efficiency (nodal measures).

Implement the global counterparts of these 3 measures.

test that a matrix get symmetric, also with each of the rules

Cant create new derived class from Measures.

Write test scripts:

• test_Graph
• test_GraphBD
• test_GraphBU
• test_GraphWD
• test_GraphWU

These are the global measures,
see http://braph.org/manual/graph-measures/

Check here for definitions:
http://braph.org/manual/graph-measures/

Write test scripts:

• Degree
• DegreeAv
• InDegree
• InDegreeAv
• OutDegree
• OutDegreeAv
• Strength
• StrengthAv
• InStrength
• InStrengthAv
• OutStrength
• OutStrengthAv

• Measure corresponding to matrix B in the distance for W matrices

• test function

• check if revision of Distance is needed

Calculate clustering coefficient for Binary Undirected graphs.

Calculate a community structure of a graph. Also write the corresponding test function.

For the calculation, two parameters need to be passed: algorithm that will be used in calculation (Louvain and Newman) and gamma parameters (that defines the resolution of the community).

Issues to decide:

1. How the community will be implemented for a graph. It is not nodal or global measure in the traditional sense, but the output is indeed a number for each node (number of community to which it participates).
2. Whether to use the optimization procedure described in other toolboxes. The procedure entails calculating the community structure few times (typically 10 or 100) and use the structure that produces maximum modularity.

Using the distance function, calculate path length of each node.

Path length can be calculated for BU and WU graph. For BD and WD graphs, calculate In and Out - path length for all nodes.

For binary graphs, path length is based on the number of edges needing to reach one node starting from the other. For weighted graphs, the calculation is based on the weights of the edges (Dijkstra's algorithm). Since we have distance based on the number of edges, maybe this variant can be implemented for weighted graphs also.

Calculate the path length of a graph (BU, WU graphs). Calculate the In and Out - path length of the graph in the case of BD and WD graphs.

The path length is simply the average of the nodal path lengths for all nodes in the graph. The average can be performed in three ways:

1. Simple average
2. within connected subgraphs
3. Harmonic mean

Once these are implemented, we can discuss about additional ways to perform the averaging procedure. Also, if a graph is disconnected, path length calculated as 1) returns NaN. Based on what we need, we can have additional ways to deal with it (return 0, output warning, etc..).

• remove_diagonal -> dediagonalize

• remove_negative_weights -> semipositivize

create/check test functions:

• test_dediagonalize

• test_symmetrize

• test_semipositivize

These are the global measures,
see
http://braph.org/manual/graph-measures/