1075 lines
25 KiB
Plaintext
1075 lines
25 KiB
Plaintext
//
|
|
// Get Price Verification for Long ...
|
|
isPriceVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& isHHVerified
|
|
&& signal.entry < hh
|
|
&& !isBigSharpOccured
|
|
&& signal.entry < candle0.high
|
|
&& MathAbs(signal.entry - hh) > 50 * _Point
|
|
;
|
|
|
|
//
|
|
isTPowVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& tPow.signal < MathMax(tPow.powerUp, tPow.powerDown)
|
|
;
|
|
|
|
//
|
|
isPSarVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& state0.psar < signal.entry
|
|
;
|
|
|
|
//
|
|
// bool isLastFastCrossSlowVerified =
|
|
// lastFastCrossOverSlowTime > 0
|
|
// && lastFastCrossUnderSlowTime > 0
|
|
// ?
|
|
// MathAbs(GetLastFastCrossOverSlowBarIndex() - GetLastFastCrossUnderSlowBarIndex()) > (xTPWSwingLength * 2)
|
|
// :
|
|
// false
|
|
// ;
|
|
|
|
//
|
|
isStateVerified =
|
|
//
|
|
// Start ...
|
|
true
|
|
//
|
|
// && state0.fast > state1.fast
|
|
// && state1.fast > state2.fast
|
|
//
|
|
// && state0.rangeFast > state0.rangeSlow
|
|
// && state1.rangeFast > state1.rangeSlow
|
|
// //
|
|
// && state0.rangeWeight > state0.verifier
|
|
// && state1.rangeWeight > state1.verifier
|
|
// //
|
|
// && state0.verifier < state0.rangeSlow
|
|
// && state1.verifier < state1.rangeSlow
|
|
//
|
|
&& MathAbs(state0.range - state0.rangeWeight) > 50 * _Point
|
|
//
|
|
&& MathAbs(state0.verifier - state0.rangeWeight) > 50 * _Point
|
|
//
|
|
// && (
|
|
// lastRangeCrossOverRangeWeightTime > 0
|
|
// && lastRangeCrossUnderRangeWeightTime > 0
|
|
// ?
|
|
// //
|
|
// MathMin(
|
|
// GetLastRangeCrossOverRangeWeightBarIndex(),
|
|
// GetLastRangeCrossUnderRangeWeightBarIndex()
|
|
// ) - signalBarIndex > xTPWSwingLength
|
|
// :
|
|
// //
|
|
// false
|
|
// )
|
|
//
|
|
// && (
|
|
// state0.range < state0.verifier
|
|
// ?
|
|
// //
|
|
// false
|
|
// :
|
|
// //
|
|
// (
|
|
// state0.rangeWeight > state0.range
|
|
// ?
|
|
// //
|
|
// MathAbs(state0.rangeWeight - state0.range) <= MathAbs(state0.range - state0.verifier)
|
|
// :
|
|
// //
|
|
// MathAbs(state0.rangeWeight - state0.range) <= MathAbs(state0.range - state0.verifier)
|
|
// )
|
|
// )
|
|
//
|
|
// // && isLastFastCrossSlowVerified
|
|
// && !(
|
|
// ll < llState.verifier
|
|
// && hh > state0.verifier
|
|
// )
|
|
;
|
|
|
|
|
|
// //
|
|
// datetime lastPriceOverVerifierTime;
|
|
// datetime lastFastCrossOverSlowTime;
|
|
// datetime lastPriceUnderVerifierTime;
|
|
// datetime lastPriceTouchVerifierTime;
|
|
// datetime lastFastCrossUnderSlowTime;
|
|
// datetime lastRangeCrossOverVerifierTime;
|
|
// datetime lastRangeCrossUnderVerifierTime;
|
|
// datetime lastRangeCrossOverRangeWeightTime;
|
|
// datetime lastRangeCrossUnderRangeWeightTime;
|
|
// datetime lastRangeWeightCrossOverVerifierTime;
|
|
// datetime lastRangeWeightCrossUnderVerifierTime;
|
|
|
|
// //
|
|
// datetime lastTPowAboveMaxVerifierTime;
|
|
|
|
// //
|
|
// // Find Crosses between fast and slow ...
|
|
|
|
// //
|
|
// bool isFastCrossOverSlow =
|
|
// state1.fast > state1.slow
|
|
// && !(state2.fast > state2.slow)
|
|
// ;
|
|
// if (isFastCrossOverSlow) {
|
|
// lastFastCrossOverSlowTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isFastCrossUnderSlow =
|
|
// state1.fast < state1.slow
|
|
// && !(state2.fast < state2.slow)
|
|
// ;
|
|
// if (isFastCrossUnderSlow) {
|
|
// lastFastCrossUnderSlowTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// // Find Range and Verifier Cross ...
|
|
|
|
// //
|
|
// bool isRangeCrossOverVerifier =
|
|
// state1.range > state1.verifier
|
|
// && !(state2.range > state2.verifier)
|
|
// ;
|
|
// if (isRangeCrossOverVerifier) {
|
|
// lastRangeCrossOverVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isRangeCrossUnderVerifier =
|
|
// state1.range < state1.verifier
|
|
// && !(state2.range < state2.verifier)
|
|
// ;
|
|
// if (isRangeCrossUnderVerifier) {
|
|
// lastRangeCrossUnderVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// // Find Crosses between range and rangeWeight ...
|
|
|
|
// //
|
|
// bool isRangeCrossOverRangeWeight =
|
|
// state1.range > state1.rangeWeight
|
|
// && !(state2.range > state2.rangeWeight)
|
|
// ;
|
|
// if (isRangeCrossOverRangeWeight) {
|
|
// lastRangeCrossOverRangeWeightTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isRangeCrossUnderRangeWeight =
|
|
// state1.range < state1.rangeWeight
|
|
// && !(state2.range < state2.rangeWeight)
|
|
// ;
|
|
// if (isRangeCrossUnderRangeWeight) {
|
|
// lastRangeCrossUnderRangeWeightTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// // Find RangeWeight and Verifier Cross ...
|
|
|
|
// //
|
|
// bool isRangeWehigthCrossOverVerifier =
|
|
// state1.rangeWeight > state1.verifier
|
|
// && !(state2.rangeWeight > state2.verifier)
|
|
// ;
|
|
// if (isRangeWehigthCrossOverVerifier) {
|
|
// lastRangeWeightCrossOverVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isRangeWeightCrossUnderVerifier =
|
|
// state1.rangeWeight < state1.verifier
|
|
// && !(state2.rangeWeight < state2.verifier)
|
|
// ;
|
|
// if (isRangeWeightCrossUnderVerifier) {
|
|
// lastRangeWeightCrossUnderVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// // Find Price Crosses by Verifier ...
|
|
|
|
// //
|
|
// bool isPriceOverVerifier =
|
|
// candle1.low > state1.verifier
|
|
// && !(candle2.low > state1.verifier)
|
|
// ;
|
|
// if (isPriceOverVerifier) {
|
|
// lastPriceOverVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isPriceUnderVerifier =
|
|
// candle1.high < state1.verifier
|
|
// && !(candle2.high < state1.verifier)
|
|
// ;
|
|
// if (isPriceUnderVerifier) {
|
|
// lastPriceUnderVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isPriceTouchVerifier =
|
|
// isPriceOverVerifier
|
|
// || isPriceUnderVerifier
|
|
// ;
|
|
|
|
// //
|
|
// if (isPriceTouchVerifier) {
|
|
// lastPriceTouchVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// bool isTPowUpperBelowMaxVerifier = MathMax(tPow1.powerUp, tPow1.powerDown) < tPowerMaxVerifier;
|
|
// bool isTPowUpperAboveMaxVerifier = MathMax(tPow1.powerUp, tPow1.powerDown) > tPowerMaxVerifier;
|
|
// if (isTPowUpperAboveMaxVerifier) {
|
|
// lastTPowAboveMaxVerifierTime = barTime;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastFastCrossOverSlowBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastFastCrossOverSlowTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastFastCrossOverSlowTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastFastCrossUnderSlowBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastFastCrossUnderSlowTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastFastCrossUnderSlowTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeCrossOverVerifierBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeCrossOverVerifierTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeCrossOverVerifierTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeCrossUnderVerifierBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeCrossUnderVerifierTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeCrossUnderVerifierTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeCrossOverRangeWeightBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeCrossOverRangeWeightTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeCrossOverRangeWeightTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeCrossUnderRangeWeightBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeCrossUnderRangeWeightTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeCrossUnderRangeWeightTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeWeightCrossOverVerifierBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeWeightCrossOverVerifierTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeWeightCrossOverVerifierTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// int GetLastRangeWeightCrossUnderVerifierBarIndex() {
|
|
// //
|
|
// int result = -1;
|
|
|
|
// //
|
|
// if (lastRangeWeightCrossUnderVerifierTime > 0) {
|
|
// //
|
|
// result = iBarShift(
|
|
// _Symbol,
|
|
// _Period,
|
|
// lastRangeWeightCrossUnderVerifierTime
|
|
// );
|
|
// }
|
|
|
|
// //
|
|
// return result;
|
|
// }
|
|
|
|
|
|
// //
|
|
// // Detect Sharp Changes ...
|
|
// double ll = GetMarketLowestLow(
|
|
// bar_index,
|
|
// xTPWSwingLength
|
|
// );
|
|
// double sharpDetectionValue =
|
|
// xTPWSharpDetectionFactor * _Point;
|
|
// double isSharpDetectionOccured =
|
|
// MathAbs(candle0.low - ll) > sharpDetectionValue
|
|
// ;
|
|
|
|
// //
|
|
// // Retrieve State Min and Max ...
|
|
// double stateMin0 = GetXTPWStateMin(state0);
|
|
// double stateMax0 = GetXTPWStateMax(state0);
|
|
// bool isStateDistanceValid =
|
|
// MathAbs(stateMax0 - stateMin0) < sharpDetectionValue;
|
|
|
|
// //
|
|
// // Fast Slow Verification ...
|
|
// //
|
|
// double topBound = MathMax(state1.range, state1.rangeWeight);
|
|
// topBound = MathMax(topBound, state1.verifier);
|
|
|
|
// //
|
|
// double bottomBound = MathMin(state1.range, state1.rangeWeight);
|
|
// bottomBound = MathMin(bottomBound, state1.verifier);
|
|
|
|
//
|
|
// bool isFastSlowValid =
|
|
// (
|
|
// state1.fast > topBound
|
|
// || state1.fast < bottomBound
|
|
// ) && (
|
|
// state1.slow > topBound
|
|
// || state1.slow < bottomBound
|
|
// );
|
|
|
|
//
|
|
bool longCondition1 =
|
|
//
|
|
// Condition 1 ...
|
|
true
|
|
//
|
|
&& tPow0.powerDown > tPow0.powerUp
|
|
&& state0.range > state0.verifier
|
|
&& state1.range > state1.verifier
|
|
&& state1.range > state1.rangeWeight
|
|
&& tPow0.powerDown > tPow1.powerDown
|
|
&& tPow1.powerDown > tPowerMaxVerifier
|
|
&& tPow2.powerDown < tPowerMaxVerifier
|
|
&& state1.rangeWeight > state1.verifier
|
|
&& !(
|
|
(
|
|
candle1.high > state1.verifier
|
|
&& candle1.low < state1.verifier
|
|
) || (
|
|
candle1.low > state1.verifier
|
|
)
|
|
)
|
|
;
|
|
|
|
//
|
|
bool longCondition2 =
|
|
//
|
|
// Condition 2 ...
|
|
true
|
|
//
|
|
&& tPow0.powerUp > tPow0.powerDown
|
|
&& tPow1.powerUp > tPow1.powerDown
|
|
&& tPow2.powerUp > tPow2.powerDown
|
|
&& tPow1.powerUp < tPowerVerifier
|
|
//
|
|
&& state1.fast > state1.slow
|
|
&& state1.range > state1.verifier
|
|
&& state0.fast < state0.rangeWeight
|
|
&& state1.fast < state1.rangeWeight
|
|
&& state1.rangeWeight > state1.range
|
|
&& MathAbs(state1.rangeWeight - state1.range) >
|
|
(MathAbs(state1.range - state1.verifier) / 2)
|
|
//
|
|
&& candle0.low > state0.verifier
|
|
&& candle1.low > state1.verifier
|
|
;
|
|
|
|
//
|
|
bool longCondition3 =
|
|
//
|
|
// Condition 3 ...
|
|
true
|
|
//
|
|
&& isCrossOver
|
|
&& state0.fast >= state2.fast
|
|
&& state1.psar < candle1.low
|
|
&& state1.verifier < state1.fast
|
|
//
|
|
&& MathMax(tPow1.powerUp, tPow1.powerDown) < tPowerMaxVerifier
|
|
;
|
|
|
|
|
|
//
|
|
// Get Minimum value of State ...
|
|
double GetXTPWStateMin(
|
|
const XTPWMarketState &state
|
|
) {
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
result = state.psar;
|
|
result = MathMin(result, state.fast);
|
|
result = MathMin(result, state.slow);
|
|
result = MathMin(result, state.range);
|
|
result = MathMin(result, state.verifier);
|
|
result = MathMin(result, state.rangeWeight);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get Maximum value of State ...
|
|
double GetXTPWStateMax(
|
|
const XTPWMarketState &state
|
|
) {
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
result = state.psar;
|
|
result = MathMax(result, state.fast);
|
|
result = MathMax(result, state.slow);
|
|
result = MathMax(result, state.range);
|
|
result = MathMax(result, state.verifier);
|
|
result = MathMax(result, state.rangeWeight);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
// Count range weight Crosses ...
|
|
if (
|
|
//
|
|
// Range Weight Cross Over Verifier ...
|
|
(
|
|
iState1.rangeWeight > iState1.verifier
|
|
&& !(iState2.rangeWeight > iState2.verifier)
|
|
)
|
|
||
|
|
//
|
|
// Range Weight Cross Under Verifier ...
|
|
(
|
|
iState1.rangeWeight < iState1.verifier
|
|
&& !(iState2.rangeWeight < iState2.verifier)
|
|
)
|
|
||
|
|
//
|
|
// Range Weight Cross Over Range ...
|
|
(
|
|
iState1.rangeWeight > iState1.range
|
|
&& !(iState2.rangeWeight > iState2.range)
|
|
)
|
|
||
|
|
//
|
|
// Range Weight Cross Under Range ...
|
|
(
|
|
iState1.rangeWeight < iState1.range
|
|
&& !(iState2.rangeWeight < iState2.range)
|
|
)
|
|
) {
|
|
rangeWeightCrosses++;
|
|
}
|
|
|
|
//
|
|
// Count Price above range ...
|
|
if (
|
|
iCandle.low > iState1.range
|
|
|| (
|
|
iCandle.low < iState1.range
|
|
&& iCandle.high > iState1.range
|
|
)
|
|
) {
|
|
//
|
|
priceAboveRange++;
|
|
}
|
|
|
|
//
|
|
// Count Price above verifier ...
|
|
if (
|
|
iCandle.low > iState1.verifier
|
|
|| (
|
|
iCandle.low < iState1.verifier
|
|
&& iCandle.high > iState1.verifier
|
|
)
|
|
) {
|
|
//
|
|
priceAboveVerifier++;
|
|
}
|
|
|
|
//
|
|
// Count between Range and Verifier ...
|
|
double vUpper = MathMax(iState0.range, iState0.verifier);
|
|
double vDowner = MathMin(iState0.range, iState0.verifier);
|
|
if (
|
|
!(
|
|
iState0.fast > vUpper
|
|
&& iState0.slow > vUpper
|
|
)
|
|
&&
|
|
!(
|
|
iState0.fast < vDowner
|
|
&& iState0.slow < vDowner
|
|
)
|
|
) {
|
|
fastAndSlowBetweenRangeAndVerifier++;
|
|
}
|
|
|
|
//
|
|
// Short ...
|
|
//
|
|
if (
|
|
!enableXTPWSignalling
|
|
|| !xTPWWaitForShortSignals
|
|
) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
datetime barTime = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
bar_index
|
|
);
|
|
|
|
//
|
|
// Retrieve TPower State ...
|
|
XTPOWStatee tPow0 = GetXTPowState(
|
|
bar_index,
|
|
xTPWSwingLength
|
|
);
|
|
XTPOWStatee tPow1 = GetXTPowState(
|
|
bar_index + 1,
|
|
xTPWSwingLength
|
|
);
|
|
XTPOWStatee tPow2 = GetXTPowState(
|
|
bar_index + 2,
|
|
xTPWSwingLength
|
|
);
|
|
|
|
//
|
|
// Retrieve TPWMarket State ...
|
|
XTPWMarketState state0 = GetXTPWMarketState(
|
|
bar_index
|
|
);
|
|
XTPWMarketState state1 = GetXTPWMarketState(
|
|
bar_index + 1
|
|
);
|
|
XTPWMarketState state2 = GetXTPWMarketState(
|
|
bar_index + 2
|
|
);
|
|
|
|
//
|
|
// Retrieve Candles ...
|
|
XOHCL candle0 = GetCandleModel(bar_index);
|
|
XOHCL candle1 = GetCandleModel(bar_index + 1);
|
|
XOHCL candle2 = GetCandleModel(bar_index + 2);
|
|
|
|
//
|
|
bool isTPowUp = tPow2.powerUp > tPow2.powerDown;
|
|
|
|
//
|
|
double tPowUpper = MathMax(tPow2.powerUp, tPow2.powerDown);
|
|
|
|
//
|
|
bool startCondition = false;
|
|
bool signalCondition = false;
|
|
|
|
//
|
|
startCondition =
|
|
//
|
|
true
|
|
//
|
|
&& tPow2.powerDown > tPowerVerifier
|
|
;
|
|
|
|
//
|
|
signalCondition =
|
|
//
|
|
true
|
|
//
|
|
&& tPow1.powerDown > tPow2.powerDown
|
|
&& tPow1.powerDown > tPowerMaxVerifier
|
|
;
|
|
|
|
// //
|
|
// bool isCrossOver =
|
|
// state1.fast > state1.slow
|
|
// && !(state2.fast > state2.slow)
|
|
// ;
|
|
|
|
// //
|
|
// bool isCrossUnder =
|
|
// state0.fast < state0.slow
|
|
// && state1.fast < state1.slow
|
|
// && !(state2.fast < state2.slow)
|
|
// ;
|
|
|
|
//
|
|
double tPowerMedian = tPowerMaxVerifier - tPowerVerifier / 2;
|
|
|
|
//
|
|
bool signalCondition1 =
|
|
isCrossUnder
|
|
;
|
|
|
|
//
|
|
bool signalCondition2 =
|
|
//
|
|
tPow0.powerDown > tPow0.powerUp
|
|
//
|
|
&& tPow1.powerDown > tPow1.powerUp
|
|
&& tPow2.powerDown > tPow2.powerUp
|
|
//
|
|
&& tPow0.powerDown > tPowerMedian
|
|
&& tPow1.powerDown > tPowerMedian
|
|
&& tPow2.powerDown > tPowerMedian
|
|
//
|
|
&& tPow0.signal > tPow0.powerDown
|
|
;
|
|
|
|
//
|
|
if (
|
|
(
|
|
(
|
|
startCondition
|
|
&& signalCondition
|
|
) || (
|
|
signalCondition1
|
|
|| signalCondition2
|
|
)
|
|
)
|
|
&& xTPWShortConds.startTime == 0
|
|
&& xTPWShortConds.signalTime == 0
|
|
) {
|
|
//
|
|
xTPWShortConds.startTime = barTime;
|
|
xTPWShortConds.signalTime = barTime;
|
|
xTPWShortConds.entryTime = barTime;
|
|
|
|
//
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Short ...
|
|
//
|
|
isPSarVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& state0.psar > candle0.high
|
|
&& state0.psar > signal.entry
|
|
;
|
|
|
|
//
|
|
// Get Price Verification for Short ...
|
|
isPriceVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& priceAboveRange < 1
|
|
&& priceAboveVerifier == 0
|
|
;
|
|
|
|
//
|
|
// Find Minimum Value of HH BarIndex Market State rangeWeight and verifier ...
|
|
double hhValidationValue = MathMin(
|
|
hhState.rangeWeight,
|
|
hhState.verifier
|
|
);
|
|
bool isHHValidForShortSignal =
|
|
hh < hhValidationValue
|
|
;
|
|
|
|
//
|
|
isTPowVerified =
|
|
//
|
|
// Starter ...
|
|
true
|
|
//
|
|
&& isHHValidForShortSignal
|
|
//
|
|
&& aboveTPowerMaxVerifier < 4
|
|
;
|
|
|
|
//
|
|
isStateVerified =
|
|
//
|
|
// Start ...
|
|
true
|
|
//
|
|
&& rangeWeightCrosses == 0
|
|
//
|
|
&& state0.slow > state0.fast
|
|
//
|
|
&& state0.range < state0.verifier
|
|
//
|
|
&& state0.rangeWeight > state0.range
|
|
&& state0.rangeWeight < state0.verifier
|
|
;
|
|
|
|
//
|
|
result =
|
|
//
|
|
// Starter Condition ...
|
|
true
|
|
//
|
|
&& isPSarVerified
|
|
//
|
|
&& isTPowVerified
|
|
//
|
|
&& isStateVerified
|
|
//
|
|
&& isPriceVerified
|
|
;
|
|
|
|
// //
|
|
// int aboveTPowerVerifier = 0;
|
|
// int abovePowerUpTPowerVerifier = 0;
|
|
// int abovePowerDownTPowerVerifier = 0;
|
|
|
|
// //
|
|
// int aboveTPowerMaxVerifier = 0;
|
|
// int abovePowerUpTPowerMaxVerifier = 0;
|
|
// int abovePowerDownTPowerMaxVerifier = 0;
|
|
|
|
// //
|
|
// int belowTPowerVerifier = 0;
|
|
// int belowPowerUpTPowerVerifier = 0;
|
|
// int belowPowerDownTPowerVerifier = 0;
|
|
|
|
// //
|
|
// int belowTPowerMaxVerifier = 0;
|
|
// int belowPowerUpTPowerMaxVerifier = 0;
|
|
// int belowPowerDownTPowerMaxVerifier = 0;
|
|
|
|
// //
|
|
// double powerUpSum = 0;
|
|
// double powerDownSum = 0;
|
|
|
|
// //
|
|
// int priceAboveRange = 0;
|
|
// int priceAboveVerifier = 0;
|
|
// int fastAndSlowBetweenRangeAndVerifier = 0;
|
|
|
|
// //
|
|
// int rangeWeightCrosses = 0;
|
|
|
|
// //
|
|
// for (int i = signalBarIndex; i < signalBarIndex + xTPWSwingLength; i++) {
|
|
// //
|
|
// XOHCL iCandle = GetCandleModel(i);
|
|
|
|
// //
|
|
// XTPOWStatee iTPow = GetXTPowState(
|
|
// i,
|
|
// xTPWSwingLength
|
|
// );
|
|
|
|
// //
|
|
// double isTPowUp = iTPow.powerUp > iTPow.powerDown;
|
|
|
|
// //
|
|
// double tPowUpper = MathMax(iTPow.powerUp, iTPow.powerDown);
|
|
|
|
// //
|
|
// // Summarise ...
|
|
// powerUpSum += iTPow.powerUp;
|
|
// powerDownSum += iTPow.powerDown;
|
|
|
|
// //
|
|
// XTPWMarketState iState0 = GetXTPWMarketState(
|
|
// i
|
|
// );
|
|
// XTPWMarketState iState1 = GetXTPWMarketState(
|
|
// i + 1
|
|
// );
|
|
// XTPWMarketState iState2 = GetXTPWMarketState(
|
|
// i + 2
|
|
// );
|
|
|
|
|
|
// //
|
|
// // Count Above TPow Verifier ...
|
|
// if (tPowUpper > tPowerVerifier) {
|
|
// //
|
|
// aboveTPowerVerifier++;
|
|
|
|
// //
|
|
// if (isTPowUp) {
|
|
// abovePowerUpTPowerVerifier++;
|
|
// } else {
|
|
// abovePowerDownTPowerVerifier++;
|
|
// }
|
|
// } else if (tPowUpper < tPowerVerifier) {
|
|
// //
|
|
// belowTPowerVerifier++;
|
|
|
|
// //
|
|
// if (isTPowUp) {
|
|
// belowPowerUpTPowerVerifier++;
|
|
// } else {
|
|
// belowPowerDownTPowerVerifier++;
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// // Count Above TPow Max Verifier ...
|
|
// if (tPowUpper > tPowerMaxVerifier) {
|
|
// //
|
|
// aboveTPowerMaxVerifier++;
|
|
|
|
// //
|
|
// if (isTPowUp) {
|
|
// abovePowerUpTPowerMaxVerifier++;
|
|
// } else {
|
|
// abovePowerDownTPowerMaxVerifier++;
|
|
// }
|
|
// } else if (tPowUpper < tPowerMaxVerifier) {
|
|
// //
|
|
// belowTPowerMaxVerifier++;
|
|
|
|
// //
|
|
// if (isTPowUp) {
|
|
// belowPowerUpTPowerMaxVerifier++;
|
|
// } else {
|
|
// belowPowerDownTPowerMaxVerifier++;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
|
|
// //
|
|
// int doubleMarketLength = (xTPWSwingLength * 2);
|
|
// int verifierLength = GetDailyCandleCount();
|
|
// int rangeLength = verifierLength / 2;
|
|
|
|
// //
|
|
// // Find Highest High ...
|
|
|
|
// //
|
|
// double rangeHH = GetMarketHighestHigh(
|
|
// signalBarIndex,
|
|
// rangeLength
|
|
// );
|
|
|
|
// //
|
|
// double verifierHH = GetMarketHighestHigh(
|
|
// signalBarIndex,
|
|
// verifierLength
|
|
// );
|
|
|
|
// //
|
|
// // Find HH Bar Index ...
|
|
// int hhBarIndex = iHighest(
|
|
// _Symbol,
|
|
// _Period,
|
|
// MODE_HIGH,
|
|
// xTPWSwingLength,
|
|
// signalBarIndex
|
|
// );
|
|
|
|
// //
|
|
// // Find HH ...
|
|
// double hh = iHigh(
|
|
// _Symbol,
|
|
// _Period,
|
|
// hhBarIndex
|
|
// );
|
|
|
|
// //
|
|
// // Retrieve Market State on HH Bar Index ...
|
|
// XTPWMarketState hhState = GetXTPWMarketState(
|
|
// hhBarIndex
|
|
// );
|
|
|
|
// //
|
|
// // Retrieve TPow State on HH Bar Index ...
|
|
// XTPOWStatee hhTPow = GetXTPowState(
|
|
// hhBarIndex,
|
|
// xTPWSwingLength
|
|
// );
|
|
|
|
// //
|
|
// // Find Lowest Low ...
|
|
|
|
// //
|
|
// double rangeLL = GetMarketLowestLow(
|
|
// signalBarIndex,
|
|
// rangeLength
|
|
// );
|
|
|
|
// //
|
|
// double verifierLL = GetMarketLowestLow(
|
|
// signalBarIndex,
|
|
// verifierLength
|
|
// );
|
|
|
|
// //
|
|
// // Find LL Bar Index ...
|
|
// int llBarIndex = iLowest(
|
|
// _Symbol,
|
|
// _Period,
|
|
// MODE_LOW,
|
|
// xTPWSwingLength,
|
|
// signalBarIndex
|
|
// );
|
|
|
|
// //
|
|
// // Find LL ...
|
|
// double ll = iLow(
|
|
// _Symbol,
|
|
// _Period,
|
|
// llBarIndex
|
|
// );
|
|
|
|
// //
|
|
// // Retrieve Market State on LL Bar Index ...
|
|
// XTPWMarketState llState = GetXTPWMarketState(llBarIndex);
|
|
|
|
// //
|
|
// // Retrieve TPow State on LL Bar Index ...
|
|
// XTPOWStatee llTPow = GetXTPowState(
|
|
// llBarIndex,
|
|
// xTPWSwingLength
|
|
// );
|
|
|
|
// //
|
|
// // Find Sharp Changes ...
|
|
// double diffChange = (hh - ll);
|
|
// double sharpDetectionValue =
|
|
// (xTPWSharpDetectionFactor * _Point);
|
|
// bool isBigSharpOccured =
|
|
// diffChange > sharpDetectionValue;
|
|
// ;
|
|
|
|
// //
|
|
// bool isHHVerified =
|
|
// !(
|
|
// hh == rangeHH
|
|
// && rangeHH == verifierHH
|
|
// )
|
|
// ||
|
|
// (
|
|
// hh > rangeHH
|
|
// || hh > verifierHH
|
|
// );
|
|
|
|
// //
|
|
// bool isLLVerified =
|
|
// !(
|
|
// ll == rangeLL
|
|
// && rangeLL == verifierLL
|
|
// )
|
|
// ||
|
|
// (
|
|
// ll < rangeLL
|
|
// || ll < verifierLL
|
|
// );
|