Assessment 2:( 30 Marks)

Implementation of Page Rank Algorithm by using Java

Follow the following Steps to implement Algorithm

To implement the PageRank algorithm in Java step-by-step, you'll need to understand the basics of the algorithm. PageRank is a link analysis algorithm that assigns a numerical weight to each element of a hyperlinked set of documents, such as the World Wide Web, with the purpose of measuring its relative importance within the set.

Here's a step-by-step guide to implementing the PageRank algorithm in Java:

### Step 1: Define the Problem

We'll represent the web as a directed graph where each page is a node, and links between pages are edges. PageRank assigns each page a rank based on the number of incoming links and the rank of the linking pages.

### Step 2: Create the Java Classes

1. **Page**: Represents a web page.

2. **Graph**: Represents the entire graph of web pages.

3. **PageRank**: Implements the algorithm.

### Step 3: Set Up the Environment

Ensure you have a Java environment set up, such as Eclipse, IntelliJ IDEA, or simply using a command-line setup.

### Step 4: Create the `Page` Class

```java

import java.util.ArrayList;

import java.util.List;

public class Page {

    private String name;

    private List<Page> outboundLinks;

    public Page(String name) {

        this.name = name;

        this.outboundLinks = new ArrayList<>();

    }

    public String getName() {

        return name;

    }

    public List<Page> getOutboundLinks() {

        return outboundLinks;

    }

    public void addLink(Page page) {

        outboundLinks.add(page);

    }

}

```

### Step 5: Create the `Graph` Class

```java

import java.util.HashMap;

import java.util.Map;

public class Graph {

    private Map<String, Page> pages;

    public Graph() {

        this.pages = new HashMap<>();

    }

    public void addPage(Page page) {

        pages.put(page.getName(), page);

    }

    public Page getPage(String name) {

        return pages.get(name);

    }

    public Map<String, Page> getPages() {

        return pages;

    }

}

```

### Step 6: Implement the Page Rank Algorithm in the `Page Rank` Class

```java

import java.util.HashMap;

import java.util.Map;

public class PageRank {

    private static final double DAMPING_FACTOR = 0.85;

    private static final int ITERATIONS = 100;

    public Map<Page, Double> calculatePageRank(Graph graph) {

        Map<Page, Double> ranks = new HashMap<>();

        int totalPages = graph.getPages().size();

        // Initialize rank values to 1/N

        for (Page page : graph.getPages().values()) {

            ranks.put(page, 1.0 / totalPages);

        }

        // Iterate to update PageRank values

        for (int i = 0; i < ITERATIONS; i++) {

            Map<Page, Double> newRanks = new HashMap<>();

            for (Page page : graph.getPages().values()) {

                double inboundRankSum = 0.0;

                // Calculate the sum of ranks of inbound links

                for (Page inboundPage : graph.getPages().values()) {

                    if (inboundPage.getOutboundLinks().contains(page)) {

                        inboundRankSum += ranks.get(inboundPage) / inboundPage.getOutboundLinks().size();

                    }

                }

                // Apply the PageN Rank formula

                double new Rank = (1 - DAMPING_FACTOR) / totalPages + DAMPING_FACTOR * inboundRankSum;

                new Ranks.put (page, newRank);

            }

           // Update ranks

            ranks = new Ranks;

        }

        return ranks;

    }

}

``

### Step 7: Test the Algorithm

Create a main class to test the implementation.

```java

public class Main {

    public static void main(String[] args) {

        // Create pages

        Page a = new Page("A");

        Page b = new Page("B");

        Page c = new Page("C");

        Page d = new Page("D");

        // Add links (edges)

        a.addLink(b);

        a.addLink(c);

        b.addLink(c);

        c.addLink(a);

        c.addLink(d);

        d.addLink(c);

        // Create a graph and add pages

        Graph graph = new Graph();

        graph.addPage(a);

        graph.addPage(b);

        graph.addPage(c);

        graph.addPage(d);

        // Calculate Page Rank

        Page Rank page Rank = new Page Rank();

        Map<Page, Double> ranks = page Rank.calculate Page      Rank(graph);

        // Display results

        for (Map.Entry<Page, Double> entry : ranks.entrySet()) {

            System.out.println("Page " + entry.getKey().getName() + " has rank: " + entry.getValue());

        }

    }

}

```

### Step 8: Run and Analyze the Output

Compile and run your program. The output will display the ranks of each page in the graph. The ranks will indicate the relative importance of each page based on the Page Rank algorithm.

This implementation provides a basic understanding of Page Rank and can be further optimized and extended for more complex networks. Let me know if you need any modifications or additional features!

******************************** End of Assessment ******