2388 lines
43 KiB
Plaintext
2388 lines
43 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Common Library
|
|
// --------------------------------------
|
|
// Name: XCommon
|
|
// Description: provide all commonly used functions ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// START Inputs ...
|
|
//
|
|
//
|
|
// END Inputs ...
|
|
//
|
|
|
|
//
|
|
// Include Models Library ...
|
|
#include "x-saherelm.models.lib.mq5";
|
|
|
|
//
|
|
// START Global Definitions: Variables, Properties and etc ...
|
|
//
|
|
//
|
|
// END Global Definitions: Variables, Properties and etc ...
|
|
//
|
|
|
|
//
|
|
// START Provided Functions ...
|
|
//
|
|
//
|
|
// Detect is new Candle or not ...
|
|
bool IsNewCandle()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
static int barsOnChart = 0;
|
|
int currentBarsOnChart = Bars(_Symbol, _Period);
|
|
result = currentBarsOnChart > barsOnChart;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
barsOnChart = currentBarsOnChart;
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrive Ask Price ...
|
|
double GetAsk()
|
|
{
|
|
return SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
|
}
|
|
double GetAsk(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
double result = SymbolInfoDouble(symbol, SYMBOL_ASK);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Bid Price ...
|
|
double GetBid()
|
|
{
|
|
return SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
|
}
|
|
double GetBid(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
double result = SymbolInfoDouble(symbol, SYMBOL_BID);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Calculate and Retrieve Spread Price ...
|
|
double GetSpread()
|
|
{
|
|
//
|
|
double ask = GetAsk();
|
|
double bid = GetBid();
|
|
double result = MathAbs(ask - bid);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetSpread(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
double result = MathAbs(ask - bid);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Points ...
|
|
double GetPoints()
|
|
{
|
|
return _Point;
|
|
}
|
|
double GetPoints(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
double result = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Digits ...
|
|
int GetDigits()
|
|
{
|
|
return _Digits;
|
|
}
|
|
int GetDigits(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
int result = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Signal Entry ...
|
|
double GetEntry(
|
|
ENUM_X_SIGNAL_TYPE type = X_SIGNAL_UNKNOWN // Get entry price for Which direction trade ...
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
// Validate Arg ...
|
|
if (type == X_SIGNAL_UNKNOWN)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isLong = type == X_SIGNAL_LONG;
|
|
result = isLong ? GetAsk() : GetBid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get 1 Pip in Price Value ...
|
|
double GetPipPrice()
|
|
{
|
|
//
|
|
double result = _Point;
|
|
if (_Digits == 3 || _Digits == 5)
|
|
{
|
|
result *= 10;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetPipPrice(
|
|
string symbol // selected symbol for calculations
|
|
)
|
|
{
|
|
//
|
|
double symbolPoint = GetPoints(symbol);
|
|
int symbolDigits = GetDigits(symbol);
|
|
|
|
//
|
|
double result = symbolPoint;
|
|
if (symbolDigits == 3 || symbolDigits == 5)
|
|
{
|
|
result *= 10;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Converts Pips To Price ...
|
|
double PipsToPrice(
|
|
int pips // pips amount
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits();
|
|
double pipValue = GetPipPrice();
|
|
double result = pips * pipValue;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double PipsToPrice(
|
|
double pips // pips amount
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits();
|
|
double pipValue = GetPipPrice();
|
|
double result = pips * pipValue;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double PipsToPrice(
|
|
string symbol, // selected symbol for calculation
|
|
int pips // pips amount
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits(symbol);
|
|
double pipValue = GetPipPrice(symbol);
|
|
double result = pips * pipValue;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double PipsToPrice(
|
|
string symbol, // selected symbol for calculation
|
|
double pips // pips amount
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits(symbol);
|
|
double pipValue = GetPipPrice(symbol);
|
|
double result = pips * pipValue;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Converts Price to Pips ...
|
|
double PriceToPips(
|
|
double price // the price amount which required to calculate
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits();
|
|
double pipPrice = GetPipPrice();
|
|
|
|
//
|
|
double result = price / pipPrice;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double PriceToPips(
|
|
string symbol, // Selected Symbol
|
|
double price // the price amount which required to calculate
|
|
)
|
|
{
|
|
//
|
|
int digits = GetDigits(symbol);
|
|
double pipPrice = GetPipPrice(symbol);
|
|
|
|
//
|
|
double result = price / pipPrice;
|
|
|
|
//
|
|
result = NormalizeDouble(result, digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get a Candle Body ...
|
|
double GetCandleBody(
|
|
XOHCL &candle // specified candle
|
|
)
|
|
{
|
|
//
|
|
double result = MathAbs(candle.open - candle.close);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get a Candle Range ...
|
|
double GetCandleRange(
|
|
XOHCL &candle // specified candle
|
|
)
|
|
{
|
|
//
|
|
double result = MathAbs(candle.high - candle.low);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get a Candle Shadow ...
|
|
double GetCandleShadow(
|
|
XOHCL &candle // specified candle
|
|
)
|
|
{
|
|
//
|
|
double range = GetCandleRange(candle);
|
|
double body = GetCandleBody(candle);
|
|
|
|
//
|
|
double result = MathAbs(range - body);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Applied Price at Specific Candle ...
|
|
double GetAppliedPrice(
|
|
XOHCL &candle, // specified candle
|
|
ENUM_APPLIED_PRICE source = PRICE_CLOSE // specified Applied To
|
|
)
|
|
{
|
|
//
|
|
double result = EMPTY_VALUE;
|
|
|
|
//
|
|
switch (source)
|
|
{
|
|
//
|
|
// Open ...
|
|
case PRICE_OPEN:
|
|
result = candle.open;
|
|
break;
|
|
|
|
//
|
|
// High ...
|
|
case PRICE_HIGH:
|
|
result = candle.high;
|
|
break;
|
|
|
|
//
|
|
// Low ...
|
|
case PRICE_LOW:
|
|
result = candle.low;
|
|
break;
|
|
|
|
//
|
|
// Median ((High + Low) / 2) ...
|
|
case PRICE_MEDIAN:
|
|
result = (candle.high + candle.low) / 2;
|
|
break;
|
|
|
|
//
|
|
// Typical ((High + Low + Close)/3) ...
|
|
case PRICE_TYPICAL:
|
|
result = (candle.high + candle.low + candle.close) / 3;
|
|
break;
|
|
|
|
//
|
|
// Weighted ((High + Low + Close + Close)/4) ...
|
|
case PRICE_WEIGHTED:
|
|
result = (candle.high + candle.low + (candle.close * 2)) / 4;
|
|
break;
|
|
|
|
//
|
|
// Close ...
|
|
default:
|
|
case PRICE_CLOSE:
|
|
result = candle.close;
|
|
break;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetAppliedPrice(
|
|
int bar_index, // specify candle index
|
|
ENUM_APPLIED_PRICE source = PRICE_CLOSE // specified Applied To
|
|
)
|
|
{
|
|
//
|
|
double result = EMPTY_VALUE;
|
|
|
|
//
|
|
XOHCL candle = GetCandle(bar_index);
|
|
result = GetAppliedPrice(candle, source);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetAppliedPrice(
|
|
int bar_index, // specify candle index
|
|
ENUM_SERIESMODE mode // converts Series Mode to Applied Price ...
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
ENUM_APPLIED_PRICE appliedTo = To(mode);
|
|
result = GetAppliedPrice(
|
|
bar_index,
|
|
appliedTo);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Converts ...
|
|
ENUM_APPLIED_PRICE To(
|
|
ENUM_SERIESMODE mode // converts Series Mode to Applied Price ...
|
|
)
|
|
{
|
|
//
|
|
ENUM_APPLIED_PRICE result = PRICE_CLOSE;
|
|
|
|
//
|
|
switch (mode)
|
|
{
|
|
//
|
|
// High ...
|
|
case MODE_HIGH:
|
|
result = PRICE_HIGH;
|
|
break;
|
|
|
|
//
|
|
// Open ...
|
|
case MODE_OPEN:
|
|
result = PRICE_OPEN;
|
|
break;
|
|
|
|
//
|
|
// Low ...
|
|
case MODE_LOW:
|
|
result = PRICE_LOW;
|
|
break;
|
|
|
|
//
|
|
// Close ...
|
|
// Default ...
|
|
case MODE_CLOSE:
|
|
default:
|
|
result = PRICE_CLOSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve a Candel Data ...
|
|
XOHCL GetCandle(int bar_index)
|
|
{
|
|
//
|
|
XOHCL result = {};
|
|
|
|
//
|
|
double open = iOpen(_Symbol, _Period, bar_index);
|
|
double high = iHigh(_Symbol, _Period, bar_index);
|
|
double close = iClose(_Symbol, _Period, bar_index);
|
|
double low = iLow(_Symbol, _Period, bar_index);
|
|
|
|
//
|
|
result.low = low;
|
|
result.open = open;
|
|
result.high = high;
|
|
result.close = close;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
XOHCL GetCandle(
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // specify candle index
|
|
)
|
|
{
|
|
//
|
|
XOHCL result = {};
|
|
|
|
//
|
|
double open = iOpen(_Symbol, period, bar_index);
|
|
double high = iHigh(_Symbol, period, bar_index);
|
|
double close = iClose(_Symbol, period, bar_index);
|
|
double low = iLow(_Symbol, period, bar_index);
|
|
|
|
//
|
|
result.low = low;
|
|
result.open = open;
|
|
result.high = high;
|
|
result.close = close;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
XOHCL GetCandle(
|
|
string symbol, // specify symbol
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // specify candle index
|
|
)
|
|
{
|
|
//
|
|
XOHCL result = {};
|
|
|
|
//
|
|
double open = iOpen(symbol, period, bar_index);
|
|
double high = iHigh(symbol, period, bar_index);
|
|
double close = iClose(symbol, period, bar_index);
|
|
double low = iLow(symbol, period, bar_index);
|
|
|
|
//
|
|
result.low = low;
|
|
result.open = open;
|
|
result.high = high;
|
|
result.close = close;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve a candle index in current timeframe inside another timeframe ...
|
|
int GetCandleBarIndex(
|
|
int bar_index, // Specify Candle index in current timeframe
|
|
ENUM_TIMEFRAMES destPeriod // Specify destination timeframe
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
datetime barTime = iTime(_Symbol, _Period, bar_index);
|
|
result = iBarShift(_Symbol, destPeriod, barTime);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve a symbol candle index in source time frame inside dest timeframe ...
|
|
int GetCandleBarIndex(
|
|
int bar_index, // Specify Candle index in current timeframe
|
|
string symbol, // Specify desired Symbol
|
|
ENUM_TIMEFRAMES sourcePeriod, // Specify bar_index timeframe
|
|
ENUM_TIMEFRAMES destPeriod // Specify destination timeframe
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
datetime barTime = iTime(symbol, sourcePeriod, bar_index);
|
|
result = iBarShift(symbol, destPeriod, barTime);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check a Candle is Bullish or not ...
|
|
bool IsBullishCandle(
|
|
XOHCL &candle // specified candle
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = candle.open < candle.close;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsBullishCandle(
|
|
int bar_index // candle index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
XOHCL candle = GetCandle(bar_index);
|
|
|
|
//
|
|
result = IsBullishCandle(candle);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsBullishCandle(
|
|
string symbol, // specify symbol
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // candle index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
XOHCL candle = GetCandle(
|
|
symbol,
|
|
period,
|
|
bar_index);
|
|
|
|
//
|
|
result = IsBullishCandle(candle);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check a Candle is Bullish or not ...
|
|
bool IsBearishCandle(
|
|
XOHCL &candle // specified candle
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = candle.open > candle.close;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsBearishCandle(
|
|
int bar_index // candle index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
XOHCL candle = GetCandle(bar_index);
|
|
|
|
//
|
|
result = IsBearishCandle(candle);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsBearishCandle(
|
|
string symbol, // specify symbol
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // candle index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
XOHCL candle = GetCandle(
|
|
symbol,
|
|
period,
|
|
bar_index);
|
|
|
|
//
|
|
result = IsBearishCandle(candle);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Candle Body Bigger Than it's Shadow ...
|
|
bool HasStrongBody(XOHCL &candle)
|
|
{
|
|
//
|
|
double bodySize = MathAbs(candle.open - candle.close);
|
|
double shadowSize = MathAbs(candle.high - candle.low) - bodySize;
|
|
|
|
//
|
|
bool result = bodySize > (shadowSize * 1.5);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Determines a cnadle is Swing High
|
|
// or Swing Low order block ...
|
|
ENUM_X_SWING_TYPE GetCandleSwing(int bar_index)
|
|
{
|
|
//
|
|
ENUM_X_SWING_TYPE result = X_NO_SWING;
|
|
|
|
//
|
|
// Reading Candle Models ...
|
|
XOHCL candles[3];
|
|
candles[0] = GetCandle(bar_index + 1);
|
|
candles[1] = GetCandle(bar_index + 2);
|
|
candles[2] = GetCandle(bar_index + 3);
|
|
|
|
//
|
|
// Check Swing Start Candle has Strong Body ...
|
|
bool isStrongBodyCandle = HasStrongBody(candles[2]);
|
|
if (!isStrongBodyCandle)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Swing Low Conditions ...
|
|
bool isSwingLowOrderBlock =
|
|
candles[2].low < candles[1].low &&
|
|
candles[1].low < candles[0].low &&
|
|
candles[2].low < candles[0].low;
|
|
if (isSwingLowOrderBlock)
|
|
{
|
|
result = X_SWING_LOW;
|
|
}
|
|
|
|
//
|
|
// Check Swing High Conditions ...
|
|
bool isSwingHighOrderBlock =
|
|
candles[2].high > candles[1].high &&
|
|
candles[1].high > candles[0].high &&
|
|
candles[2].high > candles[0].high;
|
|
if (isSwingHighOrderBlock)
|
|
{
|
|
result = X_SWING_HIGH;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
ENUM_X_SWING_TYPE GetCandleSwing(
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // specify candle index
|
|
)
|
|
{
|
|
//
|
|
ENUM_X_SWING_TYPE result = X_NO_SWING;
|
|
|
|
//
|
|
// Reading Candle Models ...
|
|
XOHCL candles[3];
|
|
candles[0] = GetCandle(period, bar_index + 1);
|
|
candles[1] = GetCandle(period, bar_index + 2);
|
|
candles[2] = GetCandle(period, bar_index + 3);
|
|
|
|
//
|
|
// Check Swing Start Candle has Strong Body ...
|
|
bool isStrongBodyCandle = HasStrongBody(candles[2]);
|
|
if (!isStrongBodyCandle)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Swing Low Conditions ...
|
|
bool isSwingLowOrderBlock =
|
|
candles[2].low < candles[1].low &&
|
|
candles[1].low < candles[0].low &&
|
|
candles[2].low < candles[0].low;
|
|
if (isSwingLowOrderBlock)
|
|
{
|
|
result = X_SWING_LOW;
|
|
}
|
|
|
|
//
|
|
// Check Swing High Conditions ...
|
|
bool isSwingHighOrderBlock =
|
|
candles[2].high > candles[1].high &&
|
|
candles[1].high > candles[0].high &&
|
|
candles[2].high > candles[0].high;
|
|
if (isSwingHighOrderBlock)
|
|
{
|
|
result = X_SWING_HIGH;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
ENUM_X_SWING_TYPE GetCandleSwing(
|
|
string symbol, // specify symbol
|
|
ENUM_TIMEFRAMES period, // specify timeframe
|
|
int bar_index // specify candle index
|
|
)
|
|
{
|
|
//
|
|
ENUM_X_SWING_TYPE result = X_NO_SWING;
|
|
|
|
//
|
|
// Reading Candle Models ...
|
|
XOHCL candles[3];
|
|
candles[0] = GetCandle(symbol, period, bar_index + 1);
|
|
candles[1] = GetCandle(symbol, period, bar_index + 2);
|
|
candles[2] = GetCandle(symbol, period, bar_index + 3);
|
|
|
|
//
|
|
// Check Swing Start Candle has Strong Body ...
|
|
bool isStrongBodyCandle = HasStrongBody(candles[2]);
|
|
if (!isStrongBodyCandle)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Swing Low Conditions ...
|
|
bool isSwingLowOrderBlock =
|
|
candles[2].low < candles[1].low &&
|
|
candles[1].low < candles[0].low &&
|
|
candles[2].low < candles[0].low;
|
|
if (isSwingLowOrderBlock)
|
|
{
|
|
result = X_SWING_LOW;
|
|
}
|
|
|
|
//
|
|
// Check Swing High Conditions ...
|
|
bool isSwingHighOrderBlock =
|
|
candles[2].high > candles[1].high &&
|
|
candles[1].high > candles[0].high &&
|
|
candles[2].high > candles[0].high;
|
|
if (isSwingHighOrderBlock)
|
|
{
|
|
result = X_SWING_HIGH;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Highest High ...
|
|
double GetHighestHigh(
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iHighest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_HIGH,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetHighestHigh(
|
|
int mLength, // Which market Length use
|
|
int bar_index, // bar index
|
|
ENUM_SERIESMODE mode // Calculation mode
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iHighest(
|
|
_Symbol,
|
|
_Period,
|
|
mode,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetHighestHigh(
|
|
string symbol, // Specified Symbol
|
|
ENUM_TIMEFRAMES period, // Specified Period
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iHighest(
|
|
symbol,
|
|
period,
|
|
MODE_HIGH,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iHigh(
|
|
symbol,
|
|
period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetHighestHigh(
|
|
string symbol, // Specified Symbol
|
|
ENUM_TIMEFRAMES period, // Specified Period
|
|
ENUM_SERIESMODE mode, // Calculation mode
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iHighest(
|
|
symbol,
|
|
period,
|
|
mode,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iHigh(
|
|
symbol,
|
|
period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Lowest Low ...
|
|
double GetLowestLow(
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iLowest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_LOW,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetLowestLow(
|
|
int mLength, // Which market Length use
|
|
int bar_index, // bar index
|
|
ENUM_SERIESMODE mode // Calculation mode
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iLowest(
|
|
_Symbol,
|
|
_Period,
|
|
mode,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetLowestLow(
|
|
string symbol, // Specified Symbol
|
|
ENUM_TIMEFRAMES period, // Specified Period
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iLowest(
|
|
symbol,
|
|
period,
|
|
MODE_LOW,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iLow(
|
|
symbol,
|
|
period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double GetLowestLow(
|
|
string symbol, // Specified Symbol
|
|
ENUM_TIMEFRAMES period, // Specified Period
|
|
ENUM_SERIESMODE mode, // Calculation mode
|
|
int mLength, // Which market Length use
|
|
int bar_index // bar index
|
|
)
|
|
{
|
|
//
|
|
double result = -1;
|
|
|
|
//
|
|
int rIdx = iLowest(
|
|
symbol,
|
|
period,
|
|
mode,
|
|
mLength,
|
|
bar_index);
|
|
|
|
//
|
|
result = iLow(
|
|
symbol,
|
|
period,
|
|
rIdx);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Calculate Fib Level ...
|
|
double GetFibonacciLevel(
|
|
double upPrice,
|
|
double downPrice,
|
|
double level,
|
|
int direction)
|
|
{
|
|
//
|
|
double ling = upPrice - downPrice;
|
|
double pLevel = (ling / 100) * (level * 100);
|
|
|
|
//
|
|
double result = direction > 0 ? upPrice - pLevel : downPrice + pLevel;
|
|
result = NormalizeDouble(result, _Digits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
//
|
|
// END Provided Functions ...
|
|
//
|
|
|
|
//
|
|
// Find Farest Time Frame ...
|
|
ENUM_TIMEFRAMES GetFarestTimeFrame()
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES result = PERIOD_MN1;
|
|
|
|
//
|
|
switch (_Period)
|
|
{
|
|
//
|
|
// M1-M30 ...
|
|
case PERIOD_M1:
|
|
case PERIOD_M2:
|
|
case PERIOD_M3:
|
|
case PERIOD_M4:
|
|
case PERIOD_M5:
|
|
case PERIOD_M6:
|
|
case PERIOD_M10:
|
|
case PERIOD_M12:
|
|
case PERIOD_M15:
|
|
case PERIOD_M20:
|
|
case PERIOD_M30:
|
|
result = PERIOD_D1;
|
|
break;
|
|
|
|
//
|
|
// H1-H12 ...
|
|
case PERIOD_H1:
|
|
case PERIOD_H2:
|
|
case PERIOD_H3:
|
|
case PERIOD_H4:
|
|
case PERIOD_H6:
|
|
case PERIOD_H8:
|
|
case PERIOD_H12:
|
|
result = PERIOD_W1;
|
|
break;
|
|
|
|
//
|
|
// D!, W1 ...
|
|
case PERIOD_D1:
|
|
case PERIOD_W1:
|
|
result = PERIOD_MN1;
|
|
break;
|
|
|
|
//
|
|
// Otherwise ...
|
|
default:
|
|
result = PERIOD_MN1;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Find Medium Time Frame ...
|
|
ENUM_TIMEFRAMES GetMediumTimeFrame()
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES result = PERIOD_D1;
|
|
|
|
//
|
|
switch (_Period)
|
|
{
|
|
//
|
|
// M1-M30 ...
|
|
case PERIOD_M1:
|
|
case PERIOD_M2:
|
|
case PERIOD_M3:
|
|
case PERIOD_M4:
|
|
case PERIOD_M5:
|
|
case PERIOD_M6:
|
|
case PERIOD_M10:
|
|
case PERIOD_M12:
|
|
case PERIOD_M15:
|
|
case PERIOD_M20:
|
|
case PERIOD_M30:
|
|
result = PERIOD_H4;
|
|
break;
|
|
|
|
//
|
|
// H1-H12 ...
|
|
case PERIOD_H1:
|
|
case PERIOD_H2:
|
|
case PERIOD_H3:
|
|
case PERIOD_H4:
|
|
case PERIOD_H6:
|
|
case PERIOD_H8:
|
|
case PERIOD_H12:
|
|
result = PERIOD_D1;
|
|
break;
|
|
|
|
//
|
|
// D!, W1 ...
|
|
case PERIOD_D1:
|
|
result = PERIOD_W1;
|
|
break;
|
|
|
|
//
|
|
// Otherwise ...
|
|
default:
|
|
result = PERIOD_MN1;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Find Smallest Time Frame ...
|
|
ENUM_TIMEFRAMES GetSmallestTimeFrame()
|
|
{
|
|
//
|
|
ENUM_TIMEFRAMES result = PERIOD_M5;
|
|
|
|
//
|
|
switch (_Period)
|
|
{
|
|
//
|
|
// M1-M5 ...
|
|
case PERIOD_M1:
|
|
case PERIOD_M2:
|
|
case PERIOD_M3:
|
|
case PERIOD_M4:
|
|
case PERIOD_M5:
|
|
result = _Period;
|
|
break;
|
|
|
|
//
|
|
// M6-M30 ...
|
|
case PERIOD_M6:
|
|
case PERIOD_M10:
|
|
case PERIOD_M12:
|
|
case PERIOD_M15:
|
|
case PERIOD_M20:
|
|
case PERIOD_M30:
|
|
result = PERIOD_M5;
|
|
break;
|
|
|
|
//
|
|
// H1-H12 ...
|
|
case PERIOD_H1:
|
|
case PERIOD_H2:
|
|
case PERIOD_H3:
|
|
case PERIOD_H4:
|
|
case PERIOD_H6:
|
|
case PERIOD_H8:
|
|
case PERIOD_H12:
|
|
result = PERIOD_H1;
|
|
break;
|
|
|
|
//
|
|
// D! ...
|
|
case PERIOD_D1:
|
|
result = PERIOD_H2;
|
|
break;
|
|
|
|
//
|
|
// Otherwise ...
|
|
default:
|
|
result = PERIOD_H4;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check first Cross Over second at bar_index ...
|
|
bool IsCrossOver(
|
|
const double &first[], // the buffer which check crossing over second buffer
|
|
const double &second[], // first buffer checks based on this buffer
|
|
const int bar_index // check crosses in specific index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
ArraySetAsSeries(first, true);
|
|
ArraySetAsSeries(second, true);
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (ArraySize(first) < bar_index + 1 || ArraySize(second) < bar_index + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = first[bar_index] > second[bar_index] &&
|
|
!(first[bar_index + 1] > second[bar_index + 1]);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check first is Over second at bar_index ...
|
|
bool IsOver(
|
|
const double &first[], // the buffer which check over second buffer
|
|
const double &second[], // first buffer checks based on this buffer
|
|
const int bar_index // check crosses in specific index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
ArraySetAsSeries(first, true);
|
|
ArraySetAsSeries(second, true);
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (ArraySize(first) < bar_index + 1 || ArraySize(second) < bar_index + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = first[bar_index] > second[bar_index] &&
|
|
first[bar_index + 1] > second[bar_index + 1];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check first Cross Under second at bar_index ...
|
|
bool IsCrossUnder(
|
|
const double &first[], // the buffer which check crossing under second buffer
|
|
const double &second[], // first buffer checks based on this buffer
|
|
const int bar_index // check crosses in specific index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
ArraySetAsSeries(first, true);
|
|
ArraySetAsSeries(second, true);
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (ArraySize(first) < bar_index + 1 || ArraySize(second) < bar_index + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = first[bar_index] < second[bar_index] &&
|
|
!(first[bar_index + 1] < second[bar_index + 1]);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check first is Under second at bar_index ...
|
|
bool IsUnder(
|
|
const double &first[], // the buffer which check under second buffer
|
|
const double &second[], // first buffer checks based on this buffer
|
|
const int bar_index // check crosses in specific index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
ArraySetAsSeries(first, true);
|
|
ArraySetAsSeries(second, true);
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (ArraySize(first) < bar_index + 1 || ArraySize(second) < bar_index + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = first[bar_index] < second[bar_index] &&
|
|
first[bar_index + 1] < second[bar_index + 1];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Calculate Slope of Specified Buffer at Specified Index ...
|
|
double GetSlope(
|
|
int from, // In Past Index ...
|
|
int to, // In Past Index ...
|
|
double &buffer[])
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
double deltaValue = toValue - fromValue;
|
|
double deltaTime = from - to;
|
|
|
|
//
|
|
result = deltaValue / deltaTime;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check if a Value Increasing in Loopback ...
|
|
bool IsIncreasing(
|
|
int from, // Last Time Index
|
|
int to, // Fisr Tima Index
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
from <= to ||
|
|
ArraySize(buffer) < from + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Items ...
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
result = toValue > fromValue;
|
|
for (int i = to + 1; i <= from - 1; i++)
|
|
{
|
|
//
|
|
double iValue = buffer[i];
|
|
bool isPassed = toValue >= iValue;
|
|
|
|
//
|
|
bool isIIncreasing = IsIncreasing(
|
|
from,
|
|
i,
|
|
buffer);
|
|
|
|
//
|
|
// Check Result ...
|
|
result = result && isPassed && isIIncreasing;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check if a Value Decreasing in Loopback ...
|
|
bool IsDecreasing(
|
|
int from, // Last Time Index
|
|
int to, // Fisr Tima Index
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
from <= to ||
|
|
ArraySize(buffer) < from + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Items ...
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
result = toValue < fromValue;
|
|
for (int i = to + 1; i <= from - 1; i++)
|
|
{
|
|
//
|
|
double iValue = buffer[i];
|
|
bool isPassed = toValue <= iValue;
|
|
|
|
//
|
|
bool isIDecreasing = IsDecreasing(
|
|
from,
|
|
i,
|
|
buffer);
|
|
|
|
//
|
|
// Check Result ...
|
|
result = result && isPassed && isIDecreasing;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Max Value of Specific Loopback of a Buffer ...
|
|
double GetMaxValue(
|
|
int mLoopback, // loopback length
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
mLoopback < 2 ||
|
|
ArraySize(buffer) < mLoopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop Through LoopBack ...
|
|
for (int i = 0; i < mLoopback; i++)
|
|
{
|
|
//
|
|
double iValue = buffer[i];
|
|
|
|
//
|
|
result =
|
|
//
|
|
result == 0 || result < iValue
|
|
//
|
|
? iValue
|
|
//
|
|
: result
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Min Value of Specific Loopback of a Buffer ...
|
|
double GetMinValue(
|
|
int mLoopback, // loopback length
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
mLoopback < 2 ||
|
|
ArraySize(buffer) < mLoopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop Through LoopBack ...
|
|
for (int i = 0; i < mLoopback; i++)
|
|
{
|
|
//
|
|
double iValue = buffer[i];
|
|
|
|
//
|
|
result =
|
|
//
|
|
result == 0 || result > iValue
|
|
//
|
|
? iValue
|
|
//
|
|
: result
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool IsInPeak(
|
|
int mLoopback, // loopback length
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
mLoopback < 2 ||
|
|
ArraySize(buffer) < mLoopback + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int q1Length = mLoopback / 4;
|
|
int halfLength = mLoopback / 2;
|
|
int q2Length = halfLength + q1Length;
|
|
|
|
//
|
|
double firstValue = buffer[1];
|
|
double q1Value = buffer[q1Length];
|
|
double q2Value = buffer[q2Length];
|
|
double halfValue = buffer[halfLength];
|
|
double lastValue = buffer[ArraySize(buffer) - 1];
|
|
|
|
//
|
|
// Peak ...
|
|
result =
|
|
//
|
|
firstValue > lastValue
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
firstValue > q1Value &&
|
|
firstValue > halfValue)
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool IsInVale(
|
|
int mLoopback, // loopback length
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
mLoopback < 2 ||
|
|
ArraySize(buffer) < mLoopback + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int q1Length = mLoopback / 4;
|
|
int halfLength = mLoopback / 2;
|
|
int q2Length = halfLength + q1Length;
|
|
|
|
//
|
|
double firstValue = buffer[1];
|
|
double q1Value = buffer[q1Length];
|
|
double q2Value = buffer[q2Length];
|
|
double halfValue = buffer[halfLength];
|
|
double lastValue = buffer[ArraySize(buffer) - 1];
|
|
|
|
//
|
|
// Peak ...
|
|
result =
|
|
//
|
|
firstValue < lastValue
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
firstValue < q1Value &&
|
|
firstValue < halfValue)
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Sharp Happens or not ...
|
|
bool IsSharpChanged(
|
|
double fromValue, // Past Value
|
|
double toValue, // Present Value
|
|
double maxValue, // Max in Range Value
|
|
double minValue // Min in Range Value
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// This Used In Increased or Decreased Sharp Detection ...
|
|
bool isIncreased = toValue > fromValue;
|
|
|
|
//
|
|
double toFromDelta = MathAbs(toValue - fromValue);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
result = toFromDelta >= (minMaxDelta / 3);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpChanged(
|
|
int from, // Past Index in Series
|
|
int to, // Present Index in Series
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
from <= to ||
|
|
ArraySize(buffer) < from + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Items ...
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
|
|
//
|
|
// This Used In Increased or Decreased Sharp Detection ...
|
|
bool isIncreased = toValue > fromValue;
|
|
|
|
//
|
|
double minValue = GetMinValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double maxValue = GetMaxValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
// Sharp Detection ...
|
|
result = IsSharpChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpChanged(
|
|
int from, // Past Bar Index
|
|
int to, // Present Bar Index
|
|
ENUM_APPLIED_PRICE appliedPrice // Which Price Choose in From or To
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
double toValue = GetAppliedPrice(
|
|
to,
|
|
appliedPrice);
|
|
double fromValue = GetAppliedPrice(
|
|
from,
|
|
appliedPrice);
|
|
|
|
//
|
|
int hIdx = iHighest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_HIGH,
|
|
from,
|
|
to);
|
|
double maxValue = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
hIdx);
|
|
|
|
//
|
|
int lIdx = iLowest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_LOW,
|
|
from,
|
|
to);
|
|
double minValue = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
lIdx);
|
|
|
|
//
|
|
result = IsSharpChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check InCreased Sharp Happens or not ...
|
|
bool IsSharpIncreasedChanged(
|
|
double fromValue, // Past Value
|
|
double toValue, // Present Value
|
|
double maxValue, // Max in Range Value
|
|
double minValue // Min in Range Value
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// This Used In Increased or Decreased Sharp Detection ...
|
|
bool isIncreased = toValue > fromValue;
|
|
|
|
//
|
|
double toFromDelta = MathAbs(toValue - fromValue);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
result =
|
|
isIncreased &&
|
|
toFromDelta >= (minMaxDelta / 3);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpIncreasedChanged(
|
|
int from, // Past Index in Series
|
|
int to, // Present Index in Series
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
from <= to ||
|
|
ArraySize(buffer) < from + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Items ...
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
|
|
//
|
|
double minValue = GetMinValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double maxValue = GetMaxValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
// Sharp Detection ...
|
|
result = IsSharpIncreasedChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpIncreasedChanged(
|
|
int from, // Past Bar Index
|
|
int to, // Present Bar Index
|
|
ENUM_APPLIED_PRICE appliedPrice // Which Price Choose in From or To
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
double toValue = GetAppliedPrice(
|
|
to,
|
|
appliedPrice);
|
|
double fromValue = GetAppliedPrice(
|
|
from,
|
|
appliedPrice);
|
|
|
|
//
|
|
int hIdx = iHighest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_HIGH,
|
|
from,
|
|
to);
|
|
double maxValue = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
hIdx);
|
|
|
|
//
|
|
int lIdx = iLowest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_LOW,
|
|
from,
|
|
to);
|
|
double minValue = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
lIdx);
|
|
|
|
//
|
|
result = IsSharpIncreasedChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Decreased Sharp Happens or not ...
|
|
bool IsSharpDecreasedChanged(
|
|
double fromValue, // Past Value
|
|
double toValue, // Present Value
|
|
double maxValue, // Max in Range Value
|
|
double minValue // Min in Range Value
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// This Used In Increased or Decreased Sharp Detection ...
|
|
bool isIncreased = toValue > fromValue;
|
|
|
|
//
|
|
double toFromDelta = MathAbs(toValue - fromValue);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
result =
|
|
!isIncreased &&
|
|
toFromDelta >= (minMaxDelta / 3);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpDecreasedChanged(
|
|
int from, // Past Index in Series
|
|
int to, // Present Index in Series
|
|
double &buffer[] // the Buffer which required to search
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
from <= to ||
|
|
ArraySize(buffer) < from + 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Items ...
|
|
double toValue = buffer[to];
|
|
double fromValue = buffer[from];
|
|
|
|
//
|
|
double minValue = GetMinValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double maxValue = GetMaxValue(
|
|
ArraySize(buffer) - 1,
|
|
buffer);
|
|
double minMaxDelta = maxValue - minValue;
|
|
|
|
//
|
|
// Sharp Detection ...
|
|
result = IsSharpDecreasedChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsSharpDecreasedChanged(
|
|
int from, // Past Bar Index
|
|
int to, // Present Bar Index
|
|
ENUM_APPLIED_PRICE appliedPrice // Which Price Choose in From or To
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
double toValue = GetAppliedPrice(
|
|
to,
|
|
appliedPrice);
|
|
double fromValue = GetAppliedPrice(
|
|
from,
|
|
appliedPrice);
|
|
|
|
//
|
|
int hIdx = iHighest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_HIGH,
|
|
from,
|
|
to);
|
|
double maxValue = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
hIdx);
|
|
|
|
//
|
|
int lIdx = iLowest(
|
|
_Symbol,
|
|
_Period,
|
|
MODE_LOW,
|
|
from,
|
|
to);
|
|
double minValue = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
lIdx);
|
|
|
|
//
|
|
result = IsSharpDecreasedChanged(
|
|
fromValue,
|
|
toValue,
|
|
maxValue,
|
|
minValue);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Validate Struct ...
|
|
bool IsValid(XSignal &model, ulong magicNumber)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Signal Type ...
|
|
result = model.type != X_SIGNAL_UNKNOWN;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Symbol ...
|
|
result = StringLen(model.symbol) == 0 ? true : model.symbol == _Symbol;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check magic number ...
|
|
result = model.magicNumber <= 0 ? true : model.magicNumber == magicNumber;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Entry ...
|
|
result = model.entry > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check SL ...
|
|
result = model.sl == 0 ? true : model.type == X_SIGNAL_LONG ? model.sl < model.entry
|
|
: model.sl > model.entry;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check TP ...
|
|
result = model.tp == 0 ? true : model.type == X_SIGNAL_LONG ? model.tp > model.entry
|
|
: model.tp < model.entry;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Volume ...
|
|
result = model.volume > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Time ...
|
|
result = model.time > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
bool IsValid(XTPSL &model)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = model.entry > 0 && model.type != X_SIGNAL_UNKNOWN;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void CleanBuffer(int &buffer[])
|
|
{
|
|
//
|
|
ArrayFree(buffer);
|
|
ArrayResize(buffer, 0);
|
|
}
|
|
void CleanBuffer(double &buffer[])
|
|
{
|
|
//
|
|
ArrayFree(buffer);
|
|
ArrayResize(buffer, 0);
|
|
}
|
|
void CleanBuffer(XSignal &buffer[])
|
|
{
|
|
//
|
|
ArrayFree(buffer);
|
|
ArrayResize(buffer, 0);
|
|
}
|
|
|
|
//
|
|
void Add(
|
|
int item, // item want to add
|
|
int &buffer[] // Destination buffer
|
|
)
|
|
{
|
|
//
|
|
ArrayResize(
|
|
buffer,
|
|
ArraySize(buffer) + 1);
|
|
|
|
//
|
|
buffer[ArraySize(buffer) - 1] = item;
|
|
}
|
|
void Add(
|
|
double item, // item want to add
|
|
double &buffer[] // Destination buffer
|
|
)
|
|
{
|
|
//
|
|
ArrayResize(
|
|
buffer,
|
|
ArraySize(buffer) + 1);
|
|
|
|
//
|
|
buffer[ArraySize(buffer) - 1] = item;
|
|
}
|
|
void Add(
|
|
XOHCL &item, // item want to add
|
|
XOHCL &buffer[] // Destination buffer
|
|
)
|
|
{
|
|
//
|
|
ArrayResize(
|
|
buffer,
|
|
ArraySize(buffer) + 1);
|
|
|
|
//
|
|
buffer[ArraySize(buffer) - 1] = item;
|
|
}
|
|
void Add(
|
|
XSignal &item, // item want to add
|
|
XSignal &buffer[] // Destination buffer
|
|
)
|
|
{
|
|
//
|
|
ArrayResize(
|
|
buffer,
|
|
ArraySize(buffer) + 1);
|
|
|
|
//
|
|
buffer[ArraySize(buffer) - 1] = item;
|
|
}
|
|
|
|
//
|
|
// Check a Signal is Long or not ...
|
|
bool IsLong(ENUM_X_SIGNAL_TYPE type)
|
|
{
|
|
return type == X_SIGNAL_LONG;
|
|
}
|
|
bool IsLong(XSignal &signal)
|
|
{
|
|
//
|
|
bool result = IsLong(signal.type);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check a Signal is Short or not ...
|
|
bool IsShort(ENUM_X_SIGNAL_TYPE type)
|
|
{
|
|
return type == X_SIGNAL_SHORT;
|
|
}
|
|
bool IsShort(XSignal &signal)
|
|
{
|
|
//
|
|
bool result = IsShort(signal.type);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve a Signal Type String Value ...
|
|
string GetSignalType(ENUM_X_SIGNAL_TYPE type)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
if (type == X_SIGNAL_UNKNOWN)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = type == X_SIGNAL_LONG ? "Long" : "Short";
|
|
|
|
//
|
|
return result;
|
|
}
|
|
string GetSignalType(XSignal &signal)
|
|
{
|
|
//
|
|
string result = "";
|
|
|
|
//
|
|
result = GetSignalType(signal.type);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check if a Signal is Primary or not ...
|
|
bool IsPrimary(XSignal &signal)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int titlePosition = StringFind(signal.comment, "Primary");
|
|
result = titlePosition >= 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check if a Signal is Grid or not ...
|
|
bool IsGrid(XSignal &signal)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int titlePosition = StringFind(signal.comment, "Grid");
|
|
result = titlePosition >= 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Normalize a give Volume ...
|
|
double NormalizeVolume(
|
|
double volume // desired volume to normalize
|
|
) {
|
|
//
|
|
double result = volume;
|
|
|
|
//
|
|
// Normalize Volume ...
|
|
result = NormalizeDouble(result, 2);
|
|
|
|
//
|
|
double maxAvailableVolume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
|
double minAvailableVolume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
|
|
|
//
|
|
// Validate Result ...
|
|
if (result > maxAvailableVolume)
|
|
{
|
|
result = maxAvailableVolume;
|
|
}
|
|
else if (result < minAvailableVolume)
|
|
{
|
|
result = minAvailableVolume;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
double NormalizeVolume(
|
|
double volume, // desired volume to normalize
|
|
string symbol // Specified Symbol for Normalization
|
|
) {
|
|
//
|
|
double result = volume;
|
|
|
|
//
|
|
// Normalize Volume ...
|
|
result = NormalizeDouble(result, 2);
|
|
|
|
//
|
|
double maxAvailableVolume = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
|
double minAvailableVolume = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
|
|
|
//
|
|
// Validate Result ...
|
|
if (result > maxAvailableVolume)
|
|
{
|
|
result = maxAvailableVolume;
|
|
}
|
|
else if (result < minAvailableVolume)
|
|
{
|
|
result = minAvailableVolume;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
} |