WickPressureLibWickPressureLib: The Regime Dynamics Engine
DESCRIPTION:
WickPressureLib/b] is not a standard candlestick pattern library. It is an advanced analytical engine designed to deconstruct the internal dynamics of price action. It provides a definitive toolkit for analyzing candle microstructure and quantifying order flow pressure through statistical modeling.
█ CHAPTER 1: THE PHILOSOPHY — BEYOND PATTERNS, INTO DYNAMICS
A candlestick wick represents a specific market event: a rejection of price. Traditional analysis often labels these simply as "bullish" or "bearish." This library aims to go deeper by treating each candle as a dataset of opposing forces.
The WickPressureLib translates static price action into dynamic metrics. It deconstructs the candle into core components and subjects them to multi-layered analysis. It calculates Kinetic Force , estimates institutional Delta , tracks the Siege Decay of key levels, and uses Thompson Sampling (a Bayesian probability algorithm) to assess the statistical weight of each formation.
This library does not just identify patterns; it quantifies the forces that create them. It is designed for developers who need quantitative, data-driven metrics rather than subjective interpretation.
█ CHAPTER 2: THE ANALYTICAL PIPELINE — SIX LAYERS OF LOGIC
The engine's capabilities come from a six-stage processing pipeline. Each layer builds upon the last to create a comprehensive data object.
LAYER 1 — DELTA ESTIMATION: Uses a proprietary model to approximate order flow (Delta) within a single candle based on the relationship between wicks, body, and total range.
LAYER 2 — SIEGE ANALYSIS: A concept for measuring structural integrity. Every time a price level is tested by a wick, its "Siege Decay" score is updated. Repeated tests without a breakout result in a decayed score, indicating weakening support/resistance.
LAYER 3 — MAGNETISM ENGINE: Calculates the probability of a wick being "filled" (mean reversion) based on trend strength and volume profile. Distinguishes between rejection wicks and exhaustion wicks.
LAYER 4 — REGIME DETECTION: Context-aware analysis using statistical tools— Shannon Entropy (disorder), DFA (trend vs. mean-reversion), and Hurst Exponent (persistence)—to classify the market state (e.g., "Bull Trend," "Bear Range," "Choppy").
LAYER 5 — ADAPTIVE LEARNING (THOMPSON SAMPLING): Uses a Bayesian Multi-Armed Bandit algorithm to track performance. It maintains a set of "Agents," each tracking a different wick pattern type. Based on historical outcomes, the system updates the probability score for each pattern in real-time.
LAYER 6 — CONTEXTUAL ROUTING: The final layer of logic. The engine analyzes the wick, determines its pattern type, and routes it to the appropriate Agent for probability assessment, weighted by the current market regime.
█ CHAPTER 3: CORE FUNCTIONS
analyze_wick() — The Master Analyzer
The primary function. Accepts a bar index and returns a WickAnalysis object containing over 15 distinct metrics:
• Anomaly Score: Z-Score indicating how statistically rare the wick's size is.
• Kinetic Force: Metric combining range and relative volume to quantify impact.
• Estimated Delta: Approximation of net buying/selling pressure.
• Siege Decay: Structural integrity of the tested level.
• Magnet Score: Probability of the wick being filled.
• Win Probability: Adaptive success rate based on the Thompson Sampling engine.
scan_clusters() — Liquidity Zone Detection
Scans recent price history to identify "Pressure Clusters"—zones where multiple high-pressure wicks have overlapped. Useful for finding high-probability supply and demand zones.
detect_regime() — Context Engine
Uses statistical methods to determine the market's current personality (Trending, Ranging, or Volatile). This output allows the analysis to adapt dynamically to changing conditions.
█ CHAPTER 4: DEVELOPER INTEGRATION GUIDE
This library is a low-level engine for building sophisticated indicators.
1. Import the Library:
import DskyzInvestments/DafeWickLib/1 as wpk
2. Initialize the Agents:
var agents = wpk.create_learning_agents()
3. Analyze the Market:
regime = wpk.detect_regime(100)
wick_data = wpk.analyze_wick(0, regime, agents)
prob = wpk.get_probability(wick_data, regime)
4. Update Learning (Feedback Loop):
agent_id = wpk.get_agent_by_pattern(wick_data)
agents := wpk.update_learning_agent(agents, agent_id, 1.0) // +1 win, -1 loss
█ CHAPTER 5: THE DEVELOPER'S FRAMEWORK — INTEGRATION GUIDE
This library serves as a professional integration framework. This guide provides instructions and templates required to connect the DAFE components into a unified custom Pine Script indicator.
PART I: THE INPUTS TEMPLATE (CONTROL PANEL)
To provide users full control over the system, include the input templates from all connected libraries. This section details the bridge-specific controls.
// ╔═════════════════════════════════════════════════════════╗
// ║ BRIDGE INPUTS TEMPLATE (COPY INTO YOUR SCRIPT) ║
// ╚═════════════════════════════════════════════════════════╝
// INPUT GROUPS
string G_BRIDGE_MAIN = "════════════ 🌉 BRIDGE CONFIG ════════════"
string G_BRIDGE_EXT = "════════════ 🌐 EXTERNAL DATA ════════════"
// BRIDGE MAIN CONFIG
float i_bridge_min_conf = input.float(0.55, "Min Confidence to Trade",
minval=0.4, maxval=0.8, step=0.01, group=G_BRIDGE_MAIN,
tooltip="Minimum blended confidence required for a trade signal.")
int i_bridge_warmup = input.int(100, "System Warmup Bars",
minval=50, maxval=500, group=G_BRIDGE_MAIN,
tooltip="Bars required for data gathering before signals begin.")
// EXTERNAL DATA SOCKETS
bool i_ext_enable = input.bool(true, "🌐 Enable External Data Sockets",
group=G_BRIDGE_EXT,
tooltip="Enables analysis of external market data (e.g., VIX, DXY).")
// Example for one external socket
string i_ext1_name = input.string("VIX", "Socket 1: Name", group=G_BRIDGE_EXT, inline="ext1")
string i_ext1_sym = input.symbol("TVC:VIX", "Symbol", group=G_BRIDGE_EXT, inline="ext1")
string i_ext1_type = input.string("volatility", "Data Type",
options= ,
group=G_BRIDGE_EXT, inline="ext1")
float i_ext1_weight = input.float(1.0, "Weight", minval=0.1, maxval=2.0, step=0.1, group=G_BRIDGE_EXT, inline="ext1")
PART II: IMPLEMENTATION LOGIC (THE CORE LOOP)
This boilerplate code demonstrates the complete, unified pipeline structure.
// ╔════════════════════════════════════════════════════════╗
// ║ USAGE EXAMPLE (ADAPT TO YOUR SCRIPT) ║
// ╚════════════════════════════════════════════════════════╝
// 1. INITIALIZE ENGINES (First bar only)
var rl.RLAgent agent = rl.init(...)
var spa.SPAEngine spa_engine = spa.init(...)
var bridge.BridgeState bridge_state = bridge.init_bridge(i_spa_num_arms, i_rl_num_actions, i_bridge_min_conf, i_bridge_warmup)
// 2. CONNECT SOCKETS (First bar only)
if barstate.isfirst
// Connect internal sockets
agent := rl.connect_socket(agent, "rsi", ...)
// Register external sockets
if i_ext_enable
ext_socket_1 = bridge.create_ext_socket(i_ext1_name, i_ext1_sym, i_ext1_type, i_ext1_weight)
bridge_state := bridge.register_ext_socket(bridge_state, ext_socket_1)
// 3. MAIN LOOP (Every bar)
// --- A. UPDATE EXTERNAL DATA ---
if i_ext_enable
= request.security(i_ext1_sym, timeframe.period, )
bridge_state := bridge.update_ext_by_name(bridge_state, i_ext1_name, ext1_c, ext1_h, ext1_l)
bridge_state := bridge.aggregate_ext_sockets(bridge_state)
// --- B. RL/ML PROPOSES ---
rl.RLState ml_state = rl.build_state(agent)
= rl.select_action(agent, ml_state)
agent := updated_agent
// --- C. BRIDGE TRANSLATES ---
array arm_signals = bridge.generate_arm_signals(ml_action.action, ml_action.confidence, i_spa_num_arms, i_rl_num_actions, 0)
// --- D. SPA DISPOSES ---
spa_engine := spa.feed_signals(spa_engine, arm_signals, close)
= spa.select(spa_engine)
spa_engine := updated_spa
string arm_name = spa.get_name(spa_engine, selected_arm)
// --- E. RECONCILE REGIME & COMPUTE RISK ---
bridge_state := bridge.reconcile_regime(bridge_state, ml_regime_id, ml_regime_name, ml_conf, spa_regime_id, spa_conf, ...)
float risk = bridge.compute_risk(bridge_state, ml_action.confidence, spa_conf, ...)
// --- F. MAKE FINAL DECISION ---
bridge_state := bridge.make_decision(bridge_state, ml_action.action, ml_action.confidence, selected_arm, arm_name, final_spa_signal, spa_conf, risk, 0.25)
bridge.UnifiedDecision final_decision = bridge_state.decision
// --- G. EXECUTE ---
if final_decision.should_trade
// Plot signals, manage positions based on final_decision.direction
// --- H. LEARN (FEEDBACK LOOP) ---
if (trade_is_closed)
bridge_state := bridge.compute_reward(bridge_state, selected_arm, ...)
agent := rl.learn(agent, ..., bridge_state.reward.shaped_reward, ...)
// --- I. PERFORMANCE & DIAGNOSTICS ---
bridge_state := bridge.update_performance(bridge_state, actual_market_direction)
if barstate.islast
label.new(bar_index, high, bridge.bridge_diagnostics(bridge_state), textalign=text.align_left)
█ DEVELOPMENT PHILOSOPHY
DafeMLSPABridge represents a hierarchical design philosophy. We believe robust systems rely not on a single algorithm, but on the intelligent integration of specialized subsystems. A complete trading logic requires tactical precision (ML), strategic selection (SPA), and environmental awareness (External Sockets). This library provides the infrastructure for these components to communicate and coordinate.
█ DISCLAIMER & IMPORTANT NOTES
• LIBRARY FOR DEVELOPERS: This script is an integration tool and produces no output on its own. It requires implementation of DafeRLMLLib and DafeSPALib.
• COMPUTATION: Full bridged systems are computationally intensive.
• RISK: All automated decisions are based on statistical probabilities from historical data. They do not predict future market movements with certainty.
"The whole is greater than the sum of its parts." — Aristotle
Create with DAFE.
Pine Script® library
