Implementing Sparse Vector in Java

Sparse vectors constitute an essential data structure in many applications, such as scientific computing, machine learning, and information retrieval. They are especially helpful when working with high-dimensional data, where the majority of the elements are zeros. This article offers a thorough walkthrough of creating a sparse vector in Java, emphasizing important ideas and design decisions and including working code samples.

What is a Sparse Vector?

A sparse vector consists of a large proportion of zero elements. It only keeps the non-zero elements and their indices, not all of the elements. This method can result in more efficient computations while also saving memory.

Advantages of Sparse Vector

Storage Efficiency: Instead of using a traditional array to store all elements, a sparse vector uses a data structure to store only non-zero elements and their indices.
Time Complexity: Operations on sparse vectors should ideally have a time complexity that depends on the number of non-zero elements rather than the total number of elements.
Data Structure Choice: Common data structures for implementing sparse vectors include hash maps, arrays of index-value pairs, or linked lists.

In this implementation, the indices and values of the non-zero entries will be stored in a HashMap<Integer, Double>. This decision guarantees effective insertion and retrieval processes.

Implementation of a Sparse Vector

File Name: SparseVector.java

import java.util.HashMap;
import java.util.Map;
public class SparseVector {
    private final Map<Integer, Double> elements;
    private final int size;
    public SparseVector(int size) {
        this.size = size;
        this.elements = new HashMap<>();
    }
    public void set(int index, double value) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        if (value != 0.0) {
            elements.put(index, value);
        } else {
            elements.remove(index);
        }
    }
    public double get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        return elements.getOrDefault(index, 0.0);
    }
    public int getSize() {
        return size;
    }
    public SparseVector add(SparseVector other) {
        if (this.size != other.size) {
            throw new IllegalArgumentException("Vector sizes do not match");
        }
        SparseVector result = new SparseVector(this.size);
        for (Map.Entry<Integer, Double> entry : this.elements.entrySet()) {
            result.set(entry.getKey(), entry.getValue());
        }
        for (Map.Entry<Integer, Double> entry : other.elements.entrySet()) {
            result.set(entry.getKey(), result.get(entry.getKey()) + entry.getValue());
        }
        return result;
    }
    public double dot(SparseVector other) {
        if (this.size != other.size) {
            throw new IllegalArgumentException("Vector sizes do not match");
        }
        double result = 0.0;
        for (Map.Entry<Integer, Double> entry : this.elements.entrySet()) {
            result += entry.getValue() * other.get(entry.getKey());
        }
        return result;
    }
    public static void main(String[] args) {
        SparseVector vector1 = new SparseVector(10);
        vector1.set(1, 3.0);
        vector1.set(4, 2.5);
        SparseVector vector2 = new SparseVector(10);
        vector2.set(1, 1.5);
        vector2.set(5, 4.5);
        SparseVector sum = vector1.add(vector2);
        double dotProduct = vector1.dot(vector2);
        System.out.println("Sum vector: ");
        for (int i = 0; i < sum.getSize(); i++) {
            System.out.print(sum.get(i) + " ");
        }
        System.out.println("\nDot product: " + dotProduct);
    }
}

Output:

Sum vector: 
0.0 4.5 0.0 0.0 2.5 4.5 0.0 0.0 0.0 0.0 
Dot product: 4.5

Explanation

By storing just, the non-zero items in a HashMap, the Java SparseVector class defined by the provided code effectively handles vectors with a high number of zero elements. The class contains methods to set and receive values at given indices, guaranteeing that indices are within bounds and that zero values are deleted to maintain sparsity.

It also includes a constructor to initialize the vector with a specified size. Two sparse vectors of the same size can be added using the add method, which combines their non-zero elements. By iterating over the non-zero items and adding the products of related elements, the dot technique determines the dot product of two sparse vectors. The main method shows how to create two sparse vectors, specify some parameters, and then add them.

Conclusion

When dealing with high-dimensional data that has a large number of zero members, Java's sparse vector implementation can greatly maximise processing efficiency and memory use.

The given method ensures efficient insertion, retrieval, and fundamental vector operations like addition and dot product by storing non-zero elements in a HashMap. This method can be expanded and modified to satisfy the requirements of different applications that work with sparse data.

Next TopicJava-util-concurrent-exchanger-class-with-examples

← prev next →