AI Turbo Trade

Strategy Configuration JavaScript

Strategy Name

Timeframe

Strategy Code

// Bollinger Bands + Stochastic Strategy for EUR/USD
const bb_period = 20;           // Bollinger Bands period
const bb_stddev = 2;            // Standard deviation
const stoch_k_period = 14;      // Stochastic %K period
const stoch_d_period = 3;       // Stochastic %D period
const overbought = 80;          // Stochastic overbought threshold
const oversold = 20;            // Stochastic oversold threshold
const trade_size_percent = 0.1; // 10% of capital per trade

// Strategy Logic - This function must return: 'buy', 'sell', or 'hold'
function executeStrategy(data, context) {
    // data: { open, high, low, close, volume, timestamp }
    // context: { position, cash, equity, history }
    
    // Need enough data for both indicators
    const minBars = Math.max(bb_period, stoch_k_period + stoch_d_period);
    if (context.history.length < minBars) return 'hold';
    
    // Get price data from history
    const closes = context.history.map(h => h.close);
    const highs = context.history.map(h => h.high);
    const lows = context.history.map(h => h.low);
    const current_price = data.close;
    
    // Calculate Bollinger Bands
    const sma = calculateSMA(closes, bb_period);
    const std = calculateStandardDeviation(closes, bb_period, sma);
    const upper_band = sma + bb_stddev * std;
    const lower_band = sma - bb_stddev * std;
    
    // Calculate Stochastic Oscillator
    const stoch = calculateStochastic(highs, lows, closes, stoch_k_period, stoch_d_period);
    
    // Trading logic with dual confirmation
    if (current_price < lower_band && stoch.k < oversold && context.position <= 0) {
        // Buy signal (price below lower BB AND stochastic oversold)
        return 'buy';
    } else if (current_price > upper_band && stoch.k > overbought && context.position >= 0) {
        // Sell signal (price above upper BB AND stochastic overbought)
        return 'sell';
    }
    
    return 'hold';
}

// Helper function for Simple Moving Average
function calculateSMA(data, period) {
    const slice = data.slice(-period);
    return slice.reduce((sum, value) => sum + value, 0) / period;
}

// Helper function for Standard Deviation
function calculateStandardDeviation(data, period, sma) {
    const slice = data.slice(-period);
    const squaredDiffs = slice.map(price => Math.pow(price - sma, 2));
    const variance = squaredDiffs.reduce((sum, value) => sum + value, 0) / period;
    return Math.sqrt(variance);
}

// Helper function for Stochastic Oscillator
function calculateStochastic(highs, lows, closes, k_period, d_period) {
    const currentClose = closes[closes.length - 1];
    
    // Get the most recent periods for calculation
    const recentHighs = highs.slice(-k_period);
    const recentLows = lows.slice(-k_period);
    
    // Calculate highest high and lowest low
    const highest_high = Math.max(...recentHighs);
    const lowest_low = Math.min(...recentLows);
    
    // Calculate %K
    const stoch_k = 100 * (currentClose - lowest_low) / (highest_high - lowest_low);
    
    // Calculate %D (simple moving average of %K)
    // We need previous %K values for this
    const k_values = [];
    for (let i = closes.length - k_period; i < closes.length; i++) {
        const periodHighs = highs.slice(i - k_period + 1, i + 1);
        const periodLows = lows.slice(i - k_period + 1, i + 1);
        const periodHighest = Math.max(...periodHighs);
        const periodLowest = Math.min(...periodLows);
        const k_val = 100 * (closes[i] - periodLowest) / (periodHighest - periodLowest);
        k_values.push(k_val);
    }
    
    // Calculate %D as SMA of the last d_period %K values
    const recent_k_values = k_values.slice(-d_period);
    const stoch_d = recent_k_values.reduce((sum, val) => sum + val, 0) / d_period;
    
    return {
        k: stoch_k,
        d: stoch_d
    };
}

Performance Summary

Total Return

+0.0%

Overall Performance

Sharpe Ratio

0.00

Risk-Adjusted Return

Max Drawdown

-0.0%

Maximum Loss

Win Rate

0.0%

Winning Trades

Backtest Parameters

Symbol

Start Date

End Date

Initial Capital ($)

Commission per Trade ($)

Risk per Trade (%)

Percentage of capital to risk per trade

Strategy Tips

Use realistic position sizing
Include commission costs
Test different market conditions
Consider risk management

Total Trades	0
Win Rate	0.0%
Avg Win / Avg Loss	0.00
Profit Factor	0.00
Avg Trade Duration	0 days
Best Trade	+$0.00
Worst Trade	-$0.00

EUR/USD Strategy Backtesting

Running Backtest Analysis

Equity Curve

Performance Metrics

Trade Analysis

Trade History

Monthly Returns

Total Return	0.0%
Annual Return	0.0%
Volatility (Annual)	0.0%
Sharpe Ratio	0.00
Sortino Ratio	0.00
Max Drawdown	-0.0%
Calmar Ratio	0.00