Voomra/trader
Archived
0
Fork 0
Code Activity

PathRoute implement

Browse Source
This commit is contained in:
iMoHax
2014-08-17 14:01:33 +04:00
parent 5fcf43b0a0
commit 7d15c8461b
5 changed files with 338 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
core/src/main/java/ru/trader/core/Order.java
View File

@@ -40,10 +40,6 @@ public class Order implements Comparable<Order> {
return profit;
}
public Order getCopy(long count){
return new Order(sell, buy, count);
}
public long getCount() {
return count;
}
@@ -56,6 +52,10 @@ public class Order implements Comparable<Order> {
return buy.getVendor().equals(buyer);
}
public Vendor getBuyer(){
return buy.getVendor();
}
@Override
public int compareTo(@NotNull Order order) {
Objects.requireNonNull(order, "Not compare with null");
@@ -100,4 +100,7 @@ public class Order implements Comparable<Order> {
return sb.toString();
}
public void setMax(double balance, long limit) {
setCount((long) Math.min(balance/sell.getPrice(), limit));
}
}

12
core/src/main/java/ru/trader/graph/Graph.java
View File

@@ -113,7 +113,7 @@ public class Graph<T extends Connectable<T>> {
if (edge != null ){
if (!(withRefill && Math.min(limit, maxDistance) < edge.getLength() && !source.getEntry().canRefill())){
found = true;
Path<T> path = head.connectTo(edge, limit < edge.getLength());
Path<T> path = head.connectTo(edge.getTarget(), limit < edge.getLength());
path.finish();
LOG.trace("Last edge find, add path {}", path);
paths.add(path);
@@ -124,10 +124,10 @@ public class Graph<T extends Connectable<T>> {
LOG.trace("Search around");
for (Edge<T> next : source.getEdges()) {
if (withRefill && Math.min(limit, maxDistance) < next.getLength() && !source.getEntry().canRefill()) continue;
if (head.contains(next)) continue;
if (head.isConnect(next.getTarget())) continue;
// target already added if source consist edge
if (next.isConnect(target)) continue;
Path<T> path = head.connectTo(next, limit < next.getLength());
Path<T> path = head.connectTo(next.getTarget(), limit < next.getLength());
double nextLimit = withRefill ? limit - next.getLength(): stock;
// refill
if (nextLimit < 0 ) nextLimit = maxDistance - next.getLength();
@@ -151,9 +151,9 @@ public class Graph<T extends Connectable<T>> {
if (deep == source.getLevel()){
for (Edge<T> next : source.getEdges()) {
if (withRefill && Math.min(limit, maxDistance) < next.getLength() && !source.getEntry().canRefill()) continue;
if (head.contains(next)) continue;
if (head.isConnect(next.getTarget())) continue;
if (next.isConnect(target)) {
Path<T> path = head.connectTo(next, limit < next.getLength());
Path<T> path = head.connectTo(next.getTarget(), limit < next.getLength());
path.finish();
LOG.trace("Last edge find, path {}", path);
return path;
@@ -165,7 +165,7 @@ public class Graph<T extends Connectable<T>> {
for (Edge<T> next : source.getEdges()) {
if (next.getTarget().getLevel() >= source.getLevel()) continue;
if (withRefill && Math.min(limit, maxDistance) < next.getLength() && !source.getEntry().canRefill()) continue;
Path<T> path = head.connectTo(next, limit < next.getLength());
Path<T> path = head.connectTo(next.getTarget(), limit < next.getLength());
double nextLimit = withRefill ? limit - next.getLength(): stock;
// refill
if (nextLimit < 0 ) nextLimit = stock - next.getLength();

24
core/src/main/java/ru/trader/graph/Path.java
View File

@@ -18,8 +18,8 @@ public class Path<T extends Connectable<T>> {
this.refill = refill;
}
public Path<T> connectTo(Edge<T> edge, boolean refill){
return new Path<>(this, edge.getTarget(), refill);
public Path<T> connectTo(Vertex<T> vertex, boolean refill){
return new Path<>(this, vertex, refill);
}
public void finish(){
@@ -37,6 +37,11 @@ public class Path<T extends Connectable<T>> {
return head == null;
}
public Path<T> getRoot(){
if (isRoot()) return this;
return head.getRoot();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
@@ -63,18 +68,21 @@ public class Path<T extends Connectable<T>> {
return sb.toString();
}
public boolean contains(Edge<T> edge) {
return target.equals(edge.getTarget()) || (!isRoot() && head.contains(edge));
public boolean isConnect(Vertex<T> vertex) {
return target.equals(vertex) || (!isRoot() && head.isConnect(vertex));
}
public boolean isPathFrom(T entry) {
return !isRoot() && head.target.getEntry().equals(entry);
}
@SafeVarargs
public static <T extends Connectable<T>> Path<T> toPath(T... items){
T s = items[0];
Path<T> path = new Path<>(new Vertex<>(s));
T t = items[0];
Path<T> path = new Path<>(new Vertex<>(t));
for (int i = 1; i < items.length; i++) {
T t = items[i];
t = items[i];
path = new Path<>(path, new Vertex<>(t), false);
s = t;
}
return path;
}

114
core/src/main/java/ru/trader/graph/PathRoute.java
View File

@@ -4,25 +4,28 @@ import ru.trader.core.Offer;
import ru.trader.core.Order;
import ru.trader.core.Vendor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.*;
public class PathRoute extends Path<Vendor> {
private final ArrayList<Order> orders = new ArrayList<>();
private double profit = 0;
private int transitIndex = 0;
private PathRoute tail;
public PathRoute(Vertex<Vendor> source) {
super(source);
}
protected PathRoute(Path<Vendor> head, Vertex<Vendor> vertex, boolean refill) {
private PathRoute(PathRoute head, Vertex<Vendor> vertex, boolean refill) {
super(head, vertex, refill);
assert head.tail == null;
head.tail = this;
}
@Override
public Path<Vendor> connectTo(Edge<Vendor> edge, boolean refill) {
return new PathRoute(this.getCopy(), edge.getTarget(), refill);
public Path<Vendor> connectTo(Vertex<Vendor> vertex, boolean refill) {
return new PathRoute(this.getCopy(), vertex, refill);
}
@Override
@@ -51,8 +54,8 @@ public class PathRoute extends Path<Vendor> {
}
}
public Collection<Order> getOrders() {
return orders;
public List<Order> getOrders() {
return Collections.unmodifiableList(orders);
}
@Override
@@ -61,7 +64,7 @@ public class PathRoute extends Path<Vendor> {
for (Order order : orders) {
if (sb.length() > 0) sb.append(", ");
sb.append(order.getBuy().getItem());
sb.append(" (").append(order.getBuy().getVendor()).append(") ");
sb.append(" (").append(order.getBuyer()).append(") ");
}
String o = sb.toString();
sb = new StringBuilder();
@@ -77,20 +80,85 @@ public class PathRoute extends Path<Vendor> {
return sb.toString();
}
public Path<Vendor> getCopy(){
Path<Vendor> res;
LinkedList<Path<Vendor>> v = new LinkedList<>();
Path<Vendor> p = this;
while (!p.isRoot()){
v.add(p);
p = p.getHead();
}
res = p;
Iterator<Path<Vendor>> it = v.descendingIterator();
while (it.hasNext()){
p = it.next();
res = new PathRoute(res, p.getTarget(), p.isRefill());
public boolean isEmpty(){
return orders.isEmpty();
}
public PathRoute getCopy(){
PathRoute path = (PathRoute) getRoot();
PathRoute res = new PathRoute(path.getTarget());
while (path.tail != null){
res = new PathRoute(res, path.tail.getTarget(), path.tail.isRefill());
path = path.tail;
}
return res;
}
public double getProfit(){
return profit;
}
public double getProfit(Order order){
if (isPathFrom(order.getBuyer())) return order.getProfit() + profit;
return tail != null ? tail.getProfit(order) : order.getProfit();
}
@Override
protected PathRoute getHead() {
return (PathRoute) super.getHead();
}
public void resort(double balance, long limit){
if (isRoot()) return;
for (Order order : orders) {
order.setMax(balance, limit);
}
orders.sort(this::compareOrders);
updateProfit();
updateTransitIndex();
getHead().resort(balance, limit);
}
private void updateTransitIndex() {
transitIndex = orders.size();
if (isEmpty()) return;
double transitProfit = tail != null ? tail.getProfit() : 0;
ListIterator<Order> itr = orders.listIterator(orders.size());
while (itr.hasPrevious()){
Order o = itr.previous();
if (getProfit(o) > transitProfit){
return;
}
transitIndex--;
}
}
private void updateProfit() {
if (isEmpty()){
profit = tail != null ? tail.getProfit() : 0;
} else {
Order best = orders.get(0);
profit = getProfit(best);
}
}
private int compareOrders(Order o1, Order o2){
if (tail == null || o1.isBuyer(o2.getBuyer())){
//reverse
return o2.compareTo(o1);
}
double profit1 = getProfit(o1);
double profit2 = getProfit(o2);
return Double.compare(profit2, profit1);
}
public PathRoute getTail() {
return tail;
}
public int getTransitIndex() {
return transitIndex;
}
}