# Fibonacci Band Oscillation Strategy

Author: ChaoZhang, Date: 2023-11-21 13:47:12
Tags:

## Overview

The Fibonacci Band Oscillation Strategy is a quantitative strategy designed based on the Fibonacci theory. It mainly uses the Fibonacci ratio to calculate multiple price bands to form upper and lower bands. When the price breaks through the bands, trading signals are generated to capture the oscillation characteristics between the bands for profit.

## Strategy Logic

The core logic of the code is to calculate the Fibonacci price bands as key points. The main steps are:

1. Calculate the 14-period EMA as the middle line
2. Calculate the upper and lower 4 band lines according to the ATR and Fibonacci ratios
3. Generate trading signals when price breaks through the downside bands or upside bands
4. Set stop loss and take profit to track price oscillation for profits

With this breakthrough-based method, it can effectively capture short-term fluctuations in the market and make round-trip trades between bands for profits.

The biggest advantage of this strategy is that it utilizes the important theoretical indicator of the Fibonacci ratio to locate key price points, thereby increasing the probability of profit. The specific advantages are mainly reflected in:

1. Clear Fibonacci bands, easy to judge breakout points
2. Reasonable band range, not too fragmented or too loose
3. Multiple bands can be selected for both aggressive and conservative trading
4. Significant band oscillation characteristics, good effect for short-term trading strategies

## Risks

Since the strategy pursues short-term profits, there are also some risks to note:

1. Unable to profit under large cycle trends
2. High stop loss risk under violent price fluctuations
3. Many breakthrough signals require cautious selection
4. Invalid when band oscillation characteristics disappear

These risks can be controlled by appropriately adjusting parameters, selecting appropriate bands, and capital management methods.

## Optimization

There is still room for further optimization of the strategy:

1. Combine with trend indicators to generate signals only in certain trend directions
2. Close the strategy before and after specific time periods or important events
3. Dynamically adjust the stop loss amplitude according to market volatility frequency
4. Optimize parameters by selecting EMAs of different cycles as the benchmark line

## Conclusion

In general, the Fibonacci Band Oscillation Strategy is a very practical short-term strategy. It uses the Fibonacci theory to set price key points. When the price oscillates around these points, generous profits can be obtained. This breakout-based method is suitable for markets with a certain degree of volatility and characteristics. It can be used alone or combined with other strategies. With parameter tuning and proper capital management, the strategy can operate stably in the long run.

```/*backtest
start: 2022-11-14 00:00:00
end: 2023-11-20 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

//@version=5
strategy("FIBONACCI BANDS Strategy", shorttitle="FBANDS Strategy", overlay=true)
// === Date === {
//Backtest dates
fromDay = input.int(defval=1, title='From Day',minval=1,maxval=31)
fromMonth = input.int(defval=2, title='From Month',minval=1,maxval=12)
fromYear = input.int(defval=2022, title='From Year')
thruDay = input.int(defval=1, title='Thru Day',minval=1,maxval=31)
thruMonth = input.int(defval=1, title='Thru Month',minval=1,maxval=12)
thruYear = input.int(defval=2112, title='Thru Year')
showDate = true  // input(defval=true, title="Show Date Range")
start = timestamp(fromYear, fromMonth, fromDay, 00, 00)  // backtest start window
finish = timestamp(thruYear, thruMonth, thruDay, 23, 59)  // backtest finish window
window() =>  // create function "within window of time"
time >= start and time <= finish ? true : false
// }

// === Long or Short ===
tradeDirection = input.string(title="Long veya Short", options=["Long", "Short", "Both"], defval="Both",                                       group="Bot")
// Translate input into trading conditions
// }

// === FIBONACCI BANDS === {
EMAperiod = input.int(14, title='EMAperiod', minval=1, maxval=500, group="Fibonacci")
ATRperiod = input.int(14, title='ATRperiod', minval=1, maxval=500, group="Fibonacci")
EMA = ta.ema(close, EMAperiod)
TR1 = math.max(high - low, math.abs(high - close[1]))
TR = math.max(TR1, math.abs(low - close[1]))
ATR = ta.sma(TR, ATRperiod)
F2 = input(defval=1.618, title='Fibonacci Ratio 2', group="Fibonacci")
F3 = input(defval=2.618, title='Fibonacci Ratio 3', group="Fibonacci")
F4 = input(defval=4.236, title='Fibonacci Ratio 4', group="Fibonacci")
R1 = ATR
R2 = ATR * F2
R3 = ATR * F3
R4 = ATR * F4
FIBOTOP4 = EMA + R4
FIBOTOP3 = EMA + R3
FIBOTOP2 = EMA + R2
FIBOTOP1 = EMA + R1
FIBOBOT1 = EMA - R1
FIBOBOT2 = EMA - R2
FIBOBOT3 = EMA - R3
FIBOBOT4 = EMA - R4
plot(FIBOTOP4[1], title='FIBOTOP4', linewidth=1, color=color.new(color.orange, 0))
plot(FIBOTOP3[1], title='FIBOTOP3', linewidth=1, color=color.new(color.aqua, 20))
plot(FIBOTOP2[1], title='FIBOTOP2', linewidth=1, color=color.new(color.gray, 40))
plot(FIBOTOP1[1], title='FIBOTOP1', linewidth=1, color=color.new(color.purple, 40))

plot(FIBOBOT1[1], title='FIBOBOT1', linewidth=1, color=color.new(color.green, 40))
plot(FIBOBOT2[1], title='FIBOBOT2', linewidth=1, color=color.new(color.yellow, 40))
plot(FIBOBOT3[1], title='FIBOBOT3', linewidth=1, color=color.new(color.blue, 20))
plot(FIBOBOT4[1], title='FIBOBOT4', linewidth=1, color=color.new(color.aqua, 0))
// plot(EMA[1], style=plot.style_cross, title='EMA', color=color.new(color.red, 0))

prefm = input.string(title="Fibo", options=["close>FIBOTOP4(orange)", "close>FIBOTOP3(aqua)","close>FIBOTOP2(gray)","close>FIBOTOP1(purple)", "Disable"] , defval="close>FIBOTOP1(purple)", group="Long")
_prefm = false
if (prefm == "close>FIBOTOP4(orange)" )
_prefm := close>FIBOTOP4[1]

if (prefm == "close>FIBOTOP3(aqua)" )
_prefm := close>FIBOTOP3[1]

if (prefm == "close>FIBOTOP2(gray)" )
_prefm := close>FIBOTOP2[1]

if (prefm == "close>FIBOTOP1(purple)" )
_prefm := close>FIBOTOP2[1]

if (prefm == "Disable" )
_prefm := low<low[1] or low>low[1]

prefmS = input.string(title="Fibo", options=["close<FIBOBOT1(green)", "close<FIBOBOT2(yellow)", "close<FIBOBOT3(blue)", "close<FIBOBOT4(aqua)", "Disable"] , defval="close<FIBOBOT1(green)", group="Short")
_prefmS = false
if (prefmS == "close<FIBOBOT1(green)" )
_prefmS := close<FIBOBOT1[1]

if (prefmS == "close<FIBOBOT2(yellow)" )
_prefmS := close<FIBOBOT2[1]

if (prefmS == "close<FIBOBOT3(blue)" )
_prefmS := close<FIBOBOT3[1]

if (prefmS == "close<FIBOBOT4(aqua)" )
_prefmS := close<FIBOBOT4[1]

if (prefmS == "Disable" )
_prefmS := low<low[1] or low>low[1]

// }

long2= _prefm

short2= _prefmS
//

// === Bot Codes === {
enterlong = input("Long Code", title='Long İlk Alım', group="Long Code")
entershort= input("Short Code", title='Short İlk Alım', group="Short Code")
exitlong = input("Long Exit Code", title='Long Exit', group="Long Code")
exitshort= input("Short Exit Code", title='Short Exit', group="Short Code")
// }

////////////////////////////////////////////////////////////////////////////////////////////TPSL
// Inputs
sl_inp = input.float(4, title='Stop %', step=0.1, group="Long") / 100
tp_inp = input.float(1.5, title='TP %', step=0.1, group="Long") / 100

sl_inp2 = input.float(4, title='Stop %', step=0.1, group="Short") / 100
tp_inp2 = input.float(1.5, title='TP %', step=0.1, group="Short") / 100

longtp = strategy.position_avg_price * (1 + tp_inp)
longstop=  strategy.position_avg_price * (1 - sl_inp)

shortstop=  strategy.position_avg_price * (1 + sl_inp2)
shorttp = strategy.position_avg_price * (1 - tp_inp2)
////////////////////////////////////////////////////////////////////////////////////////////
if window() and strategy.position_size==0 and longOK
strategy.entry("Long", strategy.long, when= long2, alert_message=enterlong, comment="Long")

if strategy.position_size>0
strategy.exit("Long", stop= longstop, limit=longtp, alert_message=exitlong, comment="TPSL")
////////////////////////////////////////////////////////////////////////////////////////////SHORT
if window() and strategy.position_size==0 and shortOK
strategy.entry("Short", strategy.short, when= short2, alert_message=entershort, comment="Short")

if strategy.position_size<0
strategy.exit("Short", stop= shortstop, limit= shorttp, alert_message=exitshort, comment="TPSL")

```

More