# Degree

In graph theory, the degree of a vertex (node) of a graph is the number of edges that are incident to the node. In Ultipa Graph, all per-node degree operations are conducted in a pure real-time fashion. Only whole-graph degree operations are invoked as tasks (asynchronously) due to computational complexity, especially on large graphs.

`Note that in multigraphs, a loop (an edge whose starting node and ending node are identical) is counted as two edges`

`algo(out_degree)`

** Basic **
** Real-time **

Out Degree is a per-node degree operation that calculates the total number of edges pointing away from a node, weight factor of edge could be applied.

Configuration items for out degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<node_id>` |
int | Ultipa ID | To calculate for a specific node |

`<edge_property_name>` |
string | Edge property (numeric type) | (Optional) The edge property (must be LTE first) to be used as the weight factor of edge, or use 1 as weight factor if not configured |

Validity of `write_back()`

:

Not supported.

Example 1: Calculate the Out Degree of node (_id = 12)

```
algo(out_degree)
.params( {node_id: 12} )
```

*Figure: Running real-time Algorithm --- Out Degree*

Example 2: To verify the result of Example 1, spread from node (_id = 12) via right-directed edges.

```
spread()
.src(12).depth(1)
.direction(right).limit(1000)
```

*Figure: Verifying Algorithm Calculation Results with spread()*

Note: A `khop()`

query is NOT a proper way to verify a degree operation, since that `khop()`

query returns a bunch of 'de-duplicated' neighbors that do not reflect the number of incident edges.

Example 3: Same as Example 1, but using edge property 'rank' as weight factor, return the sum of all edges' rank values

```
algo(out_degree)
.params( {node_id: 12, edge_property_name: "rank"} )
```

*Figure: Out Degree by Edge Property*

The result shows that the Out Degree weighted by property 'rank' is 569 instead of 10 for a weightless Out Degree of node id=12.

`algo(in_degree)`

** Basic **
** Real-time **

In Degree is comparable to Out Degree, but with calculations done against the inbound edges of node.

Configuration items for in degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<node_id>` |
int | Ultipa ID | To calculate for a specific node |

`<edge_property_name>` |
string | Edge property (numeric type) | (Optional) The edge property (must be LTE first) to be used as the weight factor of edge, or use 1 as weight factor if not configured |

Validity of `write_back()`

:

Not supported.

Example 1: Calculate the In Degree of node (_id = 12)

```
algo(in_degree)
.params( {node_id: 12} )
```

*Figure: Running Real-Time Algorithm - In Degree*

Example 2: Calculate the In Degree with edge property 'rank' of node (_id = 12)

```
algo(in_degree)
.params( {node_id: 12, edge_property_name: "rank"} )
```

*Figure: In Degree by Edge Property*

`algo(degree)`

** Basic **
** Real-time **

Degree is the summed total of In Degree and Out Degree of node.

Configuration items for degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<node_id>` |
int | Ultipa ID | To calculate for a specific node |

`<edge_property_name>` |
string | Edge property (numeric type) | (Optional) The edge property (must be LTE first) to be used as the weight factor of edge, or use 1 as weight factor if not configured |

Validity of `write_back()`

:

Not supported.

Example 1: Calculate the degree of node id=12

```
algo(degree)
.params( {node_id: 12} )
```

Example 2: Calculate the degree of node id=12 using edge property 'rank' as weight factor

```
algo(degree)
.params( {node_id: 12, edge_property_name: "rank"} )
```

*Figure: Real-Time Algorithm - Degree with Edge Property*

The above result is also verified by the results from previous examples.

`algo(out_degree_all)`

** Basic **

Out Degree All is a degree calculation algorithm on out-degrees (weighted or not) for multiple nodes, or all nodes, in the graphset, the results can be ordered and partially returned.

Configuration items for whole-graph out degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<ids>` |
[]int | Ultipa ID | (Optional) To calculate for a group of nodes, or calculate for all nodes if not configured |

`<edge_property_name>` |
string | Edge property (numeric type) | |

`<limit>` |
int | >0; -1 | The maximum number of results to return; -1: return all the results |

`<order>` |
string | 'ASC' or 'DESC' | (Optional) To arrange the results in ascending or descending order, or leave them un-ordered if not configured |

Validity of `write_back()`

:

Approach | Destination |
---|---|

To database | node property `#out_degree_all` |

To disk file | / |

Example 1: Calculate the out degrees for nodes (id=1,2,3,4,5,6,7), arrange the results in descending order and return the top 3.

```
algo(out_degree_all)
.params( {ids: [1,2,3,4,5,6,7], limit: 3, order: 'DESC'} )
```

*Figure: Real-Time Algorithm - Out Degree All Top 3*

Example 2: Calculate the whole graph out degrees with edge property 'rank' being the weight factor, and write back to the database.

```
algo(out_degree_all)
.params( {edge_property_name: "rank", limit: -1} )
.write_back()
```

*Figure: Algorithm Writing Back to Graphset*

As seen from above, after running the graph-wide out-degrees with `write_back()`

included, a new node property is created, which will simply be updated (refreshed) if this algorithm is invoked again.

`algo(in_degree_all)`

** Basic **

Similar to Out Degree All, the In Degree All calculates the nodes in-degrees for selective nodes or all nodes.

Configuration items for whole-graph in degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<ids>` |
[]int | Ultipa ID | (Optional) To calculate for a group of nodes, or calculate for all nodes if not configured |

`<edge_property_name>` |
string | Edge property (numeric type) | |

`<limit>` |
int | >0; -1 | The maximum number of results to return; -1: return all the results |

`<order>` |
string | 'ASC' or 'DESC' | (Optional) To arrange the results in ascending or descending order, or leave them un-ordered if not configured |

Validity of `write_back()`

:

Approach | Destination |
---|---|

To database | node property `#in_degree_all` |

To disk file | / |

Example 1: Calculate In Degree for nodes (id=1,2,3,4,5,6,7), arrange the results in descending order and return the top 3.

```
algo(in_degree_all)
.params( {ids: [1,2,3,4,5,6,7], limit: 3, order: 'DESC'} )
```

Example 2: Calculate all nodes' In Degree for node property 'rank'

```
algo(in_degree_all)
.params( {edge_property_name: "rank", limit: -1} )
```

`algo(degree_all)`

** Basic **

Degree All is the summed total of In Degree All and Out Degree All that applied to selective nodes or graph-wide all nodes.

Configuration items for whole-graph degree operations:

Item | Data Type | Specification | Description |
---|---|---|---|

`<ids>` |
[]int | Ultipa ID | (Optional) To calculate for a group of nodes, or calculate for all nodes if not configured |

`<edge_property_name>` |
string | Edge property (numeric type) | |

`<limit>` |
int | >0; -1 | The maximum number of results to return; -1: return all the results |

`<order>` |
string | 'ASC' or 'DESC' | (Optional) To arrange the results in ascending or descending order, or leave them un-ordered if not configured |

Validity of `write_back()`

:

Approach | Destination |
---|---|

To database | node property `#degree_all` |

To disk file | / |

Example 1: Calculate degrees for nodes (id=1,2,3,4,5,6,7), arrange the results in descending order and return the top 3.

```
algo(degree_all)
.params( {ids: [1,2,3,4,5,6,7], limit: 3, order: 'DESC'} )
```

Example 2: Calculate all nodes' degree based on edge property 'rank'

```
algo(degree_all)
.params( {edge_property_name: "rank", limit: -1} )
```

## No Comments