@Override
public Rate getRate(Currency from, Currency to) throws Exception {
if ((from == null) || (to == null)) {
throw new IllegalArgumentException();
}
String path = (from.getCode() + "_" + to.getCode() + "/ticker").toLowerCase();
TickerResponse tickerResponse = get(BTCE_API_BASE_URL, path, TickerResponse.class, true);
Ticker ticker = tickerResponse.getTicker();
return new Rate(ticker.getBuy(), from, to);
}
/**
* Stops the stopwatch. Future reads will return the fixed duration that had elapsed up to this
* point.
*
* @return this {@code Stopwatch} instance
* @throws IllegalStateException if the stopwatch is already stopped.
*/
public Stopwatch stop() {
long tick = ticker.read();
checkState(isRunning, "This stopwatch is already stopped.");
isRunning = false;
elapsedNanos += tick - startTick;
return this;
}
@VisibleForTesting
QuantileDigest(double maxError, double alpha, Ticker ticker, boolean compressAutomatically) {
checkArgument(maxError >= 0 && maxError <= 1, "maxError must be in range [0, 1]");
checkArgument(alpha >= 0 && alpha < 1, "alpha must be in range [0, 1)");
this.maxError = maxError;
this.alpha = alpha;
this.ticker = ticker;
this.compressAutomatically = compressAutomatically;
landmarkInSeconds = TimeUnit.NANOSECONDS.toSeconds(ticker.read());
}
/*
* Get the exponentially-decayed approximate counts of values in multiple buckets. The elements in
* the provided list denote the upper bound each of the buckets and must be sorted in ascending
* order.
*
* The approximate count in each bucket is guaranteed to be within 2 * totalCount * maxError of
* the real count.
*/
public List<Bucket> getHistogram(List<Long> bucketUpperBounds) {
checkArgument(
Ordering.natural().isOrdered(bucketUpperBounds),
"buckets must be sorted in increasing order");
final ImmutableList.Builder<Bucket> builder = ImmutableList.builder();
final PeekingIterator<Long> iterator = Iterators.peekingIterator(bucketUpperBounds.iterator());
final AtomicDouble sum = new AtomicDouble();
final AtomicDouble lastSum = new AtomicDouble();
// for computing weighed average of values in bucket
final AtomicDouble bucketWeightedSum = new AtomicDouble();
final double normalizationFactor = weight(TimeUnit.NANOSECONDS.toSeconds(ticker.read()));
postOrderTraversal(
root,
new Callback() {
@Override
public boolean process(Node node) {
while (iterator.hasNext() && iterator.peek() <= node.getUpperBound()) {
double bucketCount = sum.get() - lastSum.get();
Bucket bucket =
new Bucket(
bucketCount / normalizationFactor, bucketWeightedSum.get() / bucketCount);
builder.add(bucket);
lastSum.set(sum.get());
bucketWeightedSum.set(0);
iterator.next();
}
bucketWeightedSum.addAndGet(node.getMiddle() * node.weightedCount);
sum.addAndGet(node.weightedCount);
return iterator.hasNext();
}
});
while (iterator.hasNext()) {
double bucketCount = sum.get() - lastSum.get();
Bucket bucket =
new Bucket(bucketCount / normalizationFactor, bucketWeightedSum.get() / bucketCount);
builder.add(bucket);
iterator.next();
}
return builder.build();
}
@Override
public void mouseClicked(MouseEvent mouseEvent) {
if (isActive) {
sqtList.onClicked(mouseEvent.getPoint());
repaint();
if (sqtList.tilesMoving()) {
isActive = false;
puzzleTicker.tick();
}
}
}
/** Adds a value to this digest. The value must be {@code >= 0} */
public void add(long value, long count) {
checkArgument(count > 0, "count must be > 0");
long nowInSeconds = TimeUnit.NANOSECONDS.toSeconds(ticker.read());
int maxExpectedNodeCount = 3 * calculateCompressionFactor();
if (nowInSeconds - landmarkInSeconds >= RESCALE_THRESHOLD_SECONDS) {
rescale(nowInSeconds);
compress(); // need to compress to get rid of nodes that may have decayed to ~ 0
} else if (nonZeroNodeCount > MAX_SIZE_FACTOR * maxExpectedNodeCount && compressAutomatically) {
// The size (number of non-zero nodes) of the digest is at most 3 * compression factor
// If we're over MAX_SIZE_FACTOR of the expected size, compress
// Note: we don't compress as soon as we go over expectedNodeCount to avoid unnecessarily
// running a compression for every new added element when we're close to boundary
compress();
}
double weight = weight(TimeUnit.NANOSECONDS.toSeconds(ticker.read())) * count;
max = Math.max(max, value);
min = Math.min(min, value);
insert(longToBits(value), weight);
}
@Override
public void update(long dt) {
sqtList.onUpdate(dt);
repaint();
if (!sqtList.tilesMoving()) {
isActive = true;
puzzleTicker.pause();
}
if (sqtList.puzzleCompleted()) {
stateMachine.state = State.COMPLETED;
stateMachine.executeState();
isActive = false;
}
}
private void rescaleToCommonLandmark(QuantileDigest one, QuantileDigest two) {
long nowInSeconds = TimeUnit.NANOSECONDS.toSeconds(ticker.read());
// 1. rescale this and other to common landmark
long targetLandmark = Math.max(one.landmarkInSeconds, two.landmarkInSeconds);
if (nowInSeconds - targetLandmark >= RESCALE_THRESHOLD_SECONDS) {
targetLandmark = nowInSeconds;
}
if (targetLandmark != one.landmarkInSeconds) {
one.rescale(targetLandmark);
}
if (targetLandmark != two.landmarkInSeconds) {
two.rescale(targetLandmark);
}
}
private void handleRemovedTicker(
Ticker ticker, ServiceDependency serviceDependency, Bundle bundle, boolean satisfied) {
boolean hasTicked = ticker.cancel();
if (hasTicked) {
if (satisfied) {
this.eventLogger.log(
KernelLogEvents.APPLICATION_CONTEXT_DEPENDENCY_SATISFIED,
serviceDependency.getBeanName(),
bundle.getSymbolicName(),
bundle.getVersion(),
serviceDependency.getFilter());
} else {
this.eventLogger.log(
KernelLogEvents.APPLICATION_CONTEXT_DEPENDENCY_TIMED_OUT,
serviceDependency.getBeanName(),
bundle.getSymbolicName(),
bundle.getVersion(),
serviceDependency.getFilter());
}
}
}
/**
* Create a QuantileDigest with a maximum error guarantee of "maxError" and exponential decay with
* factor "alpha".
*
* @param maxError the max error tolerance
* @param alpha the exponential decay factor
*/
public QuantileDigest(double maxError, double alpha) {
this(maxError, alpha, Ticker.systemTicker(), true);
}
/** Number (decayed) of elements added to this quantile digest */
public double getCount() {
return weightedCount / weight(TimeUnit.NANOSECONDS.toSeconds(ticker.read()));
}
private long elapsedNanos() {
return isRunning ? ticker.read() - startTick + elapsedNanos : elapsedNanos;
}
/**
* Starts the stopwatch.
*
* @return this {@code Stopwatch} instance
* @throws IllegalStateException if the stopwatch is already running.
*/
public Stopwatch start() {
checkState(!isRunning, "This stopwatch is already running.");
isRunning = true;
startTick = ticker.read();
return this;
}
Stopwatch() {
this.ticker = Ticker.systemTicker();
}
@Override
public void run(ArrayList<Double> debugData) {
Ticker lastTicker = exchange.getTicker();
OrderType intend;
try {
intend = genome.addTicker(lastTicker, debugData);
} catch (IOException e) {
return;
}
NormalOrder order = new NormalOrder();
Wallet wallet = exchange.getWallet();
// state machine needed for not immediate executed tickers
switch (state) {
case DOBUY:
switch (intend) {
case DO_NOTHING:
case BUY:
// TODO what if cancelling is not working?
if (exchange.getOrderResult((NormalOrder) pendingOrder) == Order.State.DONE
|| wallet.getBalance() == 0) {
state = OrderState.BOUGHT;
break;
}
pendingOrder =
(exchange.cancelOrder(pendingOrder) == true) ? new NoOrder() : pendingOrder;
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.BUY);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeBuyOrder(order);
state = OrderState.DOBUY;
break;
case SELL:
// TODO what if cancelling is not working?
pendingOrder =
(exchange.cancelOrder(pendingOrder) == true) ? new NoOrder() : pendingOrder;
if (exchange.getWallet().getBitCoins() != 0) {
order = new NormalOrder();
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.SELL);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeSellOrder(new NormalOrder());
state = OrderState.DOSELL;
} else {
state = OrderState.SOLD;
}
break;
}
break;
case BOUGHT:
switch (intend) {
case BUY:
state = OrderState.BOUGHT;
break;
case SELL:
if (exchange.getWallet().getBitCoins() != 0) {
order = new NormalOrder();
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.SELL);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeSellOrder(new NormalOrder());
state = OrderState.DOSELL;
} else {
state = OrderState.SOLD;
}
break;
case DO_NOTHING:
state = OrderState.BOUGHT;
break;
}
break;
case DOSELL:
switch (intend) {
case DO_NOTHING:
case BUY:
// TODO what if cancelling is not working?
pendingOrder =
(exchange.cancelOrder(pendingOrder) == true) ? new NoOrder() : pendingOrder;
if (exchange.getWallet().getBalance() != 0) {
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.BUY);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeBuyOrder(order);
state = OrderState.DOBUY;
} else {
state = OrderState.BOUGHT;
}
break;
case SELL:
if (exchange.getOrderResult((NormalOrder) pendingOrder) == Order.State.DONE
|| wallet.getBitCoins() == 0) {
state = OrderState.SOLD;
break;
}
// TODO what if cancelling is not working?
pendingOrder =
(exchange.cancelOrder(pendingOrder) == true) ? new NoOrder() : pendingOrder;
order = new NormalOrder();
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.SELL);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeSellOrder(new NormalOrder());
state = OrderState.DOSELL;
break;
}
case SOLD:
switch (intend) {
case SELL:
state = OrderState.SOLD;
break;
case BUY:
if (exchange.getWallet().getBalance() != 0) {
order = new NormalOrder();
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.BUY);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeBuyOrder(new NormalOrder());
state = OrderState.DOBUY;
} else {
state = OrderState.BOUGHT;
}
break;
case DO_NOTHING:
state = OrderState.BOUGHT;
break;
}
case INIT:
switch (intend) {
case DO_NOTHING:
state = OrderState.INIT;
break;
case BUY:
pendingOrder =
(exchange.cancelOrder(pendingOrder) == true) ? new NoOrder() : pendingOrder;
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.BUY);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeBuyOrder(order);
state = OrderState.DOBUY;
break;
case SELL:
if (exchange.getWallet().getBitCoins() != 0) {
order = new NormalOrder();
order.setPrice(lastTicker.getPrice());
order.setVolume(exchange.getWallet().getBalanceBitcoins(lastTicker.getPrice()));
order.setOrderType(OrderType.SELL);
order.setState(Order.State.OPEN);
pendingOrder = exchange.placeSellOrder(new NormalOrder());
state = OrderState.DOSELL;
} else {
state = OrderState.SOLD;
}
break;
}
break;
default:
break;
}
// logger.debug(exchange.getWallet().toString());
}
