Replaced binary with decimal

Author: Hardvan

src/main/java/com/thealgorithms/bitmanipulation/BcdConversion.java

@@ -1,7 +1,7 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * This class provides methods to convert between BCD (Binary-Coded Decimal) and binary.
+ * This class provides methods to convert between BCD (Binary-Coded Decimal) and decimal numbers.
  *
  * BCD is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
  *
@@ -10,32 +10,32 @@
  *
  * <b>Example usage:</b>
  * <pre>
- * int binary = BcdConversion.bcdToBinary(0x1234);
- * System.out.println("BCD 0x1234 to binary: " + binary); // Output: 1234
+ * int decimal = BcdConversion.bcdToDecimal(0x1234);
+ * System.out.println("BCD 0x1234 to decimal: " + decimal); // Output: 1234
  *
- * int bcd = BcdConversion.binaryToBcd(1234);
- * System.out.println("Binary 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
+ * int bcd = BcdConversion.decimalToBcd(1234);
+ * System.out.println("Decimal 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
  * </pre>
  */
 public final class BcdConversion {
     private BcdConversion() {
     }
 
     /**
-     * Converts a BCD (Binary-Coded Decimal) number to binary.
+     * Converts a BCD (Binary-Coded Decimal) number to a decimal number.
      * <p>Steps:
      * <p>1. Validate the BCD number to ensure all digits are between 0 and 9.
      * <p>2. Extract the last 4 bits (one BCD digit) from the BCD number.
-     * <p>3. Multiply the extracted digit by the corresponding power of 10 and add it to the binary number.
+     * <p>3. Multiply the extracted digit by the corresponding power of 10 and add it to the decimal number.
      * <p>4. Shift the BCD number right by 4 bits to process the next BCD digit.
      * <p>5. Repeat steps 1-4 until the BCD number is zero.
      *
      * @param bcd The BCD number.
-     * @return The corresponding binary number.
+     * @return The corresponding decimal number.
      * @throws IllegalArgumentException if the BCD number contains invalid digits.
      */
-    public static int bcdToBinary(int bcd) {
-        int binary = 0;
+    public static int bcdToDecimal(int bcd) {
+        int decimal = 0;
         int multiplier = 1;
 
         // Validate BCD digits
@@ -44,37 +44,37 @@ public static int bcdToBinary(int bcd) {
             if (digit > 9) {
                 throw new IllegalArgumentException("Invalid BCD digit: " + digit);
             }
-            binary += digit * multiplier;
+            decimal += digit * multiplier;
             multiplier *= 10;
             bcd >>= 4;
         }
-        return binary;
+        return decimal;
     }
 
     /**
-     * Converts a binary number to BCD (Binary-Coded Decimal).
+     * Converts a decimal number to BCD (Binary-Coded Decimal).
      * <p>Steps:
-     * <p>1. Check if the binary number is within the valid range for BCD (0 to 9999).
-     * <p>2. Extract the last decimal digit from the binary number.
+     * <p>1. Check if the decimal number is within the valid range for BCD (0 to 9999).
+     * <p>2. Extract the last decimal digit from the decimal number.
      * <p>3. Shift the digit to the correct BCD position and add it to the BCD number.
-     * <p>4. Remove the last decimal digit from the binary number.
-     * <p>5. Repeat steps 2-4 until the binary number is zero.
+     * <p>4. Remove the last decimal digit from the decimal number.
+     * <p>5. Repeat steps 2-4 until the decimal number is zero.
      *
-     * @param binary The binary number.
+     * @param decimal The decimal number.
      * @return The corresponding BCD number.
-     * @throws IllegalArgumentException if the binary number is greater than 9999.
+     * @throws IllegalArgumentException if the decimal number is greater than 9999.
      */
-    public static int binaryToBcd(int binary) {
-        if (binary < 0 || binary > 9999) {
-            throw new IllegalArgumentException("Value out of bounds for BCD representation: " + binary);
+    public static int decimalToBcd(int decimal) {
+        if (decimal < 0 || decimal > 9999) {
+            throw new IllegalArgumentException("Value out of bounds for BCD representation: " + decimal);
         }
 
         int bcd = 0;
         int shift = 0;
-        while (binary > 0) {
-            int digit = binary % 10;
+        while (decimal > 0) {
+            int digit = decimal % 10;
             bcd |= (digit << (shift * 4));
-            binary /= 10;
+            decimal /= 10;
             shift++;
         }
         return bcd;

src/test/java/com/thealgorithms/bitmanipulation/BcdConversionTest.java

@@ -8,78 +8,78 @@
 public class BcdConversionTest {
 
     @Test
-    public void testBcdToBinary() {
-        int binary = BcdConversion.bcdToBinary(0x1234);
-        assertEquals(1234, binary); // BCD 0x1234 should convert to binary 1234
+    public void testBcdToDecimal() {
+        int decimal = BcdConversion.bcdToDecimal(0x1234);
+        assertEquals(1234, decimal); // BCD 0x1234 should convert to decimal 1234
     }
 
     @Test
-    public void testBinaryToBcd() {
-        int bcd = BcdConversion.binaryToBcd(1234);
-        assertEquals(0x1234, bcd); // Binary 1234 should convert to BCD 0x1234
+    public void testDecimalToBcd() {
+        int bcd = BcdConversion.decimalToBcd(1234);
+        assertEquals(0x1234, bcd); // Decimal 1234 should convert to BCD 0x1234
     }
 
     @Test
-    public void testBcdToBinaryZero() {
-        int binary = BcdConversion.bcdToBinary(0x0);
-        assertEquals(0, binary); // BCD 0x0 should convert to binary 0
+    public void testBcdToDecimalZero() {
+        int decimal = BcdConversion.bcdToDecimal(0x0);
+        assertEquals(0, decimal); // BCD 0x0 should convert to decimal 0
     }
 
     @Test
-    public void testBinaryToBcdZero() {
-        int bcd = BcdConversion.binaryToBcd(0);
-        assertEquals(0x0, bcd); // Binary 0 should convert to BCD 0x0
+    public void testDecimalToBcdZero() {
+        int bcd = BcdConversion.decimalToBcd(0);
+        assertEquals(0x0, bcd); // Decimal 0 should convert to BCD 0x0
     }
 
     @Test
-    public void testBcdToBinarySingleDigit() {
-        int binary = BcdConversion.bcdToBinary(0x7);
-        assertEquals(7, binary); // BCD 0x7 should convert to binary 7
+    public void testBcdToDecimalSingleDigit() {
+        int decimal = BcdConversion.bcdToDecimal(0x7);
+        assertEquals(7, decimal); // BCD 0x7 should convert to decimal 7
     }
 
     @Test
-    public void testBinaryToBcdSingleDigit() {
-        int bcd = BcdConversion.binaryToBcd(7);
-        assertEquals(0x7, bcd); // Binary 7 should convert to BCD 0x7
+    public void testDecimalToBcdSingleDigit() {
+        int bcd = BcdConversion.decimalToBcd(7);
+        assertEquals(0x7, bcd); // Decimal 7 should convert to BCD 0x7
     }
 
     @Test
-    public void testBcdToBinaryMaxValue() {
-        int binary = BcdConversion.bcdToBinary(0x9999);
-        assertEquals(9999, binary); // BCD 0x9999 should convert to binary 9999
+    public void testBcdToDecimalMaxValue() {
+        int decimal = BcdConversion.bcdToDecimal(0x9999);
+        assertEquals(9999, decimal); // BCD 0x9999 should convert to decimal 9999
     }
 
     @Test
-    public void testBinaryToBcdMaxValue() {
-        int bcd = BcdConversion.binaryToBcd(9999);
-        assertEquals(0x9999, bcd); // Binary 9999 should convert to BCD 0x9999
+    public void testDecimalToBcdMaxValue() {
+        int bcd = BcdConversion.decimalToBcd(9999);
+        assertEquals(0x9999, bcd); // Decimal 9999 should convert to BCD 0x9999
     }
 
     @Test
-    public void testBcdToBinaryInvalidHighDigit() {
+    public void testBcdToDecimalInvalidHighDigit() {
         // Testing invalid BCD input where one of the digits is > 9
         assertThrows(IllegalArgumentException.class, () -> {
-            BcdConversion.bcdToBinary(0x123A); // Invalid BCD, 'A' is not a valid digit
+            BcdConversion.bcdToDecimal(0x123A); // Invalid BCD, 'A' is not a valid digit
         });
     }
 
     @Test
-    public void testBinaryToBcdInvalidValue() {
+    public void testDecimalToBcdInvalidValue() {
         // Testing conversion for numbers greater than 9999, which cannot be represented in BCD
         assertThrows(IllegalArgumentException.class, () -> {
-            BcdConversion.binaryToBcd(10000); // 10000 is too large for BCD representation
+            BcdConversion.decimalToBcd(10000); // 10000 is too large for BCD representation
         });
     }
 
     @Test
-    public void testBcdToBinaryLeadingZeroes() {
-        int binary = BcdConversion.bcdToBinary(0x0234);
-        assertEquals(234, binary); // BCD 0x0234 should convert to binary 234, ignoring leading zero
+    public void testBcdToDecimalLeadingZeroes() {
+        int decimal = BcdConversion.bcdToDecimal(0x0234);
+        assertEquals(234, decimal); // BCD 0x0234 should convert to decimal 234, ignoring leading zero
     }
 
     @Test
-    public void testBinaryToBcdLeadingZeroes() {
-        int bcd = BcdConversion.binaryToBcd(234);
-        assertEquals(0x0234, bcd); // Binary 234 should convert to BCD 0x0234
+    public void testDecimalToBcdLeadingZeroes() {
+        int bcd = BcdConversion.decimalToBcd(234);
+        assertEquals(0x0234, bcd); // Decimal 234 should convert to BCD 0x0234
     }
 }