# Set and Cluster Similarity in R

The following set similarity functions are written in C++ for easy integration
with R using the `sourceCpp`

command.

The first function computes the Jaccard index assuming inputs are unique, sorted integers where each integer denotes an element of a set. L1 and L2 are both sets.

```
/**
* The Jaccard Similarity Coefficient or Jaccard Index is used to compare the
* similarity/diversity of sample sets. It is defined as the size of the
* intersection of the sets divided by the size of the union of the sets.
*
* INPUTS:
* L1: A list of unique, sorted integers denoting set elements.
* L2: A list of unique, sorted integers denoting set elements.
*
* RETURNS:
* Size(Intersection(L1,L2))/Size(Union(L1,L2))
*
* SIDE-EFFECTS:
* None: this is the 21st-century.
*
* COMPLEXITY:
* Time: O(N1+N2)
* Space: O(1)
*/
// [[Rcpp::export]]
NumericVector JaccardSimilarity(const NumericVector L1, const NumericVector L2){
int n1 = L1.size(); //Number of elmeents in set 1
int n2 = L2.size(); //Number of elmeents in set 2
int i1 = 0; //Current element of interest in set 1
int i2 = 0; //Current element of interest in set 2
int size_intersection = 0; //Result: to be incremented in algorithm
int size_union = 0; //Result: to be incremented in algorithm
while(true){
if(i1==n1){
size_union += n2-i2;
break;
} else if (i2==n2){
size_union += n1-i1;
break;
}
if(L1[i1]==L2[i2]){ //Element is in both sets.
i1++; //Therefore, we discard both the current element
i2++; //from both sets and mark the current element as
size_union++; //being part of both the union and the
size_intersection++; //intersection
} else if(L1[i1]<L2[i2]){ //Element is only in the first set.
i1++; //Throw it out
size_union++; //and mark it as a member of only the union
} else if(L1[i1]>L2[i2]){ //Element is only in the second set.
i2++; //Throw it out
size_union++; //and mark it as a member of only the union
}
}
return NumericVector::create((double)size_intersection/(double)size_union);
}
```

The second function computes the Jaccard index assuming only that L1 and L2 are both sets whose integers indicate set members.

```
/**
* The Jaccard Similarity Coefficient or Jaccard Index is used to compare the
* similarity/diversity of sample sets. It is defined as the size of the
* intersection of the sets divided by the size of the union of the sets.
*
* INPUTS:
* L1: A list of integers denoting set elements.
* L2: A list of integers denoting set elements.
*
* RETURNS:
* Size(Intersection(L1,L2))/Size(Union(L1,L2))
*
* SIDE-EFFECTS:
* None: this is the 21st-century.
*
* COMPLEXITY:
* Time: O(N1+N2)
* Space: O(N1+N2) worst-case
*/
#include <unordered_map>
// [[Rcpp::export]]
NumericVector JaccardSimilarityUnsorted(const NumericVector L1, const NumericVector L2){
int n1 = L1.size(); //Number of elmeents in set 1
int n2 = L2.size(); //Number of elmeents in set 2
int size_intersection = 0; //Result: to be incremented in algorithm
int size_union = 0; //Result: to be incremented in algorithm
std::unordered_map<int, unsigned char> seen;
for(int i1=0;i1<n1;i1++){ //Loop through all elements in Set 1
if(!seen.count(L1[i1])){ //If we haven't seen the element before
seen[L1[i1]] = 1; //Mark it as having been seen in Set 1
size_union++; //And as being part of the union
}
}
for(int i2=0;i2<n2;i2++){ //Loop through all elements in Set 2
if(!seen.count(L2[i2])){ //If we have not seen the element before
size_union++; //then it is part of the union.
seen[L2[i2]] = 2; //Mark it as being done.
} else if(seen[L2[i2]]==1){ //Elsewise, we've seen the element in the
size_intersection++; //Set 1, it is part of the intersection
//But not the union, because that would
//be double counting.
seen[L2[i2]] = 2; //Mark it as being done.
}
}
return NumericVector::create((double)size_intersection/(double)size_union);
}
```

This function, due to Jamie Murdoch, quickly computes the Fowlkes-Mallows index of a cluster assignment.

```
/**
* Third iteration of the Fowlkes and Mallows similarity in C++.
* For each cluster i, track the number of elements in that cluster.
* For each pair of clusters (x, y), track the number of elements assigned to x
* in L1 and to y in L2. This is the "overlap" between x and y.
* <C1, C1> is the sum of squares of cluster sizes. To see this, note that
* for all pairs of elements i, j in cluster x, c_{ij} = 1. For all pairs
* of elements in different clusters, c_{ij} = 0. Then, for each cluster x,
* the number of elements with value 1 in C_{ij} is |x|^2, the square of the
* cluster size.
* Another way to see this is that C_{ij} is an adjacency matrix for a graph, in
* which the clusters represent separate cliques. We want to count the number
* of edges for each clique, counting self-edges once and undirected edges
* between elements twice.
* <C1, C2> is the sum of squares of overlap sizes. To see this, consider the
* overlap O_{xy} between clusters x and y. This is the number of elements that
* belong to x in L1 and to y in L2. For any pair (i,j) of these elements,
* C_{ij} = 1 in both C1 and C2. This ordered pair contributes 1 to <C1, C2>.
* We sum these contributions across all pairs in the overlap (of which there
* are |O_{xy}|^2) and all overlaps.
*
* INPUTS:
* L1: Each item of the list is a point. The number stored at the element
* is the cluster the point is assigned to.
* L2: The same as L1. Must be the same length as L1.
*
* RETURNS:
* The Fowlkes and Mallows index
*
* SIDE-EFFECTS:
* None
*
* COMPLEXITY:
* Time: O(K^2+n), where K = number of clusters
* Space: O(K^2)
*
* SOURCES:
* Asa Ben-Hur, Andre Elisseeff, and Isabelle Guyon (2001) A stability based
* method for discovering structure in clustered data. Biocomputing 2002: pp.
* 6-17.
*/
// [[Rcpp::export]]
NumericVector FowlkesMallows(const NumericVector L1, const NumericVector L2){
int n = L1.size();
int K = max(L1);
ind overlaps[K][K];
ind cluster_sizes1[K], cluster_sizes2[K];
for(int i = 0; i < K; i++){
cluster_sizes1[i] = 0;
cluster_sizes2[i] = 0;
for(int j = 0; j < K; j++)
overlaps[i][j] = 0;
}
//O(n) time. O(K^2) space. Determine the size of each cluster as well as the
//size of the overlaps between the clusters.
for(int i = 0; i < n; i++){
cluster_sizes1[(int)L1[i] - 1]++; // -1's account for zero-based indexing
cluster_sizes2[(int)L2[i] - 1]++;
overlaps[(int)L1[i] - 1][(int)L2[i] - 1]++;
}
// O(K^2) time. O(1) space. Square the overlap values.
int C1dotC2 = 0;
for(int j = 0; j < K; j++){
for(int k = 0; k < K; k++){
C1dotC2 += pow(overlaps[j][k], 2);
}
}
// O(K) time. O(1) space. Square the cluster sizes
int C1dotC1 = 0, C2dotC2 = 0;
for(int i = 0; i < K; i++){
C1dotC1 += pow(cluster_sizes1[i], 2);
C2dotC2 += pow(cluster_sizes2[i], 2);
}
return NumericVector::create((double)C1dotC2 / (sqrt(C1dotC1) * sqrt(C2dotC2)));
}
```

We can modify the above to quickly compute the cluster assignment similarity using the Jaccard index, as suggested by Ben-Hur, Elisseeff, and Guyon (2002).

```
/**
* The Jaccard Similarity Coefficient or Jaccard Index is used to compare the
* similarity/diversity of sample sets. It is defined as the size of the
* intersection of the sets divided by the size of the union of the sets. Here,
* it is used to determine how similar to clustering assignments are.
*
* INPUTS:
* L1: A list. Each element of the list is a number indicating the cluster
* assignment of that number.
* L2: The same as L1. Must be the same length as L1.
*
* RETURNS:
* The Jaccard Similarity Index
*
* SIDE-EFFECTS:
* None
*
* COMPLEXITY:
* Time: O(K^2+n), where K = number of clusters
* Space: O(K^2)
*
* SOURCES:
* Asa Ben-Hur, Andre Elisseeff, and Isabelle Guyon (2001) A stability based
* method for discovering structure in clustered data. Biocomputing 2002: pp.
* 6-17.
*/
// [[Rcpp::export]]
NumericVector JaccardIndex(const NumericVector L1, const NumericVector L2){
int n = L1.size();
int K = max(L1);
ind overlaps[K][K];
ind cluster_sizes1[K], cluster_sizes2[K];
for(int i = 0; i < K; i++){
cluster_sizes1[i] = 0;
cluster_sizes2[i] = 0;
for(int j = 0; j < K; j++)
overlaps[i][j] = 0;
}
//O(n) time. O(K^2) space. Determine the size of each cluster as well as the
//size of the overlaps between the clusters.
for(int i = 0; i < n; i++){
cluster_sizes1[(int)L1[i] - 1]++; // -1's account for zero-based indexing
cluster_sizes2[(int)L2[i] - 1]++;
overlaps[(int)L1[i] - 1][(int)L2[i] - 1]++;
}
// O(K^2) time. O(1) space. Square the overlap values.
int C1dotC2 = 0;
for(int j = 0; j < K; j++){
for(int k = 0; k < K; k++){
C1dotC2 += pow(overlaps[j][k], 2);
}
}
// O(K) time. O(1) space. Square the cluster sizes
int C1dotC1 = 0, C2dotC2 = 0;
for(int i = 0; i < K; i++){
C1dotC1 += pow(cluster_sizes1[i], 2);
C2dotC2 += pow(cluster_sizes2[i], 2);
}
return NumericVector::create((double)C1dotC2/(double)(C1dotC1+C2dotC2-C1dotC2));
}
```