remove: math.BCDecimal

remove: math.MathVectors

pom.xml

@@ -5,7 +5,7 @@
 
     <groupId>net.ranides</groupId>
     <artifactId>assira</artifactId>
-    <version>0.75.0</version>
+    <version>0.76.0</version>
     <packaging>jar</packaging>
 
     <name>assira</name>

src/main/java/net/ranides/assira/math/BCDecimal.java

@@ -1,243 +0,0 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-
-package net.ranides.assira.math;
-
-import java.math.BigDecimal;
-import java.util.Arrays;
-import net.ranides.assira.collection.ArrayUtils;
-import net.ranides.assira.text.Strings;
-
-/**
- *
- * @author ranides
- */
-public class BCDecimal extends Number implements Comparable<BCDecimal> {
-    
-    private static final String NOT_SUPPORTED = "Not supported yet.";
-
-    private final byte[] data;
-
-    public BCDecimal(int size) {
-        this.data = new byte[floor2(size)];
-    }
-
-    public BCDecimal(int size, long value) {
-        this.data = new byte[floor2(size)];
-        int index = 0;
-        while(value > 0) {
-            if(index >= size) {
-                throw new ArithmeticException("BCDecimal: value is too large.");
-            }
-            at(index++, (int)(value % 10));
-            value /= 10;
-        }
-    }
-
-    public BCDecimal(int size, char[] value) {
-        this(size, Strings.asSequence(value));
-    }
-
-    public BCDecimal(int size, CharSequence value) {
-        this.data = new byte[floor2(size)];
-        for(int n=value.length()-1, i=0; i<=n; i++) {
-            at(n-i, value.charAt(i)-'0');
-        }
-    }
-
-    public BCDecimal(BCDecimal value) {
-        this.data = ArrayUtils.arraycopy(value.data);
-    }
-
-    public static BCDecimal valueOf(Number value) {
-        assert value != null;
-
-        if(value instanceof BCDecimal) {
-            return new BCDecimal((BCDecimal)value);
-        }
-        if(value instanceof Long || value instanceof Integer || value instanceof Short || value instanceof Byte) {
-            return new BCDecimal( 32, value.longValue() );
-        }
-        throw new UnsupportedOperationException("Not supported type: " + value.getClass());
-    }
-
-    @Override
-    public int intValue() {
-        int ret = 0;
-        int di= 1;
-        for(int i=0; i<9; i++) {
-            ret +=  di * at(i);
-            di*=10;
-        }
-        return ret;
-    }
-
-    @Override
-    public long longValue() {
-        long ret = 0;
-        for(int i=0; i<20; i++) {
-            ret +=  i * at(i);
-        }
-        return ret;
-    }
-
-    @Override
-    public float floatValue() {
-        return longValue();
-    }
-
-    @Override
-    public double doubleValue() {
-        return longValue();
-    }
-
-    public BigDecimal bigValue() {
-        return new BigDecimal(toString());
-    }
-
-    @Override
-    public int compareTo(BCDecimal value) {
-        int n = Math.max(size(), value.size());
-        for(int i=n-1; i>=0; i--) {
-            int d = at(i)-value.at(i);
-            if(d != 0) {
-                return d;
-            }
-        }
-        return 0;
-    }
-
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(data);
-    }
-
-    @Override
-    public boolean equals(Object object) {
-        if( object == this) {
-            return true;
-        }
-        if( object instanceof BCDecimal ) {
-            return 0 == compareTo( (BCDecimal)object );
-        }
-        if( object instanceof Number) {
-            try {
-                return 0 == BCDecimal.valueOf((Number)object).compareTo(this);
-            } catch(UnsupportedOperationException cause) {
-                return false;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder( size() );
-        boolean nz = false;
-        for(int i=size()-1; i>=0; i--) {
-            char v = (char)('0' + at(i));
-            if(v != '0' || nz) {
-                builder.append(v);
-                nz = true;
-            }
-        }
-        if(!nz) {
-            return "0";
-        }
-        return builder.toString();
-    }
-
-    public final void at(int index, int value) {
-        int seg = data.length - index / 2 - 1;
-        if(0 == index % 2) {
-            data[seg] = (byte)((data[seg] & 0xF0) | (value & 0x0F));
-        } else {
-            data[seg] = (byte)((data[seg] & 0x0F) | (value << 4));
-        }
-    }
-
-    public final int at(int index) {
-        int seg = data.length - index / 2 - 1;
-        if( seg <0 ) {
-            return 0;
-        }
-        if(0 == index % 2) {
-            return data[seg] & 0x0F;
-        } else {
-            return (data[seg] >> 4) & 0x0F;
-        }
-    }
-
-    public final int size() {
-        return data.length * 2;
-    }
-
-    public BCDecimal add(BCDecimal value) {
-        return add(this, value);
-    }
-
-    public static BCDecimal add(BCDecimal number1, BCDecimal number2) {
-        if( number1.size() < number2.size() ) {
-            return add(number2, number1);
-        }
-        BCDecimal ret = new BCDecimal(number1.size());
-        int cv = 0;
-        for(int i=0, n=number2.size(); i<n; i++) {
-            int v = number1.at(i) + number2.at(i) + cv;
-            ret.at(i, v % 10);
-            cv = v / 10;
-        }
-        if(cv > 0) {
-            if( ret.size() == number2.size() ) {
-                throw new ArithmeticException("BCDecimal: value is too large.");
-            }
-            ret.at(number2.size(), cv);
-        }
-        return ret;
-    }
-
-    public BCDecimal sub(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal mul(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal div(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal mod(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal pow(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal abs() {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal neg() {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal min(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    public BCDecimal max(BCDecimal value) {
-        throw new UnsupportedOperationException(NOT_SUPPORTED);
-    }
-
-    private static int floor2(int value) {
-        return (value / 2) + (value % 2);
-    }
-
-}

src/main/java/net/ranides/assira/math/MathVectors.java

@@ -1,514 +0,0 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/twshelper
- */
-package net.ranides.assira.math;
-
-import java.util.Locale;
-
-/**
- * 
- * @author ranides
- */
-@SuppressWarnings({"PMD.ShortVar", "PMD.AvoidArrayLoops"})
-public final class MathVectors {
-    
-    private MathVectors() {
-        // utility class
-    }
-    
-    /**
-     * Wywołuje na rzecz każdego elementu metodę {@link Math#floor} i zakrągla do liczby 
-     * całkowitej. 
-     * @param a
-     * @return
-     */
-    public static int[] floor(double[] a) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = (int)Math.floor(a[i]); }
-        return result;
-    }
-    
-    /**
-     * Wywołuje na rzecz każdego elementu metodę {@link Math#ceil} i zakrągla do liczby 
-     * całkowitej. 
-     * @param a
-     * @return
-     */
-    public static int[] ceil(double[] a) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = (int)Math.ceil(a[i]); }
-        return result;
-    }
-    
-    /**
-     * Konwertuje podaną tablicę liczb całkowitych na tablicę liczb rzeczywistych.
-     * @param a
-     * @return
-     */
-    public static double[] real(int[] a) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i]; }
-        return result;
-    }
-    
-/* ************************************************************************** */
-    
-    /**
-     * Dodaje odpowiednie elementy z tablicy {@code a} do elementów z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie sumy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] add(double[] a, double[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] + b[i]; }
-        return result;
-    }
-    
-    /**
-     * Dodaje do wszystkich elementów z tablicy {@code a} liczbę {@code b}. 
-     * Jako wynik zwraca tablicę zawierającą odpowiednie sumy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] add(double[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] + b; }
-        return result;
-    }
-    
-    /**
-     * Dodaje odpowiednie elementy z tablicy {@code a} do elementów z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie sumy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] add(int[] a, int[] b) {
-        assert a.length == b.length;
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] + b[i]; }
-        return result;
-    }
-    
-    /**
-     * Dodaje do wszystkich elementów z tablicy {@code a} liczbę {@code b}. 
-     * Jako wynik zwraca tablicę zawierającą odpowiednie sumy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] add(int[] a, int b) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] + b; }
-        return result;
-    }
-    
-    /**
-     * Odejmuje od odpowiednich elementów z tablicy {@code a} elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie różnice.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] sub(double[] a, double[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] - b[i]; }
-        return result;
-    }
-    
-    /**
-     * Odejmuje od wszystkich elementów z tablicy {@code a} liczbę {@code b}. 
-     * Jako wynik zwraca tablicę zawierającą odpowiednie różnice.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] sub(double[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] - b; }
-        return result;
-    }
-    
-    /**
-     * Odejmuje od odpowiednich elementów z tablicy {@code a} elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie różnice.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] sub(int[] a, int[] b) {
-        assert a.length == b.length;
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] - b[i]; }
-        return result;
-    }
-    
-    /**
-     * Odejmuje od wszystkich elementów z tablicy {@code a} liczbę {@code b}. 
-     * Jako wynik zwraca tablicę zawierającą odpowiednie różnice.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] sub(int[] a, int b) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] - b; }
-        return result;
-    }
-    
-    /**
-     * Dzieli odpowiednie elementy z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie ilorazy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] div(double[] a, double[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] / b[i]; }
-        return result;
-    }
-    
-    /**
-     * Dzieli wszystkie elementy z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie ilorazy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] div(double[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] / b; }
-        return result;
-    }
-    
-    /**
-     * Dzieli odpowiednie elementy z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie ilorazy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] div(int[] a, int[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = (double)a[i] / (double)b[i]; }
-        return result;
-    }
-    
-    /**
-     * Dzieli wszystkie elementy z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie ilorazy.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] div(int[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] / b; }
-        return result;
-    }
-    
-    /**
-     * Mnoży odpowiednie elementy z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie iloczyny.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] mul(double[] a, double[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] * b[i]; }
-        return result;
-    }
-    
-    /**
-     * Mnoży wszystkie elementy z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie iloczyny.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] mul(double[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] / b; }
-        return result;
-    }
-    
-    /**
-     * Mnoży odpowiednie elementy z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie iloczyny.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] mul(int[] a, int[] b) {
-        assert a.length == b.length;
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] * b[i]; }
-        return result;
-    }
-    
-    /**
-     * Mnoży wszystkie elementy z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie iloczyny.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] mul(int[] a, int b) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] / b; }
-        return result;
-    }
-
-    
-    /**
-     * Oblicza resztę z dzielenia odpowiednich elementów z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie reszty.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] mod(double[] a, double[] b) {
-        assert a.length == b.length;
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] % b[i]; }
-        return result;
-    }
-    
-    /**
-     * Oblicza resztę z dzielenia wszystkich elementów z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie reszty.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static double[] mod(double[] a, double b) {
-        double[] result = new double[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] % b; }
-        return result;
-    }
-    
-    /**
-     * Oblicza resztę z dzielenia odpowiednich elementów z tablicy {@code a} przez elementy z tablicy
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie reszty.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] mod(int[] a, int[] b) {
-        assert a.length == b.length;
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] % b[i]; }
-        return result;
-    }
-    
-    /**
-     * Oblicza resztę z dzielenia wszystkich elementów z tablicy {@code a} przez liczbę
-     * {@code b}. Jako wynik zwraca tablicę zawierającą odpowiednie reszty.
-     * @param a
-     * @param b
-     * @return
-     */
-    public static int[] mod(int[] a, int b) {
-        int[] result = new int[a.length];
-        for(int i=0; i<a.length; i++) { result[i] = a[i] % b; }
-        return result;
-    }
-
-/* ************************************************************************** */
-    
-    /**
-     * Dodaje wszystkie elementy podanej tablicy. Jako wynik zwraca obliczoną sumę.
-     * @param a
-     * @return
-     */
-    public static double sum(double[] a) {
-        double result = 0;
-        for(int i=0; i<a.length; i++) { result += a[i]; }
-        return result;
-    }
-    
-    /**
-     * Dodaje wszystkie elementy podanej tablicy. Jako wynik zwraca obliczoną sumę.
-     * @param a
-     * @return
-     */
-    public static int sum(int[] a) {
-        int result = 0;
-        for(int i=0; i<a.length; i++) { result += a[i]; }
-        return result;
-    }
-    
-    /**
-     * Traktuje tablicę o rozmiarze N jako wektor N-wymiarowy, i wylicza jego
-     * długość przy użyciu klasycznego wzoru dla geometrii euklidesowej.
-     * @param a
-     * @return
-     */
-    public static double width(double[] a) {
-        return Math.sqrt( sum( mul(a,a) ) );
-    }
-    
-    /**
-     * Traktuje tablicę o rozmiarze N jako wektor N-wymiarowy, i wylicza jego
-     * długość przy użyciu klasycznego wzoru dla geometrii euklidesowej.
-     * @param a
-     * @return
-     */
-    public static double width(int[] a) {
-        return Math.sqrt( sum( mul(a,a) ) );
-    }
-
-    /**
-     * Traktuje tablice liczb jako wektory i wylicza podobieństwo między nimi. 
-     * Składowe wyniku zawierają dwie wartości. {@code ratio} określa stosunek 
-     * proporcjonalności długościami wektorów. {@code value} należy do 
-     * zakresu {@code [0;1]} i określa podobieństwo pomiędzy kierunkiem 
-     * reprezentowanym przez wektory. Metoda użyteczna przy sprawdzaniu
-     * szeroko rozumianej korelacji między dwoma ciągami liczb.
-     * <p>
-     * {@code value = 0 } (przeciwne) jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = -b<sub>i</sub></code>
-     * <br/>
-     * {@code value = 1 } (identyczne) jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = ratio &sdot; b<sub>i</sub></code>
-     * <br/>
-     * {@code value = NaN } jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = 0</code> lub <code>b<sub>i</sub> = 0</code>
-     * <br/>
-     * {@code value = NaN } oraz {@code ratio = NaN } jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = 0</code> oraz <code>b<sub>i</sub> = 0</code>
-     * <br/>
-     * </p>
-     * @param a
-     * @param b
-     * @return 
-     */
-    public static VMRel rel(double[] a, double[] b) {
-        double wa = width(a);
-        double wb = width(b);
-        double[] na = div(a, wa);
-        double[] nb = div(b, wb);
-        double value = (2.0 - width(sub(na, nb))) / 2;
-        double ratio = wa / wb;
-        return new VMRel(value, ratio);
-    }
-    
-    /**
-     * Traktuje tablice liczb jako wektory i wylicza podobieństwo między nimi. 
-     * Składowe wyniku zawierają dwie wartości. {@code ratio} określa stosunek 
-     * proporcjonalności długościami wektorów. {@code value} należy do 
-     * zakresu {@code [0;1]} i określa podobieństwo pomiędzy kierunkiem 
-     * reprezentowanym przez wektory. Metoda użyteczna przy sprawdzaniu
-     * szeroko rozumianej korelacji między dwoma ciągami liczb.
-     * <p>
-     * {@code value = 0 } (przeciwne) jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = -b<sub>i</sub></code>
-     * <br/>
-     * {@code value = 1 } (identyczne) jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = ratio &sdot; b<sub>i</sub></code>
-     * <br/>
-     * {@code value = NaN } jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = 0</code> lub <code>b<sub>i</sub> = 0</code>
-     * <br/>
-     * {@code value = NaN } oraz {@code ratio = NaN } jeśli wszystkie elementy spełniają warunek:
-     * <code>a<sub>i</sub> = 0</code> oraz <code>b<sub>i</sub> = 0</code>
-     * <br/>
-     * </p>
-     * @param a
-     * @param b
-     * @return 
-     */
-    public static VMRel rel(int[] a, int[] b) {
-        double wa = width(a);
-        double wb = width(b);
-        double[] na = div(a, wa);
-        double[] nb = div(b, wb);
-        double value = (2.0 - width(sub(na, nb))) / 2;
-        double ratio = wa / wb;
-        return new VMRel(value, ratio);
-    }
-
-/* ************************************************************************** */
-    
-    /**
-     * Wynik działania funkcji {@link MathVectors#rel}
-     */
-    public static final class VMRel implements Comparable<VMRel> {
-        private final double value;
-        private final double ratio;
-
-        /**
-         * Tworzy nowy obiekt przechowujący parę liczb określających wynik.
-         * @param value
-         * @param ratio 
-         */
-        public VMRel(double value, double ratio) {
-            this.value = value;
-            this.ratio = ratio;
-        }
-
-        /**
-         * Szeroko rozumiany "współczynnik proporcjonalności" między porównywanymi
-         * wartościami. Liczba rzeczywista z zakresu <code>[0; +&infin;)</code> lub
-         * {@code NaN}
-         * @see MathVectors#rel
-         * @return 
-         */
-        public double ratio() {
-            return ratio;
-        }
-
-        /**
-         * Szeroko rozumiany "współczynnik korelacji" między porównywanymi
-         * wartościami. Liczba rzeczywista z zakresu <code>[0; 1]</code> lub
-         * {@code NaN}
-         * @see MathVectors#rel
-         * @return 
-         */
-        public double value() {
-            return value;
-        }
-
-        @Override
-        public int compareTo(VMRel object) {
-            int dv = (int)Math.round(100 * (value - object.value));
-            if( dv != 0) {
-                return dv;
-            } else {
-                return (int)Math.round(100 * (ratio - object.ratio));
-            }
-        }
-
-        @Override
-        public int hashCode() {
-            return HashHelper.hashValues(7, 37, value, ratio);
-        }
-
-        @Override
-        public boolean equals(Object value) {
-            return (value instanceof VMRel) && compareTo((VMRel)value) == 0;
-        }
-
-        @Override
-        public String toString() {
-            return String.format(Locale.ROOT, "%.2fr%.2f", value, ratio);
-        }
-        
-        
-    };
-    
-}
-

src/test/java/net/ranides/assira/math/BCDecimalTest.java

@@ -1,55 +0,0 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.math;
-
-import net.ranides.assira.text.Strings;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-/**
- *
- * @author ranides
- */
-public class BCDecimalTest {
-
-    public BCDecimalTest() {
-    }
-
-    @Test
-    public void testConstruct() {
-        assertEquals("0", new BCDecimal(20, 0).toString());
-        assertEquals("7", new BCDecimal(20, 7).toString());
-        assertEquals("135874", new BCDecimal(20, 135874).toString());
-        assertEquals("13587", new BCDecimal(6, 13587).toString());
-        assertEquals("12345", new BCDecimal(5, 12345).toString());
-
-        try {
-            assertEquals("12345", new BCDecimal(4, 12345).toString());
-            fail("ArithmeticException expected");
-        } catch (ArithmeticException cause) {
-            assertTrue(Strings.contains(cause.getMessage(), "BCDecimal"));
-        }
-
-        assertTrue(true);
-    }
-
-    @Test
-    public void testValue() {
-        assertEquals(1997, new BCDecimal(16, 1997).intValue() );
-    }
-
-    @Test
-    public void testAdd() {
-        assertEquals(858, BCDecimal.valueOf(132).add(BCDecimal.valueOf(726)).intValue() );
-        assertEquals(158, BCDecimal.valueOf(132).add(BCDecimal.valueOf(26)).intValue() );
-        assertEquals(142, BCDecimal.valueOf(134).add(BCDecimal.valueOf(8)).intValue() );
-        assertEquals(202, BCDecimal.valueOf(134).add(BCDecimal.valueOf(68)).intValue() );
-        assertEquals(1102, BCDecimal.valueOf(134).add(BCDecimal.valueOf(968)).intValue() );
-
-    }
-
-}

src/test/java/net/ranides/assira/math/MathVectorsTest.java

@@ -1,87 +0,0 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.math;
-
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-/**
- *
- * @author ranides
- */
-public class MathVectorsTest {
-    
-    public MathVectorsTest() {
-    }
-
-    @Test
-    public void testRel() {
-        
-        assertEquals(
-            "0.00r1.00",    
-            MathVectors.rel(new int[]{-2,-2},  new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals(
-            "0.08r0.71",
-            MathVectors.rel(new int[]{-2,+0}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals(
-            "0.08r0.35", 
-            MathVectors.rel(new int[]{-1,+0}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "NaNr0.00",
-            MathVectors.rel(new int[]{+0,+0}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "NaNrNaN",
-            MathVectors.rel(new int[]{+0,+0}, new int[]{+0,+0}).toString()
-        );
-        
-        assertEquals( 
-            "0.62r0.35",
-            MathVectors.rel(new int[]{+1,+0}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "0.62r0.71",
-            MathVectors.rel(new int[]{+2,+0}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "0.84r0.79",
-            MathVectors.rel(new int[]{+2,+1}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "0.84r1.58",
-            MathVectors.rel(new int[]{+4,+2}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "1.00r1.00",
-            MathVectors.rel(new int[]{+2,+2}, new int[]{+2,+2}).toString()
-        );
-        
-        assertEquals( 
-            "1.00r2.00",
-            MathVectors.rel(new int[]{+4,+4}, new int[]{+2,+2}).toString()
-        );
-        
-         assertEquals( 
-            "0.47r0.04",
-            MathVectors.rel(new int[]{+4,+2}, new int[]{+0,+100}).toString()
-        );
-        
-        
-        assertTrue(true);
-    }
-}