Trading Strategy tester in java
SourceForge.net: Trading Strategy Runner: Files
Data file structure:
27/10/2008,00:00:01,2,1.2624,1.2623,1.2623,1.2624
27/10/2008,00:00:11,0,1.2623,1.2623,1.2623,1.2623
27/10/2008,00:00:21,2,1.2624,1.2623,1.2623,1.2624
27/10/2008,00:00:31,1,1.2623,1.2624,1.2623,1.2624
27/10/2008,00:00:41,0,1.2624,1.2624,1.2624,1.2624

Attached Images

	screenshot.jpg (49.1 KB, 1432 views)
	testter1.jpg (28.3 KB, 1421 views)

Suppose I created two classes of vectors, one for SELL, one for the BUY.

to properly classify the current vector ( to which class he belongs) need to determinate sigma. If him 0.0001 is the vector may be classified as a BUY, as if to let him 0.01 - then classified as the vector begins SELL.

For me, until the mystery of how to determine the optimum value for sigma.

public enum SignalDirection {

BUY, SELL, NEUTRAL, CLOSE
}
///////////////////////////////////////////////////////////////////
public enum SignalType {

OPEN, CLOSE, INDICATION
}
///////////////////////////////////////////////////////////////////
public class Util {

static DecimalFormat decFormat = new DecimalFormat("0.0000");
static SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

public static synchronized String formatDate(Date date) {
return date == null ? "" : dateFormat.format(date);
}

public static synchronized Date parseDate(String date) throws ParseException {
return date == null ? null : dateFormat.parse(date);
}

public static synchronized String formatPrice(double totalProfit) {
return decFormat.format(totalProfit);
}

public static final double calcProfit(TradePosition pos, Tick currentTick) {
if (pos.getDirection() == SignalDirection.BUY) {
// long the security
return currentTick.getSellPrice() - pos.getTick().getBuyPrice();
} else {
// short the security
return pos.getTick().getSellPrice() - currentTick.getBuyPrice();
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
public class TradePosition implements Serializable, Comparable<TradePosition> {

private final Tick tick;
private final SignalDirection direction;
private final SignalType type;

/**
* The default constructor
* @param direction
* @param type
* @param tick
*/
public TradePosition(SignalDirection direction, SignalType type, Tick tick) {
if (direction != SignalDirection.BUY && direction != SignalDirection.SELL) {
throw new RuntimeException("Cannot create trade position with direction: " + direction);
}

this.direction = direction;
this.type = type;
this.tick = tick;
}

@Override
public String toString() {
DecimalFormat df = new DecimalFormat("0.0000");
StringBuilder sb = new StringBuilder(30).append(direction).append(",").
append(df.format(direction == SignalDirection.BUY ? -1d * tick.getBuyPrice() : tick.getSellPrice())).
append(",").
append(Util.formatDate(tick.getTimestamp())).appen d(", ").append(type);
return sb.toString();
}

/**
* Reference to the tick when this position is opened/closed
* @return
*/
public Tick getTick() {
return tick;
}

/**
* Get the direction of this position
* @return
*/
public SignalDirection getDirection() {
return direction;
}

/**
* Get the signal type of this position
* @return
*/
public SignalType getSignalType() {
return type;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof TradePosition) {
TradePosition b = (TradePosition) obj;
return this.direction == b.direction && this.type == b.type && this.tick.equals(b.tick);
}
return false;
}

public int compareTo(TradePosition o) {
int i = this.tick.compareTo(o.getTick());
return (i == 0) ? this.direction.toString().compareTo(o.direction.to String()) : i;
}

@Override
public int hashCode() {
return tick.hashCode();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Tick implements Comparable<Tick>, Serializable {

/**
* The bid/offer spread, e.g. in EUR/USD, this is generally 2 pips, that is 0.0002.
* Set this value before running a strategy.
*/
public static double BID_OFFER_SPREAD = 0d; //0.0002d;
protected Date date;
protected long volume;
protected double open;
protected double close;
protected double low;
protected double high;

protected Tick() {
}

public Tick(Date date, long volume, double open, double close, double low, double high) {
this.date = date;
this.volume = volume;
this.open = open;
this.close = close;
this.low = low;
this.high = high;
}

public Date getTimestamp() {
return date;
}

public long getVolume() {
return volume;
}

public double getOpenPrice() {
return open;
}

public double getClosePrice() {
return close;
}

public double getLow() {
return low;
}

public double getHigh() {
return high;
}

/**
* Is a function of closing price + (SPREAD / 2);
* @return
*/
public double getBuyPrice() {
return close + (BID_OFFER_SPREAD / 2d);
}

/**
* Is a function of closing price - (SPREAD / 2);
* @return
*/
public double getSellPrice() {
return close - (BID_OFFER_SPREAD / 2d);
}

/**
* Compare the current tick's timestamp with the other's
*/
public int compareTo(Tick o) {
long thisVal = this.date.getTime();
long anotherVal = o.date.getTime();
return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(Util.formatDate(date)).append(" P: ").append(getSellPrice()).append("/").append(getBuyPrice()).
append(" H: ").append(high).
append(" L: ").append(low).
append(" O: ").append(open);

return sb.toString();
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Tick) {
Tick o = (Tick) obj;
return this.close == o.close && this.getTimestamp() == o.getTimestamp() && this.high == o.high && this.low == o.low && this.open == o.open;
}
return false;
}

@Override
public int hashCode() {
return date.hashCode();
}
}

// PROFIT for long position
PROFITL= currentTick.getSellPrice() - pos.getTick().getBuyPrice()
// PROFIT for short position
PROFITS=pos.getTick().getSellPrice() - currentTick.getBuyPrice()

//////////////////////////////////////////////////////
public double getBuyPrice() {
return close + (BID_OFFER_SPREAD / 2d);
}
////////////////////////////////////////////////////////
public double getSellPrice() {
return close - (BID_OFFER_SPREAD / 2d);
}

need 5000 Bars min on chart, i used EURUSD 5 min

green - BUY PDF function
red - SELL PDF function

on first screenshot probality down > probality up
on two screenshot chart with 3 MA

PS: PlotGraph.mq4 extreme CPU overload, take care

Attached Images

	PlotGraph.jpg (276.0 KB, 1370 views)
	chart.JPG (301.4 KB, 1364 views)

Attached Files

PlotGraph.mq4 (7.8 KB, 120 views)

I understand the algorithm is as follows:

array with samples PNN[][], suppose it is kept 50 vectors. temporarily removed from his first vector and calculate pdf-function. That's the question what it means: "If the sample is correctly classified"? What criteria ?

then remove the second (the first returned) and again calculate pdf, and so on.

Trading Strategy tester in java
Classes

Attached Images

tester1.jpg (116.1 KB, 1259 views)

Hi barnix and all the others, i've some experience with NN and i will try to join your trip in forecasting, i will use neurosolutions so i hope i ll have some help in linking dll with mt4 eh eh

i guess you use smoothed time series for NN right?

Good evening, new here in the thread, but not in the subject I have read for a while the postings. Many thanks for the great work and suggestions here.
@sae2k :
A small hint is allowed to me: I hold for critical to work with standard deviation for the prediction of financial time series, assuming a normally distribution. No one else as John Bollinger pointed to the kurtosis in the stock markets, a similar acceptance can be probably met to other time series. A classification with plants cannot be transferred anyway directly to the financial markets.
I would choose a simple unit vector between 0 and 1 for an initial standardization, however, I can't assess the efficiency for the chosen PNN.

Regard

Simple Trading System in python
Source Checkout - wtx - Google Code


class Strategy:
def __init__(self, deposit=400000, price_per_point=200, commission=500):
self.bars = None
self.current_index = -1
self.points_balance = 0
self.entry_price = 0
self.current_contracts = 0
self.price_per_point = price_per_point
self.commission = commission
self.initial_deposit = deposit
self.balance = deposit
self.win = 0
self.lose = 0

def Buy(self, price):
self.ExitShort(price)
self.entry_price = price
self.current_contracts = 1
#print "Buy @%d"%(price)

def Sell(self, price):
self.ExitLong(price)
self.entry_price = price
self.current_contracts = -1
#print "Sell @%d"%(price)

def ExitLong(self, price):
if self.current_contracts > 0:
points_balance = (price - self.entry_price)*self.current_contracts
if points_balance>=0:
self.win += 1
else:
self.lose += 1
print "ExitLong: %d points (%d -> %d)"%(points_balance, self.entry_price, price)
self.points_balance += points_balance
self.balance += points_balance * self.price_per_point - self.commission
self.current_contracts = 0

def ExitShort(self, price):
if self.current_contracts < 0:
points_balance = (price - self.entry_price)*self.current_contracts
if points_balance<=0:
self.win += 1
else:
self.lose += 1
print "ExitShort: %d points (%d -> %d)"%(points_balance, self.entry_price, price)
self.points_balance += points_balance
self.balance += points_balance * self.price_per_point - self.commission
self.current_contracts = 0

def ShowResults(self):
self.ExitLong(self.Close(0))
self.ExitShort(self.Close(0))
transaction = self.lose+self.win
print "--------------- Performance Report ------------------"
print "%d Transaction, Win=%d (%.1f%%), Lose=%d(%.1f%%)"%(\
transaction, self.win, self.win*100/transaction, self.lose, self.lose*100/transaction)
print "Initial deposit=%d"%(self.initial_deposit)
print "points_balance is %d points, equals to %d (NTD)"%\
(self.points_balance, self.points_balance*self.price_per_point)
print "commission is %d"%(self.balance-self.initial_deposit-self.points_balance*self.price_per_point)
print "Final balance is %d"%(self.balance)
print "Actual earning is %d"%(self.balance-self.initial_deposit)
print "--------------- Performance Report ------------------"

def CrossOver(self, a, b):
#prev a < prev b and current a > current b
print "[%s] Close=%d, Fast[-1](%d)<Slow[-1](%d) and Fast(%d)>=Slow(%d) ? %d"%(self.bars[self.current_index].time, \
self.bars[self.current_index].close, a(1),b(1),a(0),b(0), a(1)<b(1) and a(0)>=b(0))
return a(1)<b(1) and a(0)>=b(0)

def Close(self, offset=0):
if self.current_index < offset:
return 0
else:
return self.bars[self.current_index - offset].close

def Open(self, offset=0):
if self.current_index < offset:
return 0
else:
return self.bars[self.current_index - offset].open

def High(self, offset=0):
if self.current_index < offset:
return 0
else:
return self.bars[self.current_index - offset].high

def Low(self, offset=0):
if self.current_index < offset:
return 0
else:
return self.bars[self.current_index - offset].low

def Sum(self, f, count, offset=0):
sum = 0
if self.current_index < offset:
return sum
elif self.current_index < offset + count:
count = self.current_index-offset
for e in map(f, range(offset, count+offset)):
#print "sum(%d) += %d"%(sum, e)
sum += e
#print "[%d] Sum(count=%d, offset=%d)=%d"%(self.current_index, count, offset, sum)
return sum

def Average(self, f, count, offset=0):
avg = 0
if self.current_index < offset:
return 0
elif self.current_index < offset + count:
count = self.current_index-offset

if count == 0:
return 0

avg = self.Sum(f, count, offset)/count
#print "[%d] Average(count=%d, offset=%d)=%d"%(self.current_index, count, offset, avg)
return avg

def Run(self, Open, High, Low, Close):
pass

def RunWithBars(self, bars):
self.bars = bars
self.count = len(bars)
for i in range(0, self.count):
self.current_index = i
#print "[%d][%s] %d %d %d %d"%(i, self.bars[i].time, self.bars[i].open, \
#self.bars[i].high, self.bars[i].low, self.bars[i].close)
self.Run(lambda x: self.Open(x), \
lambda x: self.High(x), \
lambda x: self.Low(x), \
lambda x: self.Close(x))

self.ShowResults()

Attached Files

wtx.rar (18.4 KB, 57 views)