2017 lines
48 KiB
Plaintext
2017 lines
48 KiB
Plaintext
///////////////////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 XEU5 Signal Provider Indicators Library
|
|
// ----------------------------------------------------------------
|
|
//
|
|
// 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
|
|
|
|
//
|
|
// Include Provider Inputs ...
|
|
#include "x-saherelm.xeu5.provider.inputs.lib.mq5";
|
|
|
|
//
|
|
// START Define Enums ...
|
|
//
|
|
|
|
//
|
|
// Represent Market Conditions ...
|
|
struct XEU5_MARKET_CONDITIONS
|
|
{
|
|
//
|
|
// XTM ...
|
|
bool isXTMPeak;
|
|
bool isXTMVale;
|
|
bool isXTMBullish;
|
|
bool isXTMBearish;
|
|
bool isXTMNeutural;
|
|
bool isXTMEndBullish;
|
|
bool isXTMEndBearish;
|
|
bool isXTMStartBullish;
|
|
bool isXTMStartBearish;
|
|
bool isXTMEndBullishByNeutural;
|
|
bool isXTMEndBearishByNeutural;
|
|
bool isXTMStartBullishAfterNeutural;
|
|
bool isXTMStartBearishAfterNeutural;
|
|
|
|
//
|
|
// XLH ...
|
|
bool isXLHHHIncreased;
|
|
bool isXLHHHDecreased;
|
|
bool isXLHLLIncreased;
|
|
bool isXLHLLDecreased;
|
|
bool isXLHLowAttachedLL;
|
|
bool isXLHHighAttachedHH;
|
|
bool isXLHHHSameInLength;
|
|
bool isXLHLLSameInLength;
|
|
bool isXLHPriceOverSignal;
|
|
bool isXLHPriceUnderSignal;
|
|
bool isXLHPriceInSignalRange;
|
|
bool isXLHPriceCrossedOverSignal;
|
|
bool isXLHPriceCrossedUnderSignal;
|
|
|
|
//
|
|
// XTD ...
|
|
bool isXTDSignalPeak;
|
|
bool isXTDSignalVale;
|
|
bool isXTDBullishPeak;
|
|
bool isXTDBullishVale;
|
|
bool isXTDBearishPeak;
|
|
bool isXTDBearishVale;
|
|
bool isXTDBullOverBear;
|
|
bool isXTDBullUnderBear;
|
|
bool isXTDSignalOverBear;
|
|
bool isXTDSignalUnderBear;
|
|
bool isXTDBullCrossedOverBear;
|
|
bool isXTDBullCrossedUnderBear;
|
|
bool isXTDSignalCrossedOverBear;
|
|
bool isXTDSignalCrossedUnderBear;
|
|
|
|
//
|
|
// XRSI ...
|
|
bool isXRSIPeak;
|
|
bool isXRSIVale;
|
|
bool isXRSICrossedOverLongExit;
|
|
bool isXRSICrossedOverLongEntry;
|
|
bool isXRSICrossedUnderShortExit;
|
|
bool isXRSICrossedUnderShortEntry;
|
|
|
|
//
|
|
// XOBD ...
|
|
bool isXOBDSwingLow;
|
|
bool isXOBDSwingHigh;
|
|
|
|
//
|
|
// XCHLH ...
|
|
//
|
|
bool isXCHLHSameHHs;
|
|
bool isXCHLHSameLLs;
|
|
//
|
|
bool isXCHLHSCMCHHSame;
|
|
bool isXCHLHSCMCLLSame;
|
|
//
|
|
bool isXCHLHSCLCHHSame;
|
|
bool isXCHLHSCLCLLSame;
|
|
//
|
|
bool isXCHLHMCLCHHSame;
|
|
bool isXCHLHMCLCLLSame;
|
|
//
|
|
bool isXCHLHMCOnTopOfLC;
|
|
bool isXCHLHMCInBottomOfLC;
|
|
|
|
//
|
|
// XCHMA ...
|
|
//
|
|
bool isXCHMASCOverMax;
|
|
bool isXCHMASCOverMin;
|
|
bool isXCHMASCUnderMax;
|
|
bool isXCHMASCUnderMin;
|
|
//
|
|
bool isXCHMASCCrossedOverMax;
|
|
bool isXCHMASCCrossedUnderMax;
|
|
bool isXCHMASCCrossedOverMin;
|
|
bool isXCHMASCCrossedUnderMin;
|
|
//
|
|
bool isXCHMASCPeak;
|
|
bool isXCHMASCVale;
|
|
bool isXCHMASCTrendsUp;
|
|
bool isXCHMASCTrendsDown;
|
|
bool isXCHMASCFastOverSlow;
|
|
bool isXCHMASCFastUnderSlow;
|
|
bool isXCHMASCFastCrossedOverSlow;
|
|
bool isXCHMASCFastCrossedUnderSlow;
|
|
//
|
|
bool isXCHMAMCPeak;
|
|
bool isXCHMAMCVale;
|
|
bool isXCHMAMCTrendsUp;
|
|
bool isXCHMAMCTrendsDown;
|
|
bool isXCHMAMCFastOverSlow;
|
|
bool isXCHMAMCFastUnderSlow;
|
|
bool isXCHMAMCFastCrossedOverSlow;
|
|
bool isXCHMAMCFastCrossedUnderSlow;
|
|
//
|
|
bool isXCHMALCPeak;
|
|
bool isXCHMALCVale;
|
|
bool isXCHMALCTrendsUp;
|
|
bool isXCHMALCTrendsDown;
|
|
bool isXCHMALCFastOverSlow;
|
|
bool isXCHMALCFastUnderSlow;
|
|
bool isXCHMALCFastCrossedOverSlow;
|
|
bool isXCHMALCFastCrossedUnderSlow;
|
|
};
|
|
|
|
//
|
|
// Signal Additional Info ...
|
|
struct XTF_SIGNAL
|
|
{
|
|
double tp;
|
|
double sl;
|
|
double riskFree;
|
|
int signalPusher;
|
|
};
|
|
|
|
//
|
|
// END Define Enums ...
|
|
//
|
|
|
|
//
|
|
// Imports all Indicators Helper here ...
|
|
input group "XEU5 Provider Indicators";
|
|
//
|
|
#include "x-saherelm.xtm.indicator.helper.lib.mq5";
|
|
#include "x-saherelm.xlh.indicator.helper.lib.mq5";
|
|
#include "x-saherelm.xtd.oscillator.helper.lib.mq5";
|
|
#include "x-saherelm.xobd.indicator.helper.lib.mq5";
|
|
#include "x-saherelm.xrsi.oscillator.helper.lib.mq5";
|
|
#include "x-saherelm.xchlh.oscillator.helper.lib.mq5";
|
|
#include "x-saherelm.xchma.oscillator.helper.lib.mq5";
|
|
|
|
//
|
|
int xEU5MaxLengthOfInputs = 0;
|
|
int xEU5CalculatedBars = 0;
|
|
|
|
//
|
|
// Here we Define some Global Market Variables to Analyse MArket Conditions
|
|
// using them at each time ...
|
|
XEU5_MARKET_CONDITIONS conditions = {};
|
|
|
|
//
|
|
datetime xCHMASCCrossedOverMaxTimes[];
|
|
datetime xCHMASCCrossedUnderMaxTimes[];
|
|
datetime xCHMASCCrossedOverMinTimes[];
|
|
datetime xCHMASCCrossedUnderMinTimes[];
|
|
|
|
//
|
|
double xCHMAScMaxTrend;
|
|
datetime xCHMAScMaxTrendTime;
|
|
datetime xCHMAScFastCrossedOverSlowTimes[];
|
|
datetime xCHMAScFastCrossedUnderSlowTimes[];
|
|
|
|
//
|
|
double xCHMAMcMaxTrend;
|
|
datetime xCHMAMcMaxTrendTime;
|
|
datetime xCHMAMcFastCrossedOverSlowTimes[];
|
|
datetime xCHMAMcFastCrossedUnderSlowTimes[];
|
|
|
|
//
|
|
double xCHMALcMaxTrend;
|
|
datetime xCHMALcMaxTrendTime;
|
|
datetime xCHMALcFastCrossedOverSlowTimes[];
|
|
datetime xCHMALcFastCrossedUnderSlowTimes[];
|
|
|
|
//
|
|
// Init Indicators ...
|
|
bool XEU5InitIndicators()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Check and Calculate Max Length in Inputs ...
|
|
//
|
|
|
|
//
|
|
// XTM ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xTMMaPeriod,
|
|
xEU5NumberOfItemsPerTick);
|
|
|
|
//
|
|
// XLH ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xLHLength,
|
|
xEU5NumberOfItemsPerTick);
|
|
|
|
//
|
|
// XTD ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xTDLength,
|
|
xEU5MaxLengthOfInputs);
|
|
|
|
//
|
|
// XRSI ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xRSILength,
|
|
xEU5MaxLengthOfInputs);
|
|
|
|
//
|
|
// XOBD ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xOBDLength,
|
|
xEU5MaxLengthOfInputs);
|
|
|
|
//
|
|
// XCHLH ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHLHLcLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHLHMcLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHLHScLength,
|
|
xEU5MaxLengthOfInputs);
|
|
|
|
//
|
|
// XCHMA ...
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMAScFastLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMAScSlowLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMAMcFastLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMAMcSlowLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMALcFastLength,
|
|
xEU5MaxLengthOfInputs);
|
|
xEU5MaxLengthOfInputs = MathMax(
|
|
xCHMALcSlowLength,
|
|
xEU5MaxLengthOfInputs);
|
|
|
|
//
|
|
// Initialize Indicator/Oscillator Handlers ...
|
|
ResetLastError();
|
|
|
|
//
|
|
// XTM Init ...
|
|
result = XTMInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XLH Init ...
|
|
result = XLHInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTD Init ...
|
|
result = XTDInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XRSI Init ...
|
|
result = XRSIInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XOBD Init ...
|
|
result = XOBDInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCLH Init ...
|
|
result = XCHLHInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMA Init ...
|
|
result = XCHMAInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Release Indicators ...
|
|
void XEU5ReleaseIndicators()
|
|
{
|
|
//
|
|
// Release Handlers ...
|
|
XTMReleaseHandlers();
|
|
XLHReleaseHandlers();
|
|
XTDReleaseHandlers();
|
|
XRSIReleaseHandlers();
|
|
XOBDReleaseHandlers();
|
|
XCHMAReleaseHandlers();
|
|
XCHLHReleaseHandlers();
|
|
}
|
|
|
|
//
|
|
// Handle Reading Buffers ...
|
|
void XEU5HandleReadingBuffers()
|
|
{
|
|
//
|
|
// Reading Calculated Bars for a Simple Handler ...
|
|
xEU5CalculatedBars = BarsCalculated(xTMHandler);
|
|
|
|
//
|
|
// Read Indicators Buffers ...
|
|
XTMReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XLHReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XTDReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XRSIReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XOBDReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XCHMAReadBuffers(xEU5NumberOfItemsPerTick);
|
|
XCHLHReadBuffers(xEU5NumberOfItemsPerTick);
|
|
|
|
//
|
|
XEU5ReadConditions();
|
|
}
|
|
|
|
//
|
|
//
|
|
// START Combination Functions ...
|
|
//
|
|
//
|
|
|
|
//
|
|
// Can Open Long Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Long Signals ...
|
|
bool XEU5CanOpenLongTrade(
|
|
XTF_SIGNAL &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool hasSignal = XEU5HasLongSignal(info);
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
// TODO: Remove this On Production ...
|
|
if (result)
|
|
{
|
|
XEU5ClearConditions();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Close Long Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Long Signals ...
|
|
bool XEU5CanCloseLongTrade()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// TODO: Check Market Conditions for Close Long Trades ...
|
|
// result = isXCHMASCFastCrossedUnderMax;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Open Short Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Short Signals ...
|
|
bool XEU5CanOpenShortTrade(
|
|
XTF_SIGNAL &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool hasSignal = XEU5HasShortSignal(info);
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
// TODO: Remove this On Production ...
|
|
if (result)
|
|
{
|
|
XEU5ClearConditions();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Close Short Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Short Signals ...
|
|
bool XEU5CanCloseShortTrade()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// TODO: Check Market Conditions for Close Short Trades ...
|
|
// result = XEU5HasShortCloseConditions(xEU5NumberOfItemsPerTick);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
// END Combination Functions ...
|
|
//
|
|
//
|
|
|
|
//
|
|
//
|
|
// START Combination Signaling ...
|
|
//
|
|
//
|
|
|
|
//
|
|
// TODO: Works i Had To Do:
|
|
//
|
|
// - [] Test All Strategies in All Available Brokers;
|
|
// - [] Find a Good Age for Closing Long Time Trades;
|
|
// - [] Find a Good Value for Closing Max DrawDown Equity Trades;
|
|
// - [] For All Strategies, Find Desired Long/Short Exit Points;
|
|
// - [] Find a Combination Point for Close All Trades;
|
|
// - [x] Try to Increase Trade Volume on Giving Multiple Signals at Same Time;
|
|
// - [] Prepare Signal and Event Alerts and Test Them for Production Environment;
|
|
// - [] Add SUpport for Daily and Hourly Alerts and also Make Report of Account State in Start Of Each Day;
|
|
// - [] Test All Methods for Find other Assets to Trade On them;
|
|
// - [] Do R&D about Multi Asset Trading in MT5;
|
|
// - [] Test Other Indicators/Oscillators or Exists Examples to Check and Found Market Conditions;
|
|
//
|
|
|
|
//
|
|
// Read All Globally Required Conditions ...
|
|
void XEU5ReadConditions()
|
|
{
|
|
//
|
|
XEU5ClearConditions();
|
|
|
|
//
|
|
// XTM ...
|
|
conditions.isXTMPeak = XTMIsPeak();
|
|
conditions.isXTMVale = XTMIsVale();
|
|
conditions.isXTMBullish = XTMIsBullish(1);
|
|
conditions.isXTMBearish = XTMIsBearish(1);
|
|
conditions.isXTMNeutural = XTMIsNeutural(1);
|
|
conditions.isXTMEndBullish = XTMIsEndBullish(1);
|
|
conditions.isXTMEndBearish = XTMIsEndBearish(1);
|
|
conditions.isXTMStartBullish = XTMIsStartBullish(1);
|
|
conditions.isXTMStartBearish = XTMIsStartBearish(1);
|
|
conditions.isXTMEndBullishByNeutural = XTMIsEndBullishByNeutural(1);
|
|
conditions.isXTMEndBearishByNeutural = XTMIsEndBearishByNeutural(1);
|
|
conditions.isXTMStartBullishAfterNeutural = XTMIsStartBullishAfterNeutural(1);
|
|
conditions.isXTMStartBearishAfterNeutural = XTMIsStartBearishAfterNeutural(1);
|
|
|
|
//
|
|
// XLH ...
|
|
conditions.isXLHHHIncreased = XLHIsHHIncreased(1);
|
|
conditions.isXLHHHDecreased = XLHIsHHDecreased(1);
|
|
conditions.isXLHLLIncreased = XLHIsLLIncreased(1);
|
|
conditions.isXLHLLDecreased = XLHIsLLDecreased(1);
|
|
conditions.isXLHLowAttachedLL = XLHIsLowAttachedLL(1);
|
|
conditions.isXLHHighAttachedHH = XLHIsHighAttachedHH(1);
|
|
conditions.isXLHHHSameInLength = XLHIsHHSameInLength(1);
|
|
conditions.isXLHLLSameInLength = XLHIsLLSameInLength(1);
|
|
conditions.isXLHPriceOverSignal = XLHIsPriceOverSignal(1);
|
|
conditions.isXLHPriceUnderSignal = XLHIsPriceUnderSignal(1);
|
|
conditions.isXLHPriceInSignalRange = XLHIsPriceInSignalRange(1);
|
|
conditions.isXLHPriceCrossedOverSignal = XLHIsPriceCrossedOverSignal(1);
|
|
conditions.isXLHPriceCrossedUnderSignal = XLHIsPriceCrossedUnderSignal(1);
|
|
|
|
//
|
|
// XTD ...
|
|
conditions.isXTDSignalPeak = XTDIsSignalPeak(1);
|
|
conditions.isXTDSignalVale = XTDIsSignalVale(1);
|
|
conditions.isXTDBullishPeak = XTDIsBullishPeak(1);
|
|
conditions.isXTDBullishVale = XTDIsBullishVale(1);
|
|
conditions.isXTDBearishPeak = XTDIsBearishPeak(1);
|
|
conditions.isXTDBearishVale = XTDIsBearishVale(1);
|
|
conditions.isXTDBullOverBear = XTDIsBullOverBear(1);
|
|
conditions.isXTDBullUnderBear = XTDIsBullUnderBear(1);
|
|
conditions.isXTDSignalOverBear = XTDIsSignalOverBear(1);
|
|
conditions.isXTDSignalUnderBear = XTDIsSignalUnderBear(1);
|
|
conditions.isXTDBullCrossedOverBear = XTDIsBullCrossedOverBear(1);
|
|
conditions.isXTDBullCrossedUnderBear = XTDIsBullCrossedUnderBear(1);
|
|
conditions.isXTDSignalCrossedOverBear = XTDIsSignalCrossedOverBear(1);
|
|
conditions.isXTDSignalCrossedUnderBear = XTDIsSignalCrossedUnderBear(1);
|
|
|
|
//
|
|
// XRSI ...
|
|
conditions.isXRSIPeak = XRSIIsPeak();
|
|
conditions.isXRSIVale = XRSIIsVale();
|
|
conditions.isXRSICrossedOverLongExit = XRSIIsCrossedOverLongExit(1);
|
|
conditions.isXRSICrossedOverLongEntry = XRSIIsCrossedOverLongEntry(1);
|
|
conditions.isXRSICrossedUnderShortExit = XRSIIsCrossedUnderShortExit(1);
|
|
conditions.isXRSICrossedUnderShortEntry = XRSIIsCrossedUnderShortEntry(1);
|
|
|
|
//
|
|
// XOBD ...
|
|
conditions.isXOBDSwingLow = XOBDIsSwingLow(1);
|
|
conditions.isXOBDSwingHigh = XOBDIsSwingHigh(1);
|
|
|
|
//
|
|
// XCHLH ...
|
|
//
|
|
conditions.isXCHLHSameHHs = XCHLHIsSameHHs(1);
|
|
conditions.isXCHLHSameLLs = XCHLHIsSameLLs(1);
|
|
//
|
|
conditions.isXCHLHSCMCHHSame = XCHLHIsMCSCHasSameHH(1);
|
|
conditions.isXCHLHSCMCLLSame = XCHLHIsMCSCHasSameLL(1);
|
|
//
|
|
conditions.isXCHLHSCLCHHSame = XCHLHIsLCSCHasSameHH(1);
|
|
conditions.isXCHLHSCLCLLSame = XCHLHIsLCSCHasSameLL(1);
|
|
//
|
|
conditions.isXCHLHMCLCHHSame = XCHLHIsLCMCHasSameHH(1);
|
|
conditions.isXCHLHMCLCLLSame = XCHLHIsLCMCHasSameLL(1);
|
|
//
|
|
conditions.isXCHLHMCOnTopOfLC = XCHLHIsMCOnTopOfLC(1);
|
|
conditions.isXCHLHMCInBottomOfLC = XCHLHIsMCInBottomOfLC(1);
|
|
|
|
//
|
|
// XCHMA ...
|
|
//
|
|
conditions.isXCHMASCOverMax = XCHMAIsSCOverMax(1);
|
|
conditions.isXCHMASCOverMin = XCHMAIsSCOverMin(1);
|
|
conditions.isXCHMASCUnderMax = XCHMAIsSCUnderMax(1);
|
|
conditions.isXCHMASCUnderMin = XCHMAIsSCUnderMin(1);
|
|
//
|
|
conditions.isXCHMASCCrossedOverMax = XCHMAIsSCCrossedOverMax(1);
|
|
conditions.isXCHMASCCrossedUnderMax = XCHMAIsSCCrossedUnderMax(1);
|
|
conditions.isXCHMASCCrossedOverMin = XCHMAIsSCCrossedOverMin(1);
|
|
conditions.isXCHMASCCrossedUnderMin = XCHMAIsSCCrossedUnderMin(1);
|
|
//
|
|
conditions.isXCHMASCPeak = XCHMAIsSCPeak(1);
|
|
conditions.isXCHMASCVale = XCHMAIsSCVale(1);
|
|
conditions.isXCHMASCTrendsUp = XCHMAIsSCTrendsUp(1);
|
|
conditions.isXCHMASCTrendsDown = XCHMAIsSCTrendsDown(1);
|
|
conditions.isXCHMASCFastOverSlow = XCHMAIsSCFastOverSlow(1);
|
|
conditions.isXCHMASCFastUnderSlow = XCHMAIsSCFastUnderSlow(1);
|
|
conditions.isXCHMASCFastCrossedOverSlow = XCHMAIsSCFastCrossedOverSlow(1);
|
|
conditions.isXCHMASCFastCrossedUnderSlow = XCHMAIsSCFastCrossedUnderSlow(1);
|
|
//
|
|
conditions.isXCHMAMCPeak = XCHMAIsMCPeak(1);
|
|
conditions.isXCHMAMCVale = XCHMAIsMCVale(1);
|
|
conditions.isXCHMAMCTrendsUp = XCHMAIsMCTrendsUp(1);
|
|
conditions.isXCHMAMCTrendsDown = XCHMAIsMCTrendsDown(1);
|
|
conditions.isXCHMAMCFastOverSlow = XCHMAIsMCFastOverSlow(1);
|
|
conditions.isXCHMAMCFastUnderSlow = XCHMAIsMCFastUnderSlow(1);
|
|
conditions.isXCHMAMCFastCrossedOverSlow = XCHMAIsMCFastCrossedOverSlow(1);
|
|
conditions.isXCHMAMCFastCrossedUnderSlow = XCHMAIsMCFastCrossedUnderSlow(1);
|
|
//
|
|
conditions.isXCHMALCPeak = XCHMAIsLCPeak(1);
|
|
conditions.isXCHMALCVale = XCHMAIsLCVale(1);
|
|
conditions.isXCHMALCTrendsUp = XCHMAIsLCTrendsUp(1);
|
|
conditions.isXCHMALCTrendsDown = XCHMAIsLCTrendsDown(1);
|
|
conditions.isXCHMALCFastOverSlow = XCHMAIsLCFastOverSlow(1);
|
|
conditions.isXCHMALCFastUnderSlow = XCHMAIsLCFastUnderSlow(1);
|
|
conditions.isXCHMALCFastCrossedOverSlow = XCHMAIsLCFastCrossedOverSlow(1);
|
|
conditions.isXCHMALCFastCrossedUnderSlow = XCHMAIsLCFastCrossedUnderSlow(1);
|
|
|
|
//
|
|
datetime time = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
1);
|
|
|
|
//
|
|
// START XCHMA Calculations ...
|
|
//
|
|
|
|
//
|
|
if (conditions.isXCHMASCCrossedOverMax)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMASCCrossedOverMaxTimes);
|
|
}
|
|
|
|
//
|
|
if (conditions.isXCHMASCCrossedUnderMax)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMASCCrossedUnderMaxTimes);
|
|
}
|
|
|
|
//
|
|
if (conditions.isXCHMASCCrossedOverMin)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMASCCrossedOverMinTimes);
|
|
}
|
|
|
|
//
|
|
if (conditions.isXCHMASCCrossedUnderMin)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMASCCrossedUnderMinTimes);
|
|
}
|
|
|
|
//
|
|
if (conditions.isXCHMASCFastCrossedOverSlow)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMAScFastCrossedOverSlowTimes);
|
|
}
|
|
|
|
//
|
|
if (conditions.isXCHMASCFastCrossedUnderSlow)
|
|
{
|
|
//
|
|
Add(
|
|
time,
|
|
xCHMAScFastCrossedUnderSlowTimes);
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMASCFastCrossedOverSlow ||
|
|
conditions.isXCHMASCFastCrossedUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
xCHMAScMaxTrendTime = time;
|
|
xCHMAScMaxTrend = XCHMAGetSCTrendPower(1);
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMASCFastOverSlow ||
|
|
conditions.isXCHMASCFastUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
double trendPower = XCHMAGetSCTrendPower(1);
|
|
if (trendPower > xCHMAScMaxTrend)
|
|
{
|
|
//
|
|
xCHMAScMaxTrend = trendPower;
|
|
xCHMAScMaxTrendTime = time;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMAMCFastCrossedOverSlow ||
|
|
conditions.isXCHMAMCFastCrossedUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
xCHMAMcMaxTrendTime = time;
|
|
xCHMAMcMaxTrend = XCHMAGetMCTrendPower(1);
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMAMCFastOverSlow ||
|
|
conditions.isXCHMAMCFastUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
double trendPower = XCHMAGetMCTrendPower(1);
|
|
if (trendPower > xCHMAMcMaxTrend)
|
|
{
|
|
//
|
|
xCHMAMcMaxTrend = trendPower;
|
|
xCHMAMcMaxTrendTime = time;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMALCFastCrossedOverSlow ||
|
|
conditions.isXCHMALCFastCrossedUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
xCHMALcMaxTrendTime = time;
|
|
xCHMALcMaxTrend = XCHMAGetLCTrendPower(1);
|
|
}
|
|
|
|
//
|
|
if (
|
|
//
|
|
conditions.isXCHMALCFastOverSlow ||
|
|
conditions.isXCHMALCFastUnderSlow
|
|
//
|
|
)
|
|
{
|
|
//
|
|
double trendPower = XCHMAGetLCTrendPower(1);
|
|
if (trendPower > xCHMALcMaxTrend)
|
|
{
|
|
//
|
|
xCHMALcMaxTrend = trendPower;
|
|
xCHMALcMaxTrendTime = time;
|
|
}
|
|
}
|
|
|
|
//
|
|
// END XCHMA Calculations ...
|
|
//
|
|
}
|
|
|
|
//
|
|
// Cleanup Conditions ...
|
|
void XEU5ClearConditions()
|
|
{
|
|
//
|
|
XEU5_MARKET_CONDITIONS mConditions = {};
|
|
|
|
//
|
|
conditions = mConditions;
|
|
}
|
|
|
|
//
|
|
// Converts Market Conditions to Specific String Representation ...
|
|
string XEU5GetConditionsString(
|
|
string separator = ",", // Specify Separator
|
|
bool ignoreFalses = true // Ignore False Conditions
|
|
)
|
|
{
|
|
//
|
|
string result = "\n";
|
|
|
|
//
|
|
// XOBD ...
|
|
result +=
|
|
"| XOBD |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXOBDSwingLow))
|
|
{
|
|
result += "isXOBDSwingLow: " + (string)conditions.isXOBDSwingLow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXOBDSwingHigh))
|
|
{
|
|
result += "isXOBDSwingHigh: " + (string)conditions.isXOBDSwingHigh + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XTM ...
|
|
result +=
|
|
"| XTM |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMPeak))
|
|
{
|
|
result += "isXTMPeak: " + (string)conditions.isXTMPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMVale))
|
|
{
|
|
result += "isXTMVale: " + (string)conditions.isXTMVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMStartBullish))
|
|
{
|
|
result += "isXTMStartBullish: " + (string)conditions.isXTMStartBullish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMStartBullishAfterNeutural))
|
|
{
|
|
result += "isXTMStartBullishAfterNeutural: " + (string)conditions.isXTMStartBullishAfterNeutural + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMBullish))
|
|
{
|
|
result += "isXTMBullish: " + (string)conditions.isXTMBullish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMEndBullish))
|
|
{
|
|
result += "isXTMEndBullish: " + (string)conditions.isXTMEndBullish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMEndBullishByNeutural))
|
|
{
|
|
result += "isXTMEndBullishByNeutural: " + (string)conditions.isXTMEndBullishByNeutural + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMStartBearish))
|
|
{
|
|
result += "isXTMStartBearish: " + (string)conditions.isXTMStartBearish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMStartBearishAfterNeutural))
|
|
{
|
|
result += "isXTMStartBearishAfterNeutural: " + (string)conditions.isXTMStartBearishAfterNeutural + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMBearish))
|
|
{
|
|
result += "isXTMBearish: " + (string)conditions.isXTMBearish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMEndBearish))
|
|
{
|
|
result += "isXTMEndBearish: " + (string)conditions.isXTMEndBearish + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMEndBearishByNeutural))
|
|
{
|
|
result += "isXTMEndBearishByNeutural: " + (string)conditions.isXTMEndBearishByNeutural + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTMNeutural))
|
|
{
|
|
result += "isXTMNeutural: " + (string)conditions.isXTMNeutural + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XTD ...
|
|
result +=
|
|
"| XTD |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalPeak))
|
|
{
|
|
result += "isXTDSignalPeak: " + (string)conditions.isXTDSignalPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalVale))
|
|
{
|
|
result += "isXTDSignalVale: " + (string)conditions.isXTDSignalVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullishPeak))
|
|
{
|
|
result += "isXTDBullishPeak: " + (string)conditions.isXTDBullishPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullishVale))
|
|
{
|
|
result += "isXTDBullishVale: " + (string)conditions.isXTDBullishVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBearishPeak))
|
|
{
|
|
result += "isXTDBearishPeak: " + (string)conditions.isXTDBearishPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBearishVale))
|
|
{
|
|
result += "isXTDBearishVale: " + (string)conditions.isXTDBearishVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullOverBear))
|
|
{
|
|
result += "isXTDBullOverBear: " + (string)conditions.isXTDBullOverBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullUnderBear))
|
|
{
|
|
result += "isXTDBullUnderBear: " + (string)conditions.isXTDBullUnderBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalOverBear))
|
|
{
|
|
result += "isXTDSignalOverBear: " + (string)conditions.isXTDSignalOverBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalUnderBear))
|
|
{
|
|
result += "isXTDSignalUnderBear: " + (string)conditions.isXTDSignalUnderBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullCrossedOverBear))
|
|
{
|
|
result += "isXTDBullCrossedOverBear: " + (string)conditions.isXTDBullCrossedOverBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDBullCrossedUnderBear))
|
|
{
|
|
result += "isXTDBullCrossedUnderBear: " + (string)conditions.isXTDBullCrossedUnderBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalCrossedOverBear))
|
|
{
|
|
result += "isXTDSignalCrossedOverBear: " + (string)conditions.isXTDSignalCrossedOverBear + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXTDSignalCrossedUnderBear))
|
|
{
|
|
result += "isXTDSignalCrossedUnderBear: " + (string)conditions.isXTDSignalCrossedUnderBear + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XLH ...
|
|
result +=
|
|
"| XLH |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHHHIncreased))
|
|
{
|
|
result += "isXLHHHIncreased: " + (string)conditions.isXLHHHIncreased + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHHHDecreased))
|
|
{
|
|
result += "isXLHHHDecreased: " + (string)conditions.isXLHHHDecreased + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHLLIncreased))
|
|
{
|
|
result += "isXLHLLIncreased: " + (string)conditions.isXLHLLIncreased + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHLLDecreased))
|
|
{
|
|
result += "isXLHLLDecreased: " + (string)conditions.isXLHLLDecreased + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHHighAttachedHH))
|
|
{
|
|
result += "isXLHHighAttachedHH: " + (string)conditions.isXLHHighAttachedHH + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHLowAttachedLL))
|
|
{
|
|
result += "isXLHLowAttachedLL: " + (string)conditions.isXLHLowAttachedLL + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHHHSameInLength))
|
|
{
|
|
result += "isXLHHHSameInLength: " + (string)conditions.isXLHHHSameInLength + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHLLSameInLength))
|
|
{
|
|
result += "isXLHLLSameInLength: " + (string)conditions.isXLHLLSameInLength + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHPriceCrossedOverSignal))
|
|
{
|
|
result += "isXLHPriceCrossedOverSignal: " + (string)conditions.isXLHPriceCrossedOverSignal + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHPriceOverSignal))
|
|
{
|
|
result += "isXLHPriceOverSignal: " + (string)conditions.isXLHPriceOverSignal + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHPriceCrossedUnderSignal))
|
|
{
|
|
result += "isXLHPriceCrossedUnderSignal: " + (string)conditions.isXLHPriceCrossedUnderSignal + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHPriceUnderSignal))
|
|
{
|
|
result += "isXLHPriceUnderSignal: " + (string)conditions.isXLHPriceUnderSignal + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXLHPriceInSignalRange))
|
|
{
|
|
result += "isXLHPriceInSignalRange: " + (string)conditions.isXLHPriceInSignalRange + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XRSI ...
|
|
result +=
|
|
"| XRSI |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSIPeak))
|
|
{
|
|
result += "isXRSIPeak: " + (string)conditions.isXRSIPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSIVale))
|
|
{
|
|
result += "isXRSIVale: " + (string)conditions.isXRSIVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSICrossedOverLongExit))
|
|
{
|
|
result += "isXRSICrossedOverLongExit: " + (string)conditions.isXRSICrossedOverLongExit + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSICrossedOverLongEntry))
|
|
{
|
|
result += "isXRSICrossedOverLongEntry: " + (string)conditions.isXRSICrossedOverLongEntry + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSICrossedUnderShortExit))
|
|
{
|
|
result += "isXRSICrossedUnderShortExit: " + (string)conditions.isXRSICrossedUnderShortExit + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXRSICrossedUnderShortEntry))
|
|
{
|
|
result += "isXRSICrossedUnderShortEntry: " + (string)conditions.isXRSICrossedUnderShortEntry + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XCHLH ...
|
|
result +=
|
|
"| XCHLH |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSameHHs))
|
|
{
|
|
result += "isXCHLHSameHHs: " + (string)conditions.isXCHLHSameHHs + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSameLLs))
|
|
{
|
|
result += "isXCHLHSameLLs: " + (string)conditions.isXCHLHSameLLs + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSCMCHHSame))
|
|
{
|
|
result += "isXCHLHSCMCHHSame: " + (string)conditions.isXCHLHSCMCHHSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSCMCLLSame))
|
|
{
|
|
result += "isXCHLHSCMCLLSame: " + (string)conditions.isXCHLHSCMCLLSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSCLCHHSame))
|
|
{
|
|
result += "isXCHLHSCLCHHSame: " + (string)conditions.isXCHLHSCLCHHSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHSCLCLLSame))
|
|
{
|
|
result += "isXCHLHSCLCLLSame: " + (string)conditions.isXCHLHSCLCLLSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHMCLCHHSame))
|
|
{
|
|
result += "isXCHLHMCLCHHSame: " + (string)conditions.isXCHLHMCLCHHSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHMCLCLLSame))
|
|
{
|
|
result += "isXCHLHMCLCLLSame: " + (string)conditions.isXCHLHMCLCLLSame + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHMCOnTopOfLC))
|
|
{
|
|
result += "isXCHLHMCOnTopOfLC: " + (string)conditions.isXCHLHMCOnTopOfLC + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHLHMCInBottomOfLC))
|
|
{
|
|
result += "isXCHLHMCInBottomOfLC: " + (string)conditions.isXCHLHMCInBottomOfLC + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
// XCHMA ...
|
|
result +=
|
|
"| XCHMA |" + separator;
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCOverMax))
|
|
{
|
|
result += "isXCHMASCOverMax: " + (string)conditions.isXCHMASCOverMax + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCOverMin))
|
|
{
|
|
result += "isXCHMASCOverMin: " + (string)conditions.isXCHMASCOverMin + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCUnderMax))
|
|
{
|
|
result += "isXCHMASCUnderMax: " + (string)conditions.isXCHMASCUnderMax + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCUnderMin))
|
|
{
|
|
result += "isXCHMASCUnderMin: " + (string)conditions.isXCHMASCUnderMin + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCCrossedOverMax))
|
|
{
|
|
result += "isXCHMASCCrossedOverMax: " + (string)conditions.isXCHMASCCrossedOverMax + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCCrossedUnderMax))
|
|
{
|
|
result += "isXCHMASCCrossedUnderMax: " + (string)conditions.isXCHMASCCrossedUnderMax + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCCrossedOverMin))
|
|
{
|
|
result += "isXCHMASCCrossedOverMin: " + (string)conditions.isXCHMASCCrossedOverMin + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCCrossedUnderMin))
|
|
{
|
|
result += "isXCHMASCCrossedUnderMin: " + (string)conditions.isXCHMASCCrossedUnderMin + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCPeak))
|
|
{
|
|
result += "isXCHMASCPeak: " + (string)conditions.isXCHMASCPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCVale))
|
|
{
|
|
result += "isXCHMASCVale: " + (string)conditions.isXCHMASCVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCTrendsUp))
|
|
{
|
|
result += "isXCHMASCTrendsUp: " + (string)conditions.isXCHMASCTrendsUp + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCTrendsDown))
|
|
{
|
|
result += "isXCHMASCTrendsDown: " + (string)conditions.isXCHMASCTrendsDown + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCFastOverSlow))
|
|
{
|
|
result += "isXCHMASCFastOverSlow: " + (string)conditions.isXCHMASCFastOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCFastUnderSlow))
|
|
{
|
|
result += "isXCHMASCFastUnderSlow: " + (string)conditions.isXCHMASCFastUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCFastCrossedOverSlow))
|
|
{
|
|
result += "isXCHMASCFastCrossedOverSlow: " + (string)conditions.isXCHMASCFastCrossedOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMASCFastCrossedUnderSlow))
|
|
{
|
|
result += "isXCHMASCFastCrossedUnderSlow: " + (string)conditions.isXCHMASCFastCrossedUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCPeak))
|
|
{
|
|
result += "isXCHMAMCPeak: " + (string)conditions.isXCHMAMCPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCVale))
|
|
{
|
|
result += "isXCHMAMCVale: " + (string)conditions.isXCHMAMCVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCTrendsUp))
|
|
{
|
|
result += "isXCHMAMCTrendsUp: " + (string)conditions.isXCHMAMCTrendsUp + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCTrendsDown))
|
|
{
|
|
result += "isXCHMAMCTrendsDown: " + (string)conditions.isXCHMAMCTrendsDown + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCFastOverSlow))
|
|
{
|
|
result += "isXCHMAMCFastOverSlow: " + (string)conditions.isXCHMAMCFastOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCFastUnderSlow))
|
|
{
|
|
result += "isXCHMAMCFastUnderSlow: " + (string)conditions.isXCHMAMCFastUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCFastCrossedOverSlow))
|
|
{
|
|
result += "isXCHMAMCFastCrossedOverSlow: " + (string)conditions.isXCHMAMCFastCrossedOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMAMCFastCrossedUnderSlow))
|
|
{
|
|
result += "isXCHMAMCFastCrossedUnderSlow: " + (string)conditions.isXCHMAMCFastCrossedUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCPeak))
|
|
{
|
|
result += "isXCHMALCPeak: " + (string)conditions.isXCHMALCPeak + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCVale))
|
|
{
|
|
result += "isXCHMALCVale: " + (string)conditions.isXCHMALCVale + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCTrendsUp))
|
|
{
|
|
result += "isXCHMALCTrendsUp: " + (string)conditions.isXCHMALCTrendsUp + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCTrendsDown))
|
|
{
|
|
result += "isXCHMALCTrendsDown: " + (string)conditions.isXCHMALCTrendsDown + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCFastOverSlow))
|
|
{
|
|
result += "isXCHMALCFastOverSlow: " + (string)conditions.isXCHMALCFastOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCFastUnderSlow))
|
|
{
|
|
result += "isXCHMALCFastUnderSlow: " + (string)conditions.isXCHMALCFastUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCFastCrossedOverSlow))
|
|
{
|
|
result += "isXCHMALCFastCrossedOverSlow: " + (string)conditions.isXCHMALCFastCrossedOverSlow + separator;
|
|
}
|
|
|
|
//
|
|
if (
|
|
!ignoreFalses ||
|
|
(ignoreFalses && conditions.isXCHMALCFastCrossedUnderSlow))
|
|
{
|
|
result += "isXCHMALCFastCrossedUnderSlow: " + (string)conditions.isXCHMALCFastCrossedUnderSlow + separator;
|
|
}
|
|
|
|
//
|
|
// Separator ...
|
|
result += separator;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Market Conditions by Combination of Power of All tools for LONGs ...
|
|
bool XEU5HasLongSignal(
|
|
XTF_SIGNAL &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// START Custom Mechanism ...
|
|
//
|
|
|
|
//
|
|
// Required Data ...
|
|
double entry = GetEntry(X_SIGNAL_LONG);
|
|
double nearHH = GetHighestHigh(3, 1);
|
|
double nearLL = GetLowestLow(3, 1);
|
|
XOHCL candle1 = GetCandle(1);
|
|
|
|
//
|
|
bool isSharpChanged = IsSharpChanged(
|
|
5,
|
|
1,
|
|
xTMMaBuffer);
|
|
|
|
//
|
|
bool isCandleSharpChanged = IsSharpChanged(
|
|
5,
|
|
1,
|
|
PRICE_CLOSE);
|
|
|
|
//
|
|
// Condition 1 ...
|
|
// this Method waits for XCHMA Short Cycle's Fast to Going down
|
|
// of all Cycles Minimum Value, then Check when its Crossed Over
|
|
// min value and then start to Open Long Trades based On Conditions,
|
|
// and Recieved Verifications from other Indicator/Oscillator(s) ...
|
|
bool customMethodCond1 =
|
|
//
|
|
// Selecet Swing Low as base ...
|
|
conditions.isXOBDSwingLow
|
|
//
|
|
&&
|
|
//
|
|
conditions.isXLHLowAttachedLL
|
|
//
|
|
&&
|
|
//
|
|
entry < nearHH
|
|
//
|
|
&&
|
|
//
|
|
!isCandleSharpChanged
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
conditions.isXCHMASCOverMin &&
|
|
conditions.isXCHMASCUnderMin
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Methods ...
|
|
if (customMethodCond1)
|
|
{
|
|
info.signalPusher++;
|
|
}
|
|
|
|
//
|
|
// Condition 2 ...
|
|
// this Method waits for XCHMA Medium Cycles Fast Line Crossed Over Slow,
|
|
// then start to Open Long Trades based On Conditions, and Recieved Verifications from
|
|
// other Indicator/Oscillator(s) ...
|
|
bool customMethodCond2 =
|
|
//
|
|
entry < nearHH
|
|
//
|
|
&&
|
|
//
|
|
!isCandleSharpChanged
|
|
//
|
|
&&
|
|
//
|
|
!conditions.isXOBDSwingHigh
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
(
|
|
//
|
|
xCHMAScFastBuffer[1] > xCHMAScSlowBuffer[1] &&
|
|
xCHMAMcFastBuffer[1] > xCHMAMcSlowBuffer[1] &&
|
|
xCHMALcFastBuffer[1] > xCHMALcSlowBuffer[1]
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
xCHMAScFastBuffer[2] > xCHMAScSlowBuffer[2] &&
|
|
xCHMAMcFastBuffer[2] > xCHMAMcSlowBuffer[2] &&
|
|
xCHMALcFastBuffer[2] > xCHMALcSlowBuffer[2]
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHMAMCPeak &&
|
|
conditions.isXCHMALCPeak &&
|
|
conditions.isXCHLHMCOnTopOfLC &&
|
|
conditions.isXLHHHSameInLength &&
|
|
conditions.isXCHMAMCFastOverSlow
|
|
? !conditions.isXCHMAMCTrendsDown
|
|
: true
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHLHSameHHs
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHLHMCLCHHSame &&
|
|
conditions.isXLHHHSameInLength &&
|
|
conditions.isXLHLLSameInLength
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
conditions.isXLHPriceOverSignal
|
|
//
|
|
&&
|
|
//
|
|
conditions.isXCHLHMCOnTopOfLC
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHMAMCPeak &&
|
|
conditions.isXCHMALCPeak &&
|
|
conditions.isXCHMASCFastCrossedOverSlow
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHMASCPeak &&
|
|
conditions.isXCHMAMCPeak &&
|
|
conditions.isXCHMALCPeak
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHLHMCOnTopOfLC
|
|
//
|
|
?
|
|
//
|
|
!(
|
|
//
|
|
conditions.isXLHLLSameInLength &&
|
|
!conditions.isXLHHHSameInLength
|
|
//
|
|
)
|
|
//
|
|
:
|
|
//
|
|
true
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
conditions.isXCHMAMCPeak &&
|
|
conditions.isXCHMALCPeak &&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXTDBullOverBear &&
|
|
(
|
|
//
|
|
conditions.isXTDSignalOverBear ||
|
|
conditions.isXTDSignalUnderBear
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
conditions.isXCHLHMCOnTopOfLC &&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXLHHHSameInLength
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
conditions.isXLHHHSameInLength &&
|
|
conditions.isXLHLLSameInLength
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXLHPriceOverSignal ||
|
|
conditions.isXLHPriceInSignalRange
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Methods ...
|
|
if (customMethodCond2)
|
|
{
|
|
info.signalPusher++;
|
|
}
|
|
|
|
//
|
|
// Condition 3 ...
|
|
// this Method waits for XCHMA Short Cycle's Fast to Crossed Over all Cycles max value
|
|
// and then start to Open Long Trades based On Conditions,
|
|
// and Recieved Verifications from other Indicator/Oscillator(s) ...
|
|
bool customMethodCond3 =
|
|
//
|
|
conditions.isXCHMASCCrossedOverMin &&
|
|
!conditions.isXCHMASCUnderMin
|
|
//
|
|
&&
|
|
//
|
|
!conditions.isXCHMAMCFastUnderSlow
|
|
//
|
|
&&
|
|
//
|
|
(
|
|
//
|
|
conditions.isXCHMALCFastUnderSlow ? XCHMAGetCycleMaxValue(1, X_XCHMA_CYCLE_MEDIUM) > xCHMALcFastBuffer[1] : true
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
conditions.isXCHLHSameHHs &&
|
|
conditions.isXLHHighAttachedHH &&
|
|
conditions.isXLHLLSameInLength &&
|
|
conditions.isXLHPriceInSignalRange &&
|
|
conditions.isXCHMASCCrossedOverMax &&
|
|
conditions.isXCHMASCCrossedOverMin
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
!(
|
|
//
|
|
conditions.isXLHLLDecreased &&
|
|
conditions.isXCHLHMCLCHHSame &&
|
|
conditions.isXCHLHMCOnTopOfLC &&
|
|
conditions.isXLHHHSameInLength &&
|
|
conditions.isXLHLLSameInLength &&
|
|
conditions.isXLHPriceInSignalRange
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Methods ...
|
|
if (customMethodCond3)
|
|
{
|
|
info.signalPusher++;
|
|
}
|
|
|
|
//
|
|
// Combine Custom Methods together ...
|
|
bool isCustomMethodHasSignal =
|
|
//
|
|
customMethodCond1
|
|
//
|
|
||
|
|
//
|
|
customMethodCond2
|
|
//
|
|
||
|
|
//
|
|
customMethodCond3
|
|
//
|
|
;
|
|
|
|
//
|
|
// END Custom Mechanism ...
|
|
//
|
|
|
|
//
|
|
result =
|
|
//
|
|
isCustomMethodHasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
// TODO: Remove This for Production ...
|
|
string msg = XEU5GetConditionsString("\n");
|
|
LogMessage(msg);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Market Conditions by Combination of Power of All tools for SHORTs ...
|
|
bool XEU5HasShortSignal(
|
|
XTF_SIGNAL &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Fill Result ...
|
|
result =
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
// Set Number of Occured Conditions for Increasing Volume ...
|
|
// providedSignals = ArraySize(methods);
|
|
|
|
//
|
|
// TODO: Remove This for Production ...
|
|
string msg = XEU5GetConditionsString("\n");
|
|
LogMessage(msg);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
// END Combination Signaling ...
|
|
//
|
|
//
|