package fayelab.ddd.measure.vector.original;

public class VecOpTest extends TestCase
{
    public void test_equal()
    {
        assertTrue(equal(asList(1, 2, 3), asList(1, 2, 3)));
        assertTrue(equal(asList(), asList()));
        assertFalse(equal(asList(1, 2), asList(1, 2, 3)));
        assertFalse(equal(asList(1, 3, 4), asList(1, 2, 3)));
    }
}

package fayelab.ddd.measure.vector.original;

public class VecOp
{
    public static boolean equal(List<Integer> vec1, List<Integer> vec2)
    {
        return vec1.equals(vec2);
    }
}

    public void test_add()
    {
        assertEquals(asList(5, 7, 9), add(asList(1, 2, 3), asList(4, 5, 6)));
        assertEquals(asList(), add(asList(), asList()));
    }

    public static List<Integer> add(List<Integer> vec1, List<Integer> vec2)
    {
        return IntStream.range(0, vec1.size())
                        .mapToObj(i -> vec1.get(i) + vec2.get(i))
                        .collect(Collectors.toList());
    }

    public void test_dotProduct()
    {
        assertEquals(102, dotProduct(asList(1, 0, 2), asList(100, 10, 1)));
        assertEquals(0, dotProduct(asList(), asList()));
    }

    public static int dotProduct(List<Integer> rowVec, List<Integer> colVec)
    {
        return IntStream.range(0, rowVec.size())
                        .mapToObj(i -> rowVec.get(i) * colVec.get(i))
                        .reduce(0, (x, y) -> x + y);
    }

    public void test_div()
    {
        assertEquals(asList(0, 0, 2, 0), div(asList(0, 0, 0, 24), asList(Integer.MAX_VALUE, 1760, 3, 12)));
        assertEquals(asList(2, 6, 0, 4), div(asList(1, 1765, 0, 40), asList(Integer.MAX_VALUE, 1760, 3, 12)));
    }

    public static List<Integer> div(List<Integer> dividendVec, List<Integer> divisorVec)
    {
        List<Integer> rDividendVec = reverse(dividendVec);
        List<Integer> rDivisorVec = reverse(divisorVec);
        int[] quotient = new int[]{0};
        
        List<Integer> rResultVec = IntStream.range(0, rDividendVec.size())
                                            .collect(() -> new ArrayList<>(),
                                                     (acc, i) -> {
                                                         int dividend = rDividendVec.get(i) + quotient[0];
                                                         int divisor = rDivisorVec.get(i);
                                                         quotient[0] = dividend / divisor;
                                                         acc.add(dividend % divisor);
                                                     },
                                                     (acc1, acc2) -> acc1.addAll(acc2));
        return reverse(rResultVec);
    }

    private static List<Integer> reverse(List<Integer> vec)
    {
        List<Integer> rVec = new ArrayList<>(vec);
        Collections.reverse(rVec);
        return rVec;
    }

    public void test_dotDiv()
    {
        assertEquals(asList(1, 0, 2), dotDiv(102, asList(100, 10, 1)));
    }

    public static List<Integer> dotDiv(int baseValue, List<Integer> vec)
    {
        int[] remainder = new int[]{baseValue};

        return vec.stream()
                  .collect(() -> new ArrayList<>(),
                           (acc, c) -> {
                               int quotient = remainder[0] / c;
                               remainder[0] = remainder[0] % c;
                               acc.add(quotient);
                           },
                           (acc1, acc2) -> acc1.addAll(acc2));
    }

package fayelab.ddd.measure.vector.original;

public class MeasureSystemTest extends TestCase
{
    public void test_toBaseFactors()
    {
        assertEquals(asList(1760 * 3 * 12, 3 * 12, 12, 1), 
                     MeasureSystem.toBaseFactors(asList(Integer.MAX_VALUE, 1760, 3, 12)));
    }
}

package fayelab.ddd.measure.vector.original;

public class MeasureSystem
{
    private List<Integer> stepFactors;
    private List<Integer> baseFactors;

    public MeasureSystem(List<Integer> stepFactors)
    {
        this.stepFactors = stepFactors;
        this.baseFactors = toBaseFactors(stepFactors);
    }

    static List<Integer> toBaseFactors(List<Integer> stepFactors)
    {
        int size = stepFactors.size();
        return IntStream.range(0, size)
                        .mapToObj(i -> stepFactors.subList(i + 1, size)
                                                  .stream()
                                                  .reduce(1, (acc, factor) -> acc * factor))
                        .collect(Collectors.toList());
    }
}

    private MeasureSystem ms;

    @Override
    protected void setUp()
    {
        ms = new MeasureSystem(asList(Integer.MAX_VALUE, 1760, 3, 12));
    }

    public void test_base()
    {
        assertEquals(63472, ms.base(asList(1, 2, 3, 4)));
        assertEquals(63396, ms.base(asList(1, 0, 3, 0)));
    }

    public int base(List<Integer> quantityVec)
    {
        return VecOp.dotProduct(quantityVec, baseFactors);
    }

    public void test_normalize()
    {
        assertEquals(asList(1, 4, 0, 1), ms.normalize(asList(0, 1762, 5, 13)));
    }

    public List<Integer> normalize(List<Integer> quantityVec)
    {
        return VecOp.div(quantityVec, stepFactors);
    }

    public void test_equal()
    {
        assertTrue(ms.equal(asList(1, 2, 3, 4), asList(0, 0, 0, 63472)));
        assertTrue(ms.equal(asList(0, 1765, 0, 40), asList(1, 6, 0, 4)));
        assertFalse(ms.equal(asList(0, 1765, 0, 41), asList(1, 6, 0, 4)));
    }

    public boolean equal(List<Integer> quantityVec1, List<Integer> quantityVec2)
    {
        return VecOp.equal(normalize(quantityVec1), normalize(quantityVec2));
    }

    public void test_add()
    {
        assertEquals(asList(0, 0, 2, 0), ms.add(asList(0, 0, 0, 13), asList(0, 0, 0, 11)));
        assertEquals(asList(0, 3, 0, 0), ms.add(asList(0, 0, 3, 0), asList(0, 2, 0, 0)));
    }

    public List<Integer> add(List<Integer> quantityVec1, List<Integer> quantityVec2)
    {
        return normalize(VecOp.add(quantityVec1, quantityVec2));
    }

package fayelab.ddd.measure.vector.original;

public class MeasureSystemUITest extends TestCase
{
    public void test_parseUnitConversionDesc()
    {
        List<List<?>> actual = MeasureSystemUI.parseUnitConversionDesc(" Mile  1760 Yard 3 Feet 12 Inch  ");
        assertEquals(2, actual.size());
        assertEquals(asList(Integer.MAX_VALUE, 1760, 3, 12), actual.get(0));
        assertEquals(asList("Mile", "Yard", "Feet", "Inch"), actual.get(1));

        actual = MeasureSystemUI.parseUnitConversionDesc2(" Mile  1760 Yard 3 Feet 12 Inch  ");
        assertEquals(2, actual.size());
        assertEquals(asList(Integer.MAX_VALUE, 1760, 3, 12), actual.get(0));
        assertEquals(asList("Mile", "Yard", "Feet", "Inch"), actual.get(1));
    }
}

package fayelab.ddd.measure.vector.original;

public class MeasureSystemUI
{
    @SuppressWarnings("unused")
    private String sysName;

    private MeasureSystem ms;
    private List<String> sysUnits;

    @SuppressWarnings("unchecked")
    public MeasureSystemUI(String sysName, String unitConversionDesc)
    {
        this.sysName = sysName;
        List<List<?>> unitConversion = parseUnitConversionDesc(unitConversionDesc);
        this.ms = new MeasureSystem((List<Integer>)unitConversion.get(0));
        this.sysUnits = (List<String>)unitConversion.get(1);
    }

    static List<List<?>> parseUnitConversionDesc(String desc)
    {
        List<String> tokens = asList(desc.trim().split(" +"));

        Map<Boolean, List<String>> partitioned = tokens.stream()
                                                       .collect(Collectors.partitioningBy(token -> isEvenIndex(token, tokens)));

        List<Integer> stepFactors = partitioned.get(Boolean.FALSE).stream().map(Integer::parseInt).collect(Collectors.toList());
        stepFactors.add(0, Integer.MAX_VALUE);
        List<String> units = partitioned.get(Boolean.TRUE);

        return asList(stepFactors, units);
    }

    @SuppressWarnings("unchecked")
    static List<List<?>> parseUnitConversionDesc2(String desc)
    {
        List<String> tokens = asList(desc.trim().split(" +"));

        return tokens.stream()
                     .collect(() -> asList(new ArrayList<Integer>(asList(Integer.MAX_VALUE)), new ArrayList<String>()),
                              (acc, token) -> {
                                  if(isEvenIndex(token, tokens))
                                  {
                                      ((List<String>)acc.get(1)).add(token);
                                  }
                                  else
                                  {
                                      ((List<Integer>)acc.get(0)).add(Integer.parseInt(token));
                                  }
                              },
                              (acc1, acc2) -> {
                                  ((List<Integer>)acc1.get(0)).addAll((List<Integer>)acc2.get(0));
                                  ((List<String>)acc1.get(1)).addAll((List<String>)acc2.get(1));
                              });
    }

    private static boolean isEvenIndex(String token, List<String> tokens)
    {
        return tokens.indexOf(token) % 2 == 0;
    }
}

    private MeasureSystemUI ui;

    @Override
    protected void setUp()
    {
        ui = new MeasureSystemUI("Imperial Length", "Mile 1760 Yard 3 Feet 12 Inch");
    }

    public void test_parseQuantityDesc()
    {
        assertEquals(asList(1, 2, 3, 4), ui.parseQuantityDesc(" 1 Mile  2 Yard 3 Feet 4 Inch  "));
        assertEquals(asList(1, 2, 0, 4), ui.parseQuantityDesc("1 Mile 4 Inch 2 Yard"));
        assertEquals(asList(1, 2, 0, 4), ui.parseQuantityDesc("1 Mile 2 Yard 4 Inch"));
        assertEquals(asList(0, 0, 3, 0), ui.parseQuantityDesc("3 Feet"));
    }

    List<Integer> parseQuantityDesc(String desc)
    {
        List<String> tokens = asList(desc.trim().split(" +"));

        Map<Boolean, List<String>> partitioned = tokens.stream()
                                                       .collect(Collectors.partitioningBy(token -> isEvenIndex(token, tokens)));

        List<Integer> values = partitioned.get(Boolean.TRUE).stream().map(Integer::parseInt).collect(Collectors.toList());
        List<String> units = partitioned.get(Boolean.FALSE);
        
        return sysUnits.stream()
                       .map(sysUnit -> units.contains(sysUnit) ? values.get(units.indexOf(sysUnit)) : 0)
                       .collect(Collectors.toList());
    }

    static List<List<?>> parseUnitConversionDesc(String desc)
    {
        Map<Boolean, List<String>> partitioned = partitioningByIndexParity(tokenize(desc));

        List<Integer> stepFactors = toIntegers(partitioned.get(Boolean.FALSE));
        stepFactors.add(0, Integer.MAX_VALUE);
        List<String> units = partitioned.get(Boolean.TRUE);

        return asList(stepFactors, units);
    }

    List<Integer> parseQuantityDesc(String desc)
    {
        Map<Boolean, List<String>> partitioned = partitioningByIndexParity(tokenize(desc));

        List<Integer> values = toIntegers(partitioned.get(Boolean.TRUE));
        List<String> units = partitioned.get(Boolean.FALSE);

        return sysUnits.stream()
                       .map(sysUnit -> units.contains(sysUnit) ? values.get(units.indexOf(sysUnit)) : 0)
                       .collect(Collectors.toList());
    }

    private static List<String> tokenize(String desc)
    {
        return asList(desc.trim().split(" +"));
    }

    private static Map<Boolean, List<String>> partitioningByIndexParity(List<String> tokens)
    {
        return tokens.stream().collect(Collectors.partitioningBy(token -> isEvenIndex(token, tokens)));
    }

    private static List<Integer> toIntegers(List<String> strs)
    {
        return strs.stream().map(Integer::parseInt).collect(Collectors.toList());
    }

    public void test_equal()
    {
        assertTrue(ui.equal("1 Mile 2 Yard 3 Feet 4 Inch", "63472 Inch"));
        assertTrue(ui.equal("1765 Yard 40 Inch", "1 Mile 6 Yard 4 Inch"));
        assertFalse(ui.equal("1765 Yard 41 Inch", "1 Mile 6 Yard 4 Inch"));
    }

    public boolean equal(String quantityDesc1, String quantityDesc2)
    {
        return ms.equal(parseQuantityDesc(quantityDesc1), parseQuantityDesc(quantityDesc2));
    }

    public void test_format()
    {
        assertEquals("1 Mile 3 Yard 4 Inch", ui.format(asList(1, 3, 0, 4)));
        assertEquals("2 Feet 0 Inch", ui.format(asList(0, 0, 2, 0)));
    }

    public String format(List<Integer> quantityVec)
    {
        return IntStream.range(0, quantityVec.size())
                        .filter(i -> quantityVec.get(i) != 0 || i == quantityVec.size() - 1)
                        .mapToObj(i -> String.format("%d %s", quantityVec.get(i), sysUnits.get(i)))
                        .reduce((acc, valueAndUnit) -> String.join(" ", acc, valueAndUnit))
                        .orElse("");
    }

    public void test_add()
    {
        assertEquals("2 Feet 0 Inch", ui.add("13 Inch", "11 Inch"));
        assertEquals("3 Yard 0 Inch", ui.add("3 Feet", "2 Yard"));
    }

    public String add(String quantityDesc1, String quantityDesc2)
    {
        return format(ms.add(parseQuantityDesc(quantityDesc1), parseQuantityDesc(quantityDesc2)));
    }

    public void test_baseFormat()
    {
        assertEquals("63472 Inch", ui.baseFormat(asList(1, 3, 0, 4)));
    }

    public String baseFormat(List<Integer> quantityVec)
    {
        return String.format("%d %s", ms.base(quantityVec), sysUnits.get(sysUnits.size() - 1));
    }

package fayelab.ddd.measure.vector.original;

public class AllTests
{
    public static Test suite()
    {
        TestSuite suite = new TestSuite(AllTests.class.getName());
        //$JUnit-BEGIN$
        suite.addTestSuite(MeasureSystemTest.class);
        suite.addTestSuite(MeasureSystemUITest.class);
        suite.addTestSuite(VecOpTest.class);
        //$JUnit-END$
        return suite;
    }
}

    public static void main(String[] args)
    {
        MeasureSystemUI impLen = new MeasureSystemUI("Imperial Length", "Mile 1760 Yard 3 Feet 12 Inch");
        System.out.println("1765 Yard 40 Inch == 1 Mile 6 Yard 4 Inch ? " + impLen.equal("1765 Yard 40 Inch", "1 Mile 6 Yard 4 Inch"));
        System.out.println("13 Inch + 11 Inch = " + impLen.add("13 Inch", "11 Inch"));

        MeasureSystemUI impVol = new MeasureSystemUI("Imperial Volume", "OZ 2 TBSP 3 TSP");
        System.out.println("1 OZ 10 TSP == 2 OZ 1 TBSP 1 TSP ? " + impVol.equal("1 OZ 10 TSP", "2 OZ 1 TBSP 1 TSP"));
        System.out.println("1 OZ + 3 TBSP 3 TSP = " + impVol.add("1 OZ", "3 TBSP 3 TSP"));
    }

    public static void main(String[] args)
    {
        ...

        MeasureSystemUI time = new MeasureSystemUI("Time", "Day 24 Hour 60 Minute 60 Second");
        System.out.println("7 Hour 59 Minute 60 Second == 8 Hour ? " + time.equal("7 Hour 59 Minute 60 Second", "8 Hour"));
        System.out.println("1 Day 23 Hour 59 Minute 59 Second + 1 Second = " + time.add("1 Day 23 Hour 59 Minute 59 Second", "1 Second"));
    }

    public static void main(String[] args)
    {
        ...

        MeasureSystemUI impLen2 = new MeasureSystemUI("Imperial Length 2", "Mile 4 Miya 440 Yard 3 Feet 12 Inch");
        System.out.println("4 Miya 446 Yard 40 Inch == 1 Mile 1 Miya 7 Yard 4 Inch ? " + impLen2.equal("4 Miya 446 Yard 40 Inch", "1 Mile 1 Miya 7 Yard 4 Inch"));
        System.out.println("3 Miya 13 Inch + 445 Yard 11 Inch = " + impLen2.add("3 Miya 13 Inch", "445 Yard 11 Inch"));
    }

    public void test_scale()
    {
        assertEquals(asList(2, 4, 6), scale(2, asList(1, 2, 3)));
        assertEquals(asList(0, 0), scale(0, asList(1, 2)));
        assertEquals(asList(), scale(2, asList()));
    }

    public static List<Integer> scale(int c, List<Integer> vec)
    {
        return vec.stream().map(x -> c * x).collect(Collectors.toList());
    }

    public void test_scale()
    {
        assertEquals(asList(0, 6, 0, 0), ms.scale(2, asList(0, 2, 3, 0)));
        assertEquals(asList(0, 6, 1, 2), ms.scale(2, asList(0, 2, 3, 7)));
    }

    public List<Integer> scale(int c, List<Integer> quantityVec)
    {
        return normalize(VecOp.scale(c, quantityVec));
    }

    public void test_scale()
    {
        assertEquals("6 Yard 0 Inch", ui.scale("2", "2 Yard 3 Feet"));
        assertEquals("6 Yard 1 Feet 2 Inch", ui.scale("2", "2 Yard 3 Feet 7 Inch"));
    }

    public String scale(String c, String quantityDesc)
    {
        return format(ms.scale(Integer.parseInt(c), parseQuantityDesc(quantityDesc)));
    }


    public static void main(String[] args)
    {
        ...

        System.out.println("2 * 2 Yard 3 Feet = " + impLen.scale("2", "2 Yard 3 Feet"));
        System.out.println("2 * 2 Yard 3 Feet + 13 Inch = " + impLen.add(impLen.scale("2", "2 Yard 3 Feet"), "13 Inch"));

        System.out.println("3 * 1 OZ 10 TSP = " + impVol.scale("3", "1 OZ 10 TSP"));
        System.out.println("3 * 1 OZ 10 TSP + 3 TBSP 1 TSP = " + impVol.add(impVol.scale("3", "1 OZ 10 TSP"), "3 TBSP 1 TSP"));
    }

    public boolean equal(List<Integer> quantityVec1, List<Integer> quantityVec2)
    {
        return base(quantityVec1) == base(quantityVec2);
    }

    public void test_normalize()
    {
        assertEquals(asList(1, 4, 0, 1), ms.normalize(63505));
    }

    public List<Integer> normalize(int quantityValue)
    {
        return VecOp.dotDiv(quantityValue, baseFactors);
    }

    public List<Integer> add(List<Integer> quantityVec1, List<Integer> quantityVec2)
    {
        return normalize(base(quantityVec1) + base(quantityVec2));
    }

    public List<Integer> scale(int c, List<Integer> quantityVec)
    {
        return normalize(c * base(quantityVec));
    }

    private List<Integer> baseFactors;

    public MeasureSystem(List<Integer> stepFactors)
    {
        this.baseFactors = toBaseFactors(stepFactors);
    }