Merge branch 'master' into euler_add_tests

Author: alxkm

DIRECTORY.md

@@ -938,6 +938,7 @@
             * [CeilTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CeilTest.java)
             * [CollatzConjectureTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CollatzConjectureTest.java)
             * [CombinationsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CombinationsTest.java)
+            * [ConvolutionFFTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/ConvolutionFFTTest.java)
             * [ConvolutionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/ConvolutionTest.java)
             * [CrossCorrelationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CrossCorrelationTest.java)
             * [DeterminantOfMatrixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/DeterminantOfMatrixTest.java)
@@ -1029,6 +1030,7 @@
             * [MedianOfMatrixtest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MedianOfMatrixtest.java)
             * [MedianOfRunningArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MedianOfRunningArrayTest.java)
             * [MirrorOfMatrixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MirrorOfMatrixTest.java)
+            * [PalindromePrimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/PalindromePrimeTest.java)
             * [PalindromeSinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/PalindromeSinglyLinkedListTest.java)
             * [RangeInSortedArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/RangeInSortedArrayTest.java)
             * [ThreeSumProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/ThreeSumProblemTest.java)

src/main/java/com/thealgorithms/datastructures/buffers/CircularBuffer.java

@@ -2,27 +2,62 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
+/**
+ * The {@code CircularBuffer} class implements a generic circular (or ring) buffer.
+ * A circular buffer is a fixed-size data structure that operates in a FIFO (First In, First Out) manner.
+ * The buffer allows you to overwrite old data when the buffer is full and efficiently use limited memory.
+ * When the buffer is full, adding a new item will overwrite the oldest data.
+ *
+ * @param <Item> The type of elements stored in the circular buffer.
+ */
 public class CircularBuffer<Item> {
     private final Item[] buffer;
     private final CircularPointer putPointer;
     private final CircularPointer getPointer;
     private final AtomicInteger size = new AtomicInteger(0);
 
+    /**
+     * Constructor to initialize the circular buffer with a specified size.
+     *
+     * @param size The size of the circular buffer.
+     * @throws IllegalArgumentException if the size is zero or negative.
+     */
     public CircularBuffer(int size) {
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size must be positive");
+        }
         // noinspection unchecked
         this.buffer = (Item[]) new Object[size];
         this.putPointer = new CircularPointer(0, size);
         this.getPointer = new CircularPointer(0, size);
     }
 
+    /**
+     * Checks if the circular buffer is empty.
+     * This method is based on the current size of the buffer.
+     *
+     * @return {@code true} if the buffer is empty, {@code false} otherwise.
+     */
     public boolean isEmpty() {
         return size.get() == 0;
     }
 
+    /**
+     * Checks if the circular buffer is full.
+     * The buffer is considered full when its size equals its capacity.
+     *
+     * @return {@code true} if the buffer is full, {@code false} otherwise.
+     */
     public boolean isFull() {
         return size.get() == buffer.length;
     }
 
+    /**
+     * Retrieves and removes the item at the front of the buffer (FIFO).
+     * This operation will move the {@code getPointer} forward.
+     *
+     * @return The item at the front of the buffer, or {@code null} if the buffer is empty.
+     */
     public Item get() {
         if (isEmpty()) {
             return null;
@@ -33,31 +68,64 @@ public Item get() {
         return item;
     }
 
+    /**
+     * Adds an item to the end of the buffer (FIFO).
+     * If the buffer is full, this operation will overwrite the oldest data.
+     *
+     * @param item The item to be added.
+     * @throws IllegalArgumentException if the item is null.
+     * @return {@code true} if the item was successfully added, {@code false} if the buffer was full and the item overwrote existing data.
+     */
     public boolean put(Item item) {
+        if (item == null) {
+            throw new IllegalArgumentException("Null items are not allowed");
+        }
+
+        boolean wasEmpty = isEmpty();
         if (isFull()) {
-            return false;
+            getPointer.getAndIncrement(); // Move get pointer to discard oldest item
+        } else {
+            size.incrementAndGet();
         }
 
         buffer[putPointer.getAndIncrement()] = item;
-        size.incrementAndGet();
-        return true;
+        return wasEmpty;
     }
 
+    /**
+     * The {@code CircularPointer} class is a helper class used to track the current index (pointer)
+     * in the circular buffer.
+     * The max value represents the capacity of the buffer.
+     * The `CircularPointer` class ensures that the pointer automatically wraps around to 0
+     * when it reaches the maximum index.
+     * This is achieved in the `getAndIncrement` method, where the pointer
+     * is incremented and then taken modulo the maximum value (`max`).
+     * This operation ensures that the pointer always stays within the bounds of the buffer.
+     */
     private static class CircularPointer {
         private int pointer;
         private final int max;
 
+        /**
+         * Constructor to initialize the circular pointer.
+         *
+         * @param pointer The initial position of the pointer.
+         * @param max The maximum size (capacity) of the circular buffer.
+         */
         CircularPointer(int pointer, int max) {
             this.pointer = pointer;
             this.max = max;
         }
 
+        /**
+         * Increments the pointer by 1 and wraps it around to 0 if it reaches the maximum value.
+         * This ensures the pointer always stays within the buffer's bounds.
+         *
+         * @return The current pointer value before incrementing.
+         */
         public int getAndIncrement() {
-            if (pointer == max) {
-                pointer = 0;
-            }
             int tmp = pointer;
-            pointer++;
+            pointer = (pointer + 1) % max;
             return tmp;
         }
     }

src/main/java/com/thealgorithms/datastructures/trees/BinaryTree.java

@@ -281,7 +281,7 @@ public void preOrder(Node localRoot) {
     }
 
     /**
-     * Prints rightChild - leftChild - root
+     * Prints leftChild - rightChild - root
      *
      * @param localRoot The local root of the binary tree
      */

src/main/java/com/thealgorithms/maths/FFT.java

@@ -165,6 +165,14 @@ public Complex divide(double n) {
             temp.img = this.img / n;
             return temp;
         }
+
+        public double real() {
+            return real;
+        }
+
+        public double imaginary() {
+            return img;
+        }
     }
 
     /**

src/main/java/com/thealgorithms/misc/PalindromePrime.java

@@ -1,51 +1,57 @@
 package com.thealgorithms.misc;
 
-import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.List;
 
 public final class PalindromePrime {
     private PalindromePrime() {
     }
 
-    public static void main(String[] args) { // Main function
-        Scanner in = new Scanner(System.in);
-        System.out.println("Enter the quantity of First Palindromic Primes you want");
-        int n = in.nextInt(); // Input of how many first palindromic prime we want
-        functioning(n); // calling function - functioning
-        in.close();
-    }
+    public static boolean prime(int num) {
+        if (num < 2) {
+            return false; // Handle edge case for numbers < 2
+        }
+        if (num == 2) {
+            return true; // 2 is prime
+        }
+        if (num % 2 == 0) {
+            return false; // Even numbers > 2 are not prime
+        }
 
-    public static boolean prime(int num) { // checking if number is prime or not
         for (int divisor = 3; divisor <= Math.sqrt(num); divisor += 2) {
             if (num % divisor == 0) {
-                return false; //  false if not prime
+                return false;
             }
         }
-        return true; // True if prime
+        return true;
     }
 
-    public static int reverse(int n) { //  Returns  the reverse of the number
+    public static int reverse(int n) {
         int reverse = 0;
         while (n != 0) {
-            reverse *= 10;
-            reverse += n % 10;
+            reverse = reverse * 10 + (n % 10);
             n /= 10;
         }
         return reverse;
     }
 
-    public static void functioning(int y) {
-        if (y == 0) {
-            return;
+    public static List<Integer> generatePalindromePrimes(int n) {
+        List<Integer> palindromicPrimes = new ArrayList<>();
+        if (n <= 0) {
+            return palindromicPrimes; // Handle case for 0 or negative input
         }
-        System.out.print(2 + "\n"); // print the first Palindromic Prime
+
+        palindromicPrimes.add(2); // 2 is the first palindromic prime
         int count = 1;
         int num = 3;
-        while (count < y) {
-            if (num == reverse(num) && prime(num)) { // number is prime and it's reverse is same
-                count++; // counts check when to terminate while loop
-                System.out.print(num + "\n"); // print the Palindromic Prime
+
+        while (count < n) {
+            if (num == reverse(num) && prime(num)) {
+                palindromicPrimes.add(num);
+                count++;
             }
-            num += 2; // inrease iterator value by two
+            num += 2; // Skip even numbers
         }
+        return palindromicPrimes;
     }
 }