Jaccard Similarity Coefficient In C++

In this guide, we will explore the Jaccard Similarity Coefficient in C++ through different illustrations, benefits, and drawbacks.

Jaccard Similarity:

When comparing two items like two text documents, a common metric known as Jaccard Similarity is employed to assess their likeness. The Jaccard similarity metric is utilized to evaluate the resemblance between two collections or two non-symmetric binary vectors. In academic works, Jaccard similarity is denoted by the symbol J.

A common statistical metric for measuring the diversity and resemblance between sets of samples is the Jaccard Similarity Coefficient. This coefficient is frequently applied in various fields like data mining, bioinformatics, and information retrieval to assess the similarity of datasets. By calculating the ratio of the union of the sets to the intersection of the sets, the coefficient is determined.

Example:

For instance, let's take into account two arrays denoted as A and B. Array A comprises elements {1,2,3,4,5}, while array B comprises elements {3,4,5,6,7}. The common elements shared between arrays A and B, known as the intersection, are {3,4,5}. On the other hand, the union of arrays A and B, which includes all elements from both sets, is {1,2,3,4,5,6,7}. To calculate the Jaccard Similarity Coefficient, you divide the size of the intersection of arrays A and B by the size of the union, resulting in a value of 0.4286 for the Jaccard Similarity Coefficient.

Use cases for Jaccard Similarity:

Several use cases for Jaccard Similarity are as follows:

• ✅ Text mining: Compare two text documents to see how similar they are by counting the terms that are used in each.
• ✅ E-commerce: Using a market database containing millions of products and thousands of customers, identify comparable customers based on their past purchases.
• ✅ System of Recommendations: When a consumer rents or rates a high number of the same movies, movie recommendation systems use the Jaccard Coefficient to identify comparable customers.

The Jaccard Similarity Coefficient scale spans from 0 to 1, with 1 indicating complete similarity between sets, and 0 representing no commonality. This feature makes it a valuable tool for comparing sets of varying sizes and identifying shared elements, even when the sets have different numbers of elements.

Pseudocode:

function jaccard_similarity_coefficient(set1, set2):
    intersection_count = 0
    union_count = 0
    for each element in the set1:
        if the element is in set:
            intersection_count += 1
        union_count += 1
    for each element in the set2:
        if the element is not in set1:
            union_count += 1
    return intersection_count / union_count

Example 1:

Let's take an example to demonstrate the Jaccard Similarity Coefficient in C++.

#include<iostream>
#include<unordered_set>
double jaccard_similarity_coefficient(const std::unordered_order <int>& set1, const std::unordered_set<int>& set2){
std::unordered_set <int> intersection, union_set;
    for (int element: set1) {
        if (set2.count(element)) {
            intersection.insert(element);
        }
        union_set.insert(element);
    }
    for (int element: set2) {
        if (!set1.count(element)) {
            union_set.insert(element);
        }
    }
    return static_cast<double>(intersection.size()) / union_set.size();
}
int main()
{
std::unordered_set<int>set1={1,2,3,4,5};
std::unordered_set<int>set2={3,4,5,6,7};
double similarity=jaccard_similarity_coefficient(set1,set2);
std::cout<<"Jaccard Similarity Coefficient"<<similarity<<std::endl;
    return 0;
}

Output:

Example 2:

Let's consider another instance to demonstrate the Jaccard Similarity Coefficient in C++.

#include<iostream>
#include<unordered_set>
double jaccard_similarity_coefficient(int set1[], int size1, int set2[],int size2)
{
std::unordered_set<int>intersection,union_set;
for(int i=0;i<size1;++i){
        intersection.insert(set1[i]);
        union_set.insert(set1[i]);
    }
    for(int i=0;i<size2;++i){
        if (!intersection.count(set2[i])) {
            union_set.insert(set2[i]);
        } else {
            intersection.erase(set2[i]);
        }
    }
    return static_cast<double>(intersection.size()) / union_set.size();
}
int main()
{
int set1[]={1,2,3,4,5};
int set2[]={3.4.5.6.7};
int size1 = sizeof(set1)/sizeof(set1[0]);
int size2=sizeof(set2)/sizeof(set2[0]);
double similarity = jaccard_similarity_coefficient(set1,size1,set2,size2);
std::cout<<"Jaccard Similarity Coefficient"<<similarity<<std::endl;
    return 0;
}

Output:

Advantages and Disadvantages of the Jaccard Similarity Coefficient:

Several benefits and drawbacks of the Jaccard Similarity Coefficient include:

Advantages:

• ✅ Simplicity: Everyone who is from a nonmathematical background can also compute and comprehend the Jaccard Similarity measure.
• ✅ Robustness: It can be used to compare sets with varying cardinalities because it is resilient to changes in dataset size.
• ✅ Versatility: Jaccard similarity can be used in a broad range of data kinds and areas from textual data to biological sequences.

Disadvantages:

• ✅ Binary Representation: To apply Jaccard similarity, data must be given in binary form, meaning that items must be present or absent. It may make it difficult to identify subtler similarities.
• ✅ Equal Weighting: It will give every element equal weights, ignoring any possible small differences in the element's significance.
• ✅ Sensitive to set size: Jaccard Similarity is resilient to changes in set size, so it might lead to inaccurate conclusions when working with small or very large data sets.

Conclusion:

In summary, data interpretation, Internal Revenue Service (IRS), and Business Intelligence (BI) are among the many areas where the Jaccard Similarity Coefficient proves valuable for comparing set similarities. Through the utilization of the Jaccard similarity coefficient in C++, we can efficiently compute similarities between sets. This capability enables us to derive insights from the data and facilitate decision-making processes.