wip

Author: GreenWizard2015

src/Tests/Test_Estimator.java

@@ -0,0 +1,29 @@
+package Tests;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import YASL.CEstimator;
+import YASL.CExactCollector;
+import YASL.CExactCounter;
+import YASL.IEstimator;
+
+public class Test_Estimator {
+	@Test
+	public void simplest() {
+		IEstimator<Integer> est = new CEstimator<Integer>( //
+		    new CExactCounter<>(), //
+		    new CExactCollector<>() //
+		);
+		for (int i = 1; i <= 4; i++) {
+			for (int j = 0; j < i; j++) {
+				est.add(i);
+			}
+		}
+
+		Assert.assertEquals( //
+		    "4 -> 4.0, 3 -> 3.0, 2 -> 2.0, 1 -> 1.0", //
+		    est.estimate().toString() //
+		);
+	}
+}

src/YASL/CEstimatedItems.java

@@ -0,0 +1,23 @@
+package YASL;
+
+import java.util.Collection;
+
+public class CEstimatedItems<T> {
+	private final Collection<CEstimationFor<T>> _estimation;
+
+	public CEstimatedItems(Collection<CEstimationFor<T>> estimation) {
+		this._estimation = estimation;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder res = new StringBuilder();
+		String del = "";
+		for (CEstimationFor<T> item : _estimation) {
+			res.append(del);
+			res.append(item.toString());
+			del = ", ";
+		}
+		return res.toString();
+	}
+}

src/YASL/CEstimationFor.java

@@ -0,0 +1,27 @@
+package YASL;
+
+public class CEstimationFor<T> implements Comparable<CEstimationFor<T>> {
+	public final T			Item;
+	public final double	Frequence;
+
+	public CEstimationFor(T item, double frequence) {
+		Item = item;
+		Frequence = frequence;
+	}
+
+	@Override
+	public String toString() {
+		return Item.toString() + " -> " + Frequence;
+	}
+
+	@Override
+	public int compareTo(CEstimationFor<T> o) {
+		final double delta = o.Frequence - Frequence;
+		if (0 < delta)
+			return 1;
+		if (delta < 0)
+			return -1;
+		return 0;
+	}
+
+}

src/YASL/CEstimator.java

@@ -0,0 +1,25 @@
+package YASL;
+
+public class CEstimator<T> implements IEstimator<T> {
+	private final IItemsCounter<T> _counter;
+	private final IEstimationCollector<T> _collector;
+
+	public CEstimator( //
+	    IItemsCounter<T> counter, //
+	    IEstimationCollector<T> est //
+	) {
+		this._counter = counter;
+		this._collector = est;
+	}
+
+	@Override
+	public void add(T item, long count) {
+		final long cnt = _counter.put(item, count);
+		_collector.put(item, cnt);
+	}
+
+	@Override
+	public CEstimatedItems<T> estimate() {
+		return _collector.collect();
+	}
+}

src/YASL/CExactCollector.java

@@ -0,0 +1,25 @@
+package YASL;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class CExactCollector<T> implements IEstimationCollector<T> {
+
+	private Map<T, Long> _storage = new HashMap<>();
+
+	@Override
+	public void put(T item, long cnt) {
+		_storage.put(item, cnt);
+	}
+
+	@Override
+	public CEstimatedItems<T> collect() {
+		return new CEstimatedItems<>( //
+		    _storage.entrySet().stream() //
+		        .map(e -> new CEstimationFor<>(e.getKey(), e.getValue())) //
+		        .sorted() //
+		        .collect(Collectors.toList()) //
+		);
+	}
+}

src/YASL/CExactCounter.java

@@ -0,0 +1,22 @@
+package YASL;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+ * Just for testing.
+ * Don't use in real applications, unless you know what you are doing.
+ */
+
+public class CExactCounter<T> implements IItemsCounter<T> {
+
+	private final Map<T, Long> _counters = new HashMap<>();
+
+	@Override
+	public long put(T item, long count) {
+		Long cnt = _counters.get(item);
+		cnt = count + ((null == cnt) ? 0 : cnt);
+		_counters.put(item, cnt);
+		return cnt;
+	}
+}

src/YASL/IEstimationCollector.java

@@ -0,0 +1,6 @@
+package YASL;
+
+public interface IEstimationCollector<T> {
+	public void put(T item, long cnt);
+	public CEstimatedItems<T> collect();
+}

src/YASL/IEstimator.java

@@ -0,0 +1,10 @@
+package YASL;
+
+public interface IEstimator<T> {
+	public void add(T item, long count);
+	public CEstimatedItems<T> estimate();
+
+	public default void add(T item) {
+		add(item, 1);
+	}
+}

src/YASL/IItemsCounter.java

@@ -0,0 +1,5 @@
+package YASL;
+
+public interface IItemsCounter<T> {
+	public long put(T item, long count);
+}