feat: add numeric converter

Author: Camilo Molina Orth

README.md

@@ -21,7 +21,7 @@ You can pull it from the central Maven repositories:
 <dependency>
     <groupId>cl.bennu</groupId>
     <artifactId>commons</artifactId>
-    <version>1.4.0</version>
+    <version>1.5.0</version>
 </dependency>
 ```
 
@@ -42,13 +42,13 @@ Dependencies
 ------------
 
 - lombok 1.18.38
-- jackson-core 2.18.3
-- jackson-annotations 2.18.3
+- jackson-core 2.19.0
+- jackson-annotations 2.19.0
 - commons-lang3 3.17.0
-- commons-io 2.18.0
+- commons-io 2.19.0
 - java-jwt 4.5.0
 - commons-beanutils 1.10.1
-- commons-collections4 4.5.0-M3
+- commons-collections4 4.5.0
 - slf4j-api 2.0.17
 
 Test Dependencies

pom.xml

@@ -7,7 +7,7 @@
 
     <groupId>cl.bennu</groupId>
     <artifactId>commons</artifactId>
-    <version>1.4.0</version>
+    <version>1.5.0</version>
     <name>bennu-commons</name>
     <description>Utilitarios bennu</description>
     <url>https://github.com/bennu/commons</url>

src/main/java/cl/bennu/commons/enums/NumberSystemTypeEnum.java

@@ -0,0 +1,50 @@
+package cl.bennu.commons.enums;
+
+import cl.bennu.commons.number.*;
+import cl.bennu.commons.number.iface.SpecificNumberSystem;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.Map;
+
+@Getter
+@JsonFormat(shape = JsonFormat.Shape.OBJECT)
+public enum NumberSystemTypeEnum implements cl.bennu.commons.enums.base.BaseEnum {
+
+    //@formatter:off
+    POSITIONAL(1, "Positional")
+    , ADDITIVE(2, "Additive")
+    , MULTIPLICATIVE(3, "Multiplicative")
+    , HYBRID(4, "Hybrid")
+    , UNARY(5, "Unary")
+    , ALPHABETICAL(6, "Alphabetical")
+    , LOGOGRAPHIC(7, "Logographic")
+    , NOT_POSITIONAL(8, "Not positional")
+    , CUNEIFORM(9, "Cuneiform")
+    , NUMERICAL_SYLLABIC(10, "Numerical syllabic")
+    ;
+    //@formatter:on
+
+    NumberSystemTypeEnum(Integer id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    private final Integer id;
+    private final String name;
+
+    @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+    public static NumberSystemTypeEnum valueOf(Object o) {
+        if (o instanceof Integer id) {
+            return Arrays.stream(values()).filter(e -> e.getId().equals(id)).findFirst().orElse(null);
+        } else if (o instanceof Map map) {
+            Integer id = (Integer) map.get("id");
+            return Arrays.stream(values()).filter(e -> e.getId().equals(id)).findFirst().orElse(null);
+        } else {
+            return null;
+        }
+    }
+
+}

src/main/java/cl/bennu/commons/enums/NumericBaseEnum.java

@@ -0,0 +1,104 @@
+package cl.bennu.commons.enums;
+
+import cl.bennu.commons.number.*;
+import cl.bennu.commons.number.iface.SpecificNumberSystem;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.Map;
+
+@Getter
+@JsonFormat(shape = JsonFormat.Shape.OBJECT)
+public enum NumericBaseEnum implements cl.bennu.commons.enums.base.BaseEnum {
+
+    //@formatter:off
+    BINARY(1, 2, "Binary", NumberSystemTypeEnum.POSITIONAL)
+    , OCTAL(2, 8, "Octal", NumberSystemTypeEnum.POSITIONAL)
+    , DECIMAL(3, 10, "Decimal", NumberSystemTypeEnum.POSITIONAL)
+    , HEXADECIMAL(4, 16, "Hexadecimal", NumberSystemTypeEnum.POSITIONAL)
+
+    , TERNARY(5, 3, "Ternary", NumberSystemTypeEnum.POSITIONAL)
+    , QUATERNARY(6, 4, "Quaternary", NumberSystemTypeEnum.POSITIONAL)
+    , QUINARY(7, 5, "Quinary", NumberSystemTypeEnum.POSITIONAL)
+    , SENARY(8, 6, "Senary", NumberSystemTypeEnum.POSITIONAL)
+    , SEPTENARY(9, 7, "Septenary", NumberSystemTypeEnum.POSITIONAL)
+    , NONARY(10, 9, "Nonary", NumberSystemTypeEnum.POSITIONAL)
+    , UNDECIMAL(11, 11, "Undecimal", NumberSystemTypeEnum.POSITIONAL)
+    , DUODECIMAL(12, 12, "Duodecimal", NumberSystemTypeEnum.POSITIONAL)
+    , VIGESIMAL(13, 20, "Vigesimal", NumberSystemTypeEnum.POSITIONAL)
+
+    , ROMAN(14, new RomanNumeralSystem(),  "Roman", NumberSystemTypeEnum.ADDITIVE)
+    , ATTIC(15, new AtticNumeralSystem(),  "Attic", NumberSystemTypeEnum.ADDITIVE)
+    , EGYPTIAN(16, new EgyptianNumeralSystem(),  "Egyptian", NumberSystemTypeEnum.ADDITIVE)
+    , MAYAN(17, new MayanNumeralSystem(),  "Mayan", NumberSystemTypeEnum.NOT_POSITIONAL)
+    , BABYLONIAN(18, new BabylonianNumeralSystem(),  "Babylonian", NumberSystemTypeEnum.ADDITIVE)
+    , HEBREW(19, new HebrewNumeralSystem(),  "Hebrew", NumberSystemTypeEnum.ALPHABETICAL)
+    , GREEKIONIAN(20, new GreekIonianNumeralSystem(),  "Greek Ionian", NumberSystemTypeEnum.ALPHABETICAL)
+    , CYRILLIC(21, new CyrillicNumeralSystem(),  "Cyrillic", NumberSystemTypeEnum.NOT_POSITIONAL)
+    , AEGEAN(22, new AegeanNumeralSystem(),  "Aegean", NumberSystemTypeEnum.NOT_POSITIONAL)
+
+    , BASE_13(23, 13, "Base 13", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_14(24, 14, "Base 14", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_15(25, 15, "Base 15", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_17(26, 17, "Base 17", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_18(27, 18, "Base 18", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_19(28, 19, "Base 19", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_21(29, 21, "Base 21", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_22(30, 22, "Base 22", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_23(31, 23, "Base 23", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_24(32, 24, "Base 24", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_25(33, 25, "Base 25", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_26(34, 26, "Base 26", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_27(35, 27, "Base 27", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_28(36, 28, "Base 28", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_29(37, 29, "Base 29", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_30(38, 30, "Base 30", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_31(39, 31, "Base 31", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_32(40, 32, "Base 32", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_33(41, 33, "Base 33", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_34(42, 34, "Base 34", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_35(43, 35, "Base 35", NumberSystemTypeEnum.POSITIONAL)
+    , BASE_36(44, 36, "Base 36", NumberSystemTypeEnum.POSITIONAL)
+
+    , BRAILLE(45, new BrailleNumeralSystem(), "Braille", NumberSystemTypeEnum.NOT_POSITIONAL)
+    , MORSE(46, new MorseNumeralSystem(), "Morse", NumberSystemTypeEnum.NOT_POSITIONAL)
+    ;
+    //@formatter:on
+
+    NumericBaseEnum(Integer id, Integer base, String name, NumberSystemTypeEnum numberSystemTypeEnum) {
+        this.id = id;
+        this.base = base;
+        this.name = name;
+        this.specificNumberSystem = null;
+        this.numberSystemTypeEnum = numberSystemTypeEnum;
+    }
+
+    NumericBaseEnum(Integer id, SpecificNumberSystem specificNumberSystem, String name, NumberSystemTypeEnum numberSystemTypeEnum) {
+        this.id = id;
+        this.base = null;
+        this.name = name;
+        this.specificNumberSystem = specificNumberSystem;
+        this.numberSystemTypeEnum = numberSystemTypeEnum;
+    }
+
+    private final Integer id;
+    private final Integer base;
+    private final String name;
+    private final SpecificNumberSystem specificNumberSystem;
+    private final NumberSystemTypeEnum numberSystemTypeEnum;
+
+    @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+    public static NumericBaseEnum valueOf(Object o) {
+        if (o instanceof Integer id) {
+            return Arrays.stream(values()).filter(e -> e.getId().equals(id)).findFirst().orElse(null);
+        } else if (o instanceof Map map) {
+            Integer id = (Integer) map.get("id");
+            return Arrays.stream(values()).filter(e -> e.getId().equals(id)).findFirst().orElse(null);
+        } else {
+            return null;
+        }
+    }
+
+}

src/main/java/cl/bennu/commons/number/AegeanNumeralSystem.java

@@ -0,0 +1,65 @@
+package cl.bennu.commons.number;
+
+import cl.bennu.commons.number.iface.SpecificNumberSystem;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class AegeanNumeralSystem implements SpecificNumberSystem {
+
+    private static final LinkedHashMap<String, Long> SYMBOLS = new LinkedHashMap<>();
+
+    static {
+        SYMBOLS.put("*", 10_000L); // 𐄫
+        SYMBOLS.put("@", 1_000L);  // 𐄢
+        SYMBOLS.put("9", 100L);    // 𐄙
+        SYMBOLS.put("n", 10L);     // 𐄐
+        SYMBOLS.put("|", 1L);      // 𐄇
+    }
+
+    @Override
+    public String convert(Long number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(long number) {
+        if (number <= 0) throw new IllegalArgumentException("Number must be greater than 0");
+
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<String, Long> entry : SYMBOLS.entrySet()) {
+            while (number >= entry.getValue()) {
+                sb.append(entry.getKey());
+                number -= entry.getValue();
+            }
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public String convert(Integer number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(int number) {
+        return convert((long) number);
+    }
+
+    @Override
+    public long convert(String value) {
+        long total = 0;
+        for (char c : value.toCharArray()) {
+            String symbol = String.valueOf(c);
+            Long num = SYMBOLS.get(symbol);
+            if (num == null) throw new IllegalArgumentException("Invalid symbol: " + symbol);
+            total += num;
+        }
+        return total;
+    }
+
+}

src/main/java/cl/bennu/commons/number/AtticNumeralSystem.java

@@ -0,0 +1,77 @@
+package cl.bennu.commons.number;
+
+import cl.bennu.commons.number.iface.SpecificNumberSystem;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class AtticNumeralSystem implements SpecificNumberSystem {
+
+    private static final LinkedHashMap<String, Long> SYMBOLS = new LinkedHashMap<>();
+
+    static {
+        SYMBOLS.put("ΜΔ", 1_000_000L);
+        SYMBOLS.put("ΜΥ", 100_000L);
+        SYMBOLS.put("Μ", 10_000L);
+        SYMBOLS.put("Χ", 1_000L);
+        SYMBOLS.put("Η", 100L);
+        SYMBOLS.put("Δ", 10L);
+        SYMBOLS.put("Π", 5L);
+        SYMBOLS.put("Ι", 1L);
+    }
+
+    @Override
+    public String convert(Long number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(long number) {
+        if (number <= 0) throw new IllegalArgumentException("Number must be greater than 0");
+
+        StringBuilder result = new StringBuilder();
+        for (Map.Entry<String, Long> entry : SYMBOLS.entrySet()) {
+            while (number >= entry.getValue()) {
+                result.append(entry.getKey());
+                number -= entry.getValue();
+            }
+        }
+        return result.toString();
+    }
+
+    @Override
+    public String convert(Integer number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(int number) {
+        return convert((long) number);
+    }
+
+    @Override
+    public long convert(String value) {
+        long result = 0;
+        int i = 0;
+        value = value.toUpperCase();
+        while (i < value.length()) {
+            boolean matched = false;
+            for (String symbol : SYMBOLS.keySet()) {
+                if (value.startsWith(symbol, i)) {
+                    result += SYMBOLS.get(symbol);
+                    i += symbol.length();
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) throw new IllegalArgumentException("Invalid symbol: " + value);
+        }
+
+        return result;
+    }
+
+}

src/main/java/cl/bennu/commons/number/BabylonianNumeralSystem.java

@@ -0,0 +1,61 @@
+package cl.bennu.commons.number;
+
+import cl.bennu.commons.number.iface.SpecificNumberSystem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BabylonianNumeralSystem implements SpecificNumberSystem {
+
+    @Override
+    public String convert(Long number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(long number) {
+        if (number < 0) throw new IllegalArgumentException("Number must be greater than 0");
+
+        if (number == 0) return "0";
+
+        List<String> parts = new ArrayList<>();
+        while (number > 0) {
+            long digit = number % 60;
+            StringBuilder symbol = new StringBuilder();
+            symbol.append("^".repeat((int) (digit / 10)));
+            symbol.append("|".repeat((int) (digit % 10)));
+            parts.add(0, symbol.toString());
+            number /= 60;
+        }
+        return String.join(" ", parts);
+    }
+
+    @Override
+    public String convert(Integer number) {
+        if (number == null) throw new IllegalArgumentException("Number cannot be null");
+
+        return convert(number.longValue());
+    }
+
+    @Override
+    public String convert(int number) {
+        return convert((long) number);
+    }
+
+    @Override
+    public long convert(String value) {
+        if (value.equals("0")) return 0;
+
+        String[] parts = value.split(" ");
+        long result = 0;
+        for (String group : parts) {
+            long num = group.chars().filter(c -> c == '^').count() * 10L +
+                    group.chars().filter(c -> c == '|').count();
+            result = result * 60 + num;
+        }
+        return result;
+    }
+
+}