Financial data analysis and prototyping.
Various tools available to explore, transform and chart the data (charting written in pure server-side JS, easy to extend)
hedge.market.open('AAPL');
hedge.market.from(new Date(2013,0,01));
hedge.market.to(new Date(2013,11,31));
hedge.market.timeframe('daily');
hedge.market.fetch(function(data) {
var chart = {
data: {
top: 5,
left: 5,
width: 790,
height: 195,
type: 'line',
rect: true,
series: {}
},
noiseless: {
top: 200,
left: 5,
width: 790,
height: 195,
type: 'line',
rect: true,
series: {}
},
};
chart.data.series['original'] = _.map(data, function(item) {
return item.c;
});
chart.noiseless.series['noiseless'] = _.map(hedge.transform.noiseless(data, {
period: 45,
type: 'ma'
}), function(item) {
return item._c;
});
chart.noiseless.series['noise'] = _.map(hedge.transform.noise(data, {
period: 45,
type: 'ma'
}), function(item) {
return item._c;
});
chart.noiseless.series['avg'] = _.map(hedge.transform.noiseless(data, {
level: 30
}), function(item) {
return item._c;
});
hedge.chart.render({
filename: 'data/AAPL-noiseless-avg.png',
width: 800,
height: 400,
charts: [chart.data, chart.noiseless]
});
});
hedge.market.open('AAPL');
hedge.market.from(new Date(2013,0,01));
hedge.market.to(new Date(2013,11,31));
hedge.market.timeframe('daily');
hedge.market.fetch(function(data) {
var chart = {
top: 0,
left: 0,
width: 800,
height: 200,
type: 'line',
series: {}
};
chart.series['original'] = _.map(data, function(item) {
return item.c;
});
chart.series['ma'] = _.map(hedge.transform.noiseless(data, {
type: 'ma',
period: 5
}), function(item) {
return item._c;
});
hedge.debug("chart", chart);
hedge.chart.render({
filename: 'data/AAPL-noiseless-ma.png',
width: 800,
height: 200,
charts: [chart]
});
});
hedge.market.open('CURRENCY:EUR-USD');
hedge.market.from(new Date(2013,0,1));
hedge.market.to(new Date(2015,11,31));
hedge.market.timeframe('daily');
hedge.market.fetch(function(data) {
var chartObj = {
filename: 'data/detrend-tp-eurusd2.png',
width: 1920,
height: 800
};
//hedge.debug("raw-data", data);
//return false;
var chart = {
original: {
top: 5,
left: 5,
width: chartObj.width-10,
height: (chartObj.height/4)-10,
type: 'line',
rect: true,
series: {
original: _.map(data, function(item) {
return item.c;
})
}
},
noiseless: {
top: (chartObj.height/4)*1+5,
left: 5,
width: chartObj.width-10,
height: (chartObj.height/4)-10,
rect: true,
type: 'line',
series: {}
},
noise: {
top: (chartObj.height/4)*2+5,
left: 5,
width: chartObj.width-10,
height: (chartObj.height/4)-10,
rect: true,
type: 'line',
series: {}
},
noiseAvg: {
top: (chartObj.height/4)*2+5,
left: 5,
width: chartObj.width-10,
height: (chartObj.height/4)-10,
rect: false,
type: 'line',
series: {}
},
noiseStd: {
top: (chartObj.height/4)*3+5,
left: 5,
width: chartObj.width-10,
height: (chartObj.height/4)-10,
rect: true,
type: 'line',
series: {}
}
};
var noiseBuffer = {};
_.each(_.range(80,100,1), function(level) {
// Remove the noise
chart.noiseless.series[level] = _.map(hedge.transform.noiseless(data, {
level: level,
period: level,
type: 'ma',
}), function(item) {
return item._c;
});
/// Remove the trend
noiseBuffer[level] = hedge.transform.noise(data, {
level: level,
period: level,
type: 'ma',
})
chart.noise.series[level] = _.map(noiseBuffer[level], function(item) {
return item._c;
});
});
chart.noiseAvg.series['ma'] = _.map(hedge.transform.noiseless(noiseBuffer[100], {
type: 'ma',
period: 30
}), function(item) {
return item._c;
});
// Calculate the vertical stdev of the series
chart.noiseStd.series['stdev'] = hedge.transform.hstdev(chart.noise.series);//@TODO: hstdev()
//hedge.debug("chart", chart);
//hedge.debug("hstdev", hedge.transform.hstdev(chart.noise.series));
chartObj.charts = [chart.original,chart.noiseless,chart.noise,chart.noiseAvg,chart.noiseStd];
hedge.chart.render(chartObj, function(filename) {
scope.hedge.airbase.image('noiseless', filename);
});
});
hedge.market.open('AAPL');
hedge.market.from(new Date(2013,0,01));
hedge.market.to(new Date(2013,11,31));
hedge.market.timeframe('daily');
hedge.market.fetch(function(data) {
var chart = {
top: 0,
left: 0,
width: 800,
height: 200,
type: 'line',
series: {}
};
chart.series['original'] = _.map(data, function(item) {
return item.c;
});
_.each(_.range(1,100,5), function(level) {
chart.series[level] = _.map(hedge.transform.noiseless(data, {
level: level
}), function(item) {
return item._c;
});
});
hedge.debug("chart", chart);
hedge.chart.render({
width: 800,
height: 200,
charts: [chart]
});
});
var data = {};
var symbols = ['CURRENCY:EUR-USD','CURRENCY:EUR-NZD'];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2013,0,01));
hedge.market.to(new Date(2015,11,31));
hedge.market.timeframe('daily');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
});
});
});
stack.start(function() {
/*var correlation = hedge.correlation.correlate(data, {
prop: 'c'
});
console.log("Correlation delay:",_.min(correlation, function(item) {
return Math.abs(item.r);
}));
hedge.debug("correlation", correlation);
*/
var chart = {
data: {
top: 5,
left: 5,
width: 790,
height: 195,
type: 'line',
rect: true,
series: {}
},
noiseless: {
top: 200,
left: 5,
width: 790,
height: 195,
type: 'line',
rect: true,
series: {}
},
symbols: []
};
_.each(symbols, function(symbol, n) {
chart.data.series[symbol] = _.map(data[symbol], function(item) {
return item.c;
});
chart.noiseless.series[symbol] = _.map(hedge.transform.noise(data[symbol], {
type: 'ma',
period: '10'
}), function(item) {
return item._c;
});
var bufferSeries = {};
_.each(_.range(1,15,1), function(period) {
bufferSeries[symbol+'-'+period] = _.map(hedge.transform.delta(data[symbol], {
type: 'ma',
period: period
}), function(item) {
return item._c;
});
});
// Save the chart
chart.symbols.push({
top: 400+(200*n),
left: 5,
width: 790,
height: 195,
type: 'line',
rect: true,
series: bufferSeries,
range: {
type: 'sync'
}
});
});
var chartList = [chart.data, chart.noiseless];
_.each(chart.symbols, function(item, n) {
//hedge.debug("item-"+n, item);
chartList.push(item);
});
//hedge.debug("chartList", chartList);
hedge.chart.render({
filename: 'data/delta-ma.png',
width: 800,
height: 800,
charts: chartList
});
});
var hedgejs = require('./hedgejs');
var chartLib = require('./chart');
var pstack = require('pstack');
var _ = require('underscore');
var hedge = new hedgejs({});
var data = {};
//var symbols = ['CURRENCY:CAD-JPY','CURRENCY:EUR-USD','CURRENCY:EUR-NZD','CURRENCY:EUR-CAD'];
var symbols = ['CURRENCY:EUR-CHF'];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2015,2,01));
hedge.market.to(new Date());
hedge.market.timeframe('daily');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
});
});
});
stack.start(function() {
var charts = [];
var chartSize = [1200,800];
_.each(symbols, function(symbol, n) {
// Create the delta spectrum chart
var bufferSeries = {};
_.each(_.range(3,60,1), function(period) {
bufferSeries[symbol+'-'+period] = _.map(hedge.transform.delta(data[symbol], {
type: 'ma',
period: period
}), function(item) {
return item._c;
});
});
charts.push({
top: (chartSize[1]*n)+5,
left: 5,
width: chartSize[0]-10,
height: chartSize[1]*0.70-10,
type: 'line',
rect: true,
series: bufferSeries,
range: {
type: 'sync' // All charts must share the same min/max range
}
});
// Add the raw data as overlay
charts.push({
top: (chartSize[1]*n)+5,
left: 5,
width: chartSize[0]-10,
height: chartSize[1]*0.70-10,
rect: true,
type: 'line',
color: {r:216,g:17,b:89,a:255},
series: {
raw: _.map(data[symbol], function(item) {
return item.c;
})
}
});
// Add the hstdev
charts.push({
top: (chartSize[1]*n)+chartSize[1]*0.70+5,
left: 5,
width: chartSize[0]-10,
height: chartSize[1]*0.15-10,
rect: true,
type: 'line',
color: {r:216,g:17,b:89,a:255},
origin: true,
series: {
hstdev: hedge.transform.hstdev(bufferSeries, {})
}
});
// Add the hmean
charts.push({
top: (chartSize[1]*n)+chartSize[1]*0.85+5,
left: 5,
width: chartSize[0]-10,
height: chartSize[1]*0.15-10,
rect: true,
type: 'line',
color: {r:255,g:188,b:66,a:255},
origin: true,
series: {
hstdev: hedge.transform.hmean(bufferSeries, {})
}
});
});
hedge.chart.render({
filename: 'data/delta-ma-vs-4.png',
width: chartSize[0],
height: chartSize[1]*symbols.length,
charts: charts,
slice: 60
});
});
var hedgejs = require('./hedgejs');
var chartLib = require('./chart');
var pstack = require('pstack');
var _ = require('underscore');
var hedge = new hedgejs({});
var data = {};
//var symbols = ['CURRENCY:CAD-JPY','CURRENCY:EUR-USD','CURRENCY:EUR-NZD','CURRENCY:EUR-CAD'];
var symbols = ['CURRENCY:CAD-JPY','CURRENCY:EUR-USD','CURRENCY:EUR-NZD','CURRENCY:EUR-CAD', 'CURRENCY:EUR-CHF'/**/];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2015,2,01));
hedge.market.to(new Date(2016,2,01));
hedge.market.timeframe('daily');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
return true;
});
return true;
});
return true;
});
stack.start(function() {
var charts = [];
var chartSize = [1200,400];
var panels = {
standardized: {
width: 1200,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
delta: {
width: 1200,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
sdelta: {
width: 1200,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
madelta: {
width: 1200,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
}
};
_.each(symbols, function(symbol, n) {
var dataset = hedge.transform.standardize(data[symbol], {
prop: 'c',
propOut: 'std'
});
dataset = hedge.transform.delta(dataset, {
prop: 'std',
propOut: 'delta'
});
dataset = hedge.transform.delta(dataset, {
type: 'lag',
period: 5,
prop: 'std',
propOut: 'sdelta'
});
dataset = hedge.transform.delta(dataset, {
type: 'ma',
period: 5,
prop: 'std',
propOut: 'madelta'
});
panels.standardized.series[symbol] = _.map(dataset, function(item) {
return item.std;
});
panels.delta.series[symbol] = _.map(dataset, function(item) {
return item.delta;
});
panels.sdelta.series[symbol] = _.map(dataset, function(item) {
return item.sdelta;
});
panels.madelta.series[symbol] = _.map(dataset, function(item) {
return item.madelta;
});
});
var chart = _.extend({
filename: 'data/standardized-all.png',
width: chartSize[0],
height: chartSize[1],
charts: []
}, hedge.chart.vpanels([panels.standardized, panels.delta, panels.sdelta, panels.madelta]));
//hedge.debug("chart", chart);
hedge.chart.render(chart);
});
var hedgejs = require('./hedgejs');
var chartLib = require('./chart');
var pstack = require('pstack');
var _ = require('underscore');
var hedge = new hedgejs({});
var data = {};
var symbols = ['CURRENCY:EUR-USD','CURRENCY:EUR-CAD','CURRENCY:EUR-NZD','CURRENCY:EUR-AUD'];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2015,1,01));
hedge.market.to(new Date(2015,3,01));
hedge.market.timeframe('hours');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
return true;
});
return true;
});
return true;
});
stack.start(function() {
var charts = [];
var chartSize = [1200,400];
var panels = {
raw: {
width: 1920,
height: 400,
rect: true,
type: 'line',
origin: true,
series: {}
},
standardized1: {
width: 1920,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
standardized2: {
width: 1920,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
delta: {
width: 1920,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
madelta: {
width: 1920,
height: 400,
rect: true,
type: 'line',
range: {
type: 'sync'
},
origin: true,
series: {}
},
std1_stats: {
width: 1920,
height: 150,
rect: true,
type: 'line',
//color: {r:216,g:17,b:89,a:255},
range: {
type: 'sync'
},
origin: true,
series: {}
},
std2_stats: {
width: 1920,
height: 150,
rect: true,
type: 'line',
//color: {r:216,g:17,b:89,a:255},
range: {
type: 'sync'
},
origin: true,
series: {}
},
delta_stats: {
width: 1920,
height: 150,
rect: true,
type: 'line',
//color: {r:216,g:17,b:89,a:255},
range: {
type: 'sync'
},
origin: true,
series: {}
}
};
_.each(symbols, function(symbol, n) {
var dataset = hedge.transform.noiseless(data[symbol], {
type: 'ma',
period: 3,
prop: 'c',
propOut: 'smooth'
});
dataset = hedge.transform.standardize(dataset, {
prop: 'smooth',
propOut: 'std1'
});
dataset = hedge.transform.standardize(dataset, {
prop: 'smooth',
type: 'rolling',
period: 60,
propOut: 'std2'
});
dataset = hedge.transform.delta(dataset, {
prop: 'std2',
propOut: 'delta'
});
dataset = hedge.transform.delta(dataset, {
type: 'ma',
period: 12,
prop: 'std2',
propOut: 'madelta'
});
// Main panels
panels.raw.series[symbol] = _.map(data[symbol], function(item) {
return item.c;
});
panels.standardized1.series[symbol] = _.map(dataset, function(item) {
return item.std1;
});
panels.standardized2.series[symbol] = _.map(dataset, function(item) {
return item.std2;
});
panels.delta.series[symbol] = _.map(dataset, function(item) {
return item.delta;
});
panels.madelta.series[symbol] = _.map(dataset, function(item) {
return item.madelta;
});
});
// Stats panels
panels.std1_stats.series.mean = hedge.transform.hmean(panels.standardized1.series, {});
panels.std1_stats.series.stdev = hedge.transform.hstdev(panels.standardized1.series, {});
panels.std2_stats.series.mean = hedge.transform.hmean(panels.standardized2.series, {});
panels.std2_stats.series.stdev = hedge.transform.hstdev(panels.standardized2.series, {});
panels.delta_stats.series.mean = hedge.transform.hmean(panels.madelta.series, {});
panels.delta_stats.series.stdev = hedge.transform.hstdev(panels.madelta.series, {});
var chart = _.extend({
filename: 'data/correlation-pair-rolling-std.png',
width: chartSize[0],
height: chartSize[1],
charts: []
}, hedge.chart.vpanels([panels.raw, panels.std1_stats, panels.std2_stats, panels.delta_stats, panels.standardized1, panels.standardized2, panels.madelta]));
//hedge.debug("chart", chart);
hedge.chart.render(chart);
});
var hedgejs = require('./hedgejs');
var chartLib = require('./chart');
var pstack = require('pstack');
var _ = require('underscore');
var hedge = new hedgejs({});
var data = {};
var symbols = ['CURRENCY:EUR-USD','CURRENCY:EUR-CAD','CURRENCY:EUR-NZD','CURRENCY:EUR-AUD'];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2015,1,01));
hedge.market.to(new Date(2015,4,01));
hedge.market.timeframe('hours');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
return true;
});
return true;
});
return true;
});
stack.start(function() {
var charts = [];
var chartSize = [1200,400];
var panels = {
raw: {
width: 1920,
height: 400,
rect: true,
type: 'line',
series: {},
polarity: {}
},
standardized: {
width: 1920,
height: 400,
rect: true,
type: 'line',
//color: {r:255,g:255,b:255,a:255},
origin: true,
range: {
type: 'sync'
},
series: {}
}
};
_.each(symbols, function(symbol, n) {
var dataset = data[symbol];
dataset = hedge.transform.noiseless(dataset, {
type: 'ma',
period: 24,
prop: 'c',
propOut: 'ma'
});
dataset = hedge.transform.standardize(dataset, {
type: 'rolling',
period: 100,
prop: 'ma',
propOut: 'std'
});
// Main panels
panels.raw.series[symbol] = _.map(dataset, function(item) {
return item.c;
});
panels.standardized.series[symbol] = _.map(dataset, function(item) {
return item.std;
});
panels.raw.polarity[symbol] = {
positive: {r:88,g:144,b:255,a:255},
negative: {r:216,g:17,b:89,a:255},
data: panels.standardized.series[symbol],
threshold_pos: _.max(panels.standardized.series[symbol])*0.1,
threshold_neg: _.min(panels.standardized.series[symbol])*0.1
};
});
var chart = _.extend({
filename: 'data/pair-chart-polarity.png',
width: chartSize[0],
height: chartSize[1],
charts: []
}, hedge.chart.vpanels([panels.raw, panels.standardized]));
hedge.chart.render(chart);
});
var hedgejs = require('./hedgejs');
var chartLib = require('./chart');
var pstack = require('pstack');
var _ = require('underscore');
var hedge = new hedgejs({});
var data = {};
var symbols = ['CURRENCY:EUR-USD'];
var stack = new pstack();
_.each(symbols, function(symbol) {
stack.add(function(done) {
hedge.market.open(symbol);
hedge.market.from(new Date(2016,0,01));
hedge.market.to(new Date(2016,2,01));
hedge.market.timeframe('1h');
hedge.market.fetch(function(response) {
data[symbol] = response;
done();
return true;
});
return true;
});
return true;
});
stack.start(function() {
var charts = [];
var chartSize = [1200,400];
var panels = {
raw: {
width: 1920,
height: 400,
rect: true,
type: 'line',
series: {},
polarity: {},
objects: {}
},
range: {
width: 1920,
height: 200,
rect: true,
type: 'line',
color: {r:255,g:255,b:255,a:255},
origin: true,
series: {},
objects: {}
},
osc: {
width: 1920,
height: 200,
rect: true,
type: 'line',
origin: true,
series: {},
objects: {}
},
polarity: {
width: 1920,
height: 200,
rect: true,
type: 'line',
color: {r:255,g:255,b:255,a:255},
origin: true,
series: {},
polarity: {},
objects: {}
},
transformed: {
width: 1920,
height: 400,
rect: true,
type: 'line',
color: {r:255,g:255,b:255,a:255},
origin: true,
series: {},
objects: {}
},
backtest: {
balance: {
width: 1920,
height: 200,
rect: true,
type: 'line',
series: {}
},
profits: {
width: 1920,
height: 200,
rect: true,
type: 'line',
origin: true,
series: {}
}
}
};
panels.raw.objects[symbols[0]] = [];
_.each(symbols, function(symbol, n) {
var dataset = data[symbol];
// Moving Average
dataset = hedge.transform.noiseless(dataset, {
type: 'ma',
prop: 'c',
propOut: 'ma',
period: 14,
});
// Moving Average Delta
dataset = hedge.transform.delta(dataset, {
type: 'lag',
prop: 'ma',
propOut: 'delta',
period: 2
});
dataset = hedge.transform.normalize(dataset, {
prop: 'delta',
propOut: 'delta',
period: 2,
min: -1,
max: 1,
symmetry: true
});
// Difference between the price and the MA
dataset = hedge.transform.diff(dataset, {
type: 'lag',
propA: 'c',
propB: 'ma',
propOut: 'diff'
});
dataset = hedge.transform.normalize(dataset, {
prop: 'diff',
propOut: 'diff',
period: 2,
min: -1,
max: 1,
symmetry: true
});
// AND Polarity
dataset = hedge.transform.ANDpolarity(dataset, {
propA: 'diff',
propB: 'delta',
propOut: 'polarity'
});
// Stochastic Standardization
dataset = hedge.transform.standardize(dataset, {
type: 'rolling',
prop: 'ma',
propOut: 'std',
period: 14,
});
// Trading Range
dataset = hedge.transform.range(dataset, {
propOpen: 'o',
propClose: 'c',
propOut: 'range',
period: 14
});
// Main panels
panels.raw.series[symbol] = _.map(dataset, function(item) {
return item.c;
});
// Moving Average
panels.raw.series[symbol+'ma'] = _.map(dataset, function(item) {
return item.ma;
});
// Diff
panels.osc.series[symbol+'diff'] = _.map(dataset, function(item) {
return item.diff;
});
// Moving Average Delta
panels.osc.series[symbol+'delta'] = _.map(dataset, function(item) {
return item.delta;
});
// AND Polarity Signal
panels.polarity.series[symbol] = _.map(dataset, function(item) {
return item.polarity;
});
// Average trading range
panels.range.series[symbol] = _.map(dataset, function(item) {
return item.range;
});
// Stochastic Standardization
panels.transformed.series[symbol] = _.map(dataset, function(item) {
return item.std;
});
// Polarity
panels.raw.polarity[symbol] = {
positive: {r:88,g:144,b:255,a:255},
negative: {r:216,g:17,b:89,a:255},
data: panels.polarity.series[symbol],
threshold_pos: 0,//_.max(panels.transformed.series[symbol])*0.3,
threshold_neg: 0//_.min(panels.transformed.series[symbol])*0.3
};
// Polarity
panels.polarity.polarity[symbol] = {
positive: {r:88,g:144,b:255,a:255},
negative: {r:216,g:17,b:89,a:255},
data: panels.polarity.series[symbol],
threshold_pos: 0,//_.max(panels.transformed.series[symbol])*0.3,
threshold_neg: 0//_.min(panels.transformed.series[symbol])*0.3
};
});
hedge.debug('panels.raw', panels.raw);
/*
hedge.debug("backtest", {
main: data[symbols[0]], // Main data, mandatory
std: panels.transformed.series[symbols[0]],
range: panels.range.series[symbols[0]]
});
*/
// Backtest
var backtest = hedge.trader.backtest({
rules: {
balance: 10000,
leverage: 100
},
data: {
main: data[symbols[0]], // Main data, mandatory
std: panels.transformed.series[symbols[0]],
range: panels.range.series[symbols[0]]
},
buffer: {
flags: {},
trigger: {
trigger: 0.7,
range: [0.5,0.7]
},
stdRange: {
min: 1000000,
max: -1000000
}
},
trade: function(n, data, buffer) {
// Update the trigger points
var std = data.std[n];
if (std > buffer.stdRange.max) {
buffer.stdRange.max = std;
}
if (std < buffer.stdRange.min) {
buffer.stdRange.min = std;
}
var triggers = {
sell: {
trigger: buffer.stdRange.max*buffer.trigger.trigger,
range: [buffer.stdRange.max*buffer.trigger.range[0],buffer.stdRange.max*buffer.trigger.range[1]]
},
buy: {
trigger: buffer.stdRange.min*buffer.trigger.trigger,
range: [buffer.stdRange.min*buffer.trigger.range[0],buffer.stdRange.min*buffer.trigger.range[1]]
}
}
// Trade only when we have some history
if (n > 30) {
if (data.std[n-1]>triggers.sell.trigger && data.std[n]<triggers.sell.trigger) {
//this.closeAll();
}
// Buy
if (buffer.flags.buy) {
// There was a flag, so we previously touched the trigger point
if (data.std[n-1]>triggers.buy.trigger && data.std[n]<triggers.buy.trigger) {
buffer.flags.buy = true;
}
} else {
if (data.std[n-1]<triggers.buy.range[1] && data.std[n]>triggers.buy.range[1] && data.std[n]<triggers.buy.range[0]) {
buffer.flags.buy = false;
this.buy({
lots: this.balance*0.15,
TS: -data.range[n]*2
});
}
}
}
}
});
console.log("Stats:\n---------\n",JSON.stringify(backtest.stats(),null,4));
//hedge.debug("backtest.charts", backtest.charts);
// Chart the balance and profits
panels.backtest.balance.series.balance = backtest.charts.balance;
panels.backtest.balance.series.value = backtest.charts.value;
panels.backtest.profits.series.profits = backtest.charts.profits;
//hedge.debug("backtest.charts", backtest.charts);
//hedge.debug("backtest.positions", backtest.positions);
// Generate the positions
_.each(backtest.positions, function(position) {
//position.ended -= 14;
//position.started -= 14;
panels.raw.objects[symbols[0]].push({
type: 'line',
coords: [position.started,position.entry,position.ended,position.exit]
});
// Add the objects
if (position.TP) {
panels.raw.objects[symbols[0]].push({
type: 'TP',
value: position.TP,
from: position.started,
length: position.ended-position.started
});
}
if (position.SL) {
panels.raw.objects[symbols[0]].push({
type: 'SL',
value: position.SL,
from: position.started,
length: position.ended-position.started
});
}
if (position.TP && position.SL) {
panels.raw.objects[symbols[0]].push({
type: 'line',
coords: [position.started,Math.max(position.entry, position.exit),position.started,Math.min(position.entry, position.exit)]
});
panels.raw.objects[symbols[0]].push({
type: 'line',
coords: [position.ended,Math.max(position.entry, position.exit),position.ended,Math.min(position.entry, position.exit)]
});
if (position.entry!=position.TP&&position.entry!=position.SL) {
panels.raw.objects[symbols[0]].push({
type: 'line',
coords: [position.started,position.entry,position.ended,position.entry]
});
}
}
});
var chart = _.extend({
filename: 'data/backtest-test.png',
width: chartSize[0],
height: chartSize[1],
charts: [],
slice: 0
}, hedge.chart.vpanels([panels.raw, panels.polarity/*, panels.osc, panels.transformed, panels.backtest.balance, panels.backtest.profits*/]));
hedge.chart.render(chart);
});