drawingLibrary "drawing"
Contains common types and methods to draw objects on the chart.
method toTextAlign(input)
Namespace types: series textHorizontalAlignEnum
Parameters:
input (series textHorizontalAlignEnum)
method toTextAlign(input)
Namespace types: series textVertialAlignEnum
Parameters:
input (series textVertialAlignEnum)
method toSize(input)
Namespace types: series sizeEnum
Parameters:
input (series sizeEnum)
method toStyle(input)
Namespace types: series lineStyleEnum
Parameters:
input (series lineStyleEnum)
Cari skrip untuk "text"
Aibuyzone Elliott Wave SuiteOverview
This study approximates Elliott-style wave structure using swing pivots. It labels primary waves (1–5), tracks subwaves (1–5) inside them, and plots future projection bands derived from the size of a recent primary leg. A small floating dashboard summarizes the current wave number, bias (bullish/bearish) based on the last leg, and a projection price range.
Note: This tool is educational. Wave detection is algorithmic and approximate; it does not identify textbook Elliott patterns or validate rule sets. Manage risk independently.
What it draws
Primary wave labels (1–5): Based on higher swing length pivots (major turns).
Subwave labels (1–5): Based on shorter swing length pivots (minor turns).
Zigzag connectors: Simple lines between the latest primary pivots for structure visualization.
Projection bands: Three dotted horizontal levels forward from the last primary pivot, using user-defined extension multipliers.
Floating dashboard:
Current Wave: Latest primary wave count (1–5).
Bias: “Bullish Leg” (last pivot was a low) or “Bearish Leg” (last pivot was a high), or “Unknown” if insufficient data.
Proj Range: Min–max of the three projection levels.
Key Inputs
Swing Structure
Primary Swing Length: Pivot left/right bars for major swings. Larger values = fewer, cleaner waves.
Subwave Swing Length: Pivot left/right bars for minor swings. Smaller values = more frequent subwave labels.
Max Saved Swing Points: Memory limit to prevent clutter.
Future Projections
Show Projection Levels: Toggle projection lines on/off.
Use Last Nth Leg For Size: Which recent primary leg to use for measuring projection distance (1 = most recent).
Extension 1 / 2 / 3: Multipliers applied to the measured leg (e.g., 1.0, 1.618, 2.0).
Style
Colors and text sizes for primary and subwave labels, and projection lines.
Dashboard
Show Dashboard: Toggle table on/off.
Dashboard Position: Top-Left / Top-Right / Bottom-Left / Bottom-Right.
How projections are computed
The script measures the price distance of a recent primary leg (from pivot A to pivot B).
If the last pivot is a low, projections extend upward; if the last pivot is a high, projections extend downward.
The three extension inputs (e.g., 1.0 / 1.618 / 2.0) are applied to that leg distance to create dotted forward levels.
The dashboard’s Proj Range displays the min–max of those three levels.
Using the study (suggested workflow)
Choose timeframe appropriate for your style (e.g., higher timeframes for cleaner structure; lower timeframes for detail).
Tune swing lengths:
Increase Primary Swing Length on noisy charts to stabilize wave counts.
Adjust Subwave Swing Length to reveal or simplify internal moves.
Read the dashboard:
Current Wave shows where the latest primary count sits (1–5).
Bias summarizes the direction of the last measured leg only; it is not a trend system.
Proj Range offers a coarse price band derived from your extensions.
Context check: Combine wave labeling with your own market context (trend, structure, volatility) before making decisions.
Risk management: Use your own stop/target methods. The projection lines are not signals.
Practical tips
Clutter control: If labels overlap on volatile symbols, try larger swing lengths or reduce label text sizes in Style.
Scaling: On very small tick sizes, increasing the internal label price offset can improve label readability.
Projection sensitivity: Changing Use Last Nth Leg can materially alter levels; confirm they match your intent.
Non-determinism across timeframes: Different timeframes and symbols will produce different pivot sequences and counts.
Limitations & important notes
Approximation: This does not enforce all Elliott rules (e.g., alternation, wave 4 overlap constraints, channeling). It only labels swings numerically.
Repainting of labels: Pivot-based waves confirm after enough bars have printed to the right of a high/low. Labels are placed when pivots confirm; they don’t predict pivots.
Not a signal generator: No entries/exits/alerts are included; add your own trade plan and risk controls.
Data sufficiency: Early bars or sparse data may show “Unknown” bias or “N/A” projections until adequate pivots exist.
Clean-chart publishing guidance (to stay compliant)
Use a chart that clearly shows this script’s outputs without unrelated indicators.
Keep the description educational. Avoid performance claims, guarantees, or language implying certainty.
Do not include links, promotions, prices, giveaways, contact details, or solicitations.
Disclose that labels and projections are algorithmic approximations and for educational use.
Risk disclosure
This script is for educational purposes only. It does not provide financial, investment, or trading advice and does not guarantee outcomes. Markets involve risk, including the potential loss of capital. Always do your own research and use independent judgment.
JOPA Channel (Dual-Volumed) v1 [JopAlgo]JOPA Channel (Dual-Volumed) v1
Short title: JOPAV1 • License: MPL-2.0 • Provider: JopAlgo
We have developed our own, first channel-based trading indicator and we’re making it available to all traders. The goal was a channel that breathes with the tape—built on a volume-weighted backbone—so the outcome stays lively instead of static. That led to the JOPA Channel.
All important features (at a glance)
In one line: A Rolling-VWAP channel whose width adapts with two volumes (RVOL + dollar-flow), adds order-flow asymmetry (OBV tilt) and regime awareness (Efficiency Ratio), and frames risk with outer containment bands from residual extremes—so you see fair value, momentum, and exhaustion in one view.
Feature list
Rolling VWAP centerline: Tracks where volume traded (fair value).
Dual-volume width: Bands expand/contract with relative volume and value traded (price×volume).
OBV tilt: Upper/lower widths skew toward the side actually pushing.
Regime adapter (ER): Tighter in trend, wider in chop—automatically.
Outer containment rails: Residual-extreme ceilings/floors, smoothed + margin.
20% / 80% guides: 20% light blue (discount), 80% light red (premium).
Squeeze dots (optional): Orange circles below candles during compression.
Non-repainting: Uses rolling sums and past-only math; no lookahead.
Default visual in this release
Containment rails + fill: ON (stepline, medium).
Inner Value rails + fill: Rails OFF (stepline, thin), fill ON (drawn only if rails are shown).
20% & 80% guides: ON (dashed, thin; 20% light blue, 80% light red).
Squeeze dots: OFF by default (orange circles when enabled).
What you see on the chart
RVWAP (centerline): Your compass for fair value.
Inner Value Bands (optional): Tight rails for breakouts and pullback timing.
Outer Containment Bands (default ON): High-confidence ceilings/floors for targets and fades.
20% / 80% guides: Quick read of “where in the channel” price is sitting.
Squeeze dots (optional): Volatility compression heads-up (no text labels).
Non-repainting note: The indicator does not revise closed bars. Forecast-Lock uses linear regression to extrapolate 1–3 bars ahead without using future data.
How to use it
Core reads (works on any timeframe)
Bias: Above a rising RVWAP → long bias; below a falling RVWAP → short bias.
Breakouts (momentum): Close beyond an Inner Value rail with RVOL ≥ threshold (alert provided).
Reversions (fades): Tag Outer Containment, stall, then close back inside → expect mean reversion toward RVWAP.
20/80 timing:
At/above 80% (light red) → premium/exhaustion risk; trim longs or consider fades if RVOL cools.
At/below 20% (light blue) → discount/exhaustion risk; trim shorts or consider longs if RVOL cools.
Squeeze clusters: When dots bunch up, expect a range break; use the Breakout alert as confirmation.
Playbooks by trading style
Day Trading (1–5m)
Setup: Keep the chart clean (Containment ON, Value rails OFF). Toggle Inner Value ON when hunting a breakout or timing a pullback.
Pullback Long: Dip to RVWAP / Lower Value with sub-threshold RVOL, then a close back above RVWAP → long.
Stop: Just beyond Lower Containment or the pullback swing.
Targets (1:1:1): ⅓ at RVWAP, ⅓ at Upper Value, ⅓ trail toward Upper Containment.
Breakout Long: After a squeeze cluster, take the Breakout Long alert (close > Upper Value, RVOL ≥ min). If no retest, demand the next bar holds outside.
Range Fade: Only when RVWAP is flat and dots cluster; short Upper Containment → RVWAP (mirror for longs at the lower rail).
Intraday (15m–1H)
HTF compass: Take bias from 4H.
Pullback Long: “Touch & reclaim” of RVWAP while RVOL cools; enter on the reclaim close or break of that candle’s high.
Breakout: Run Inner Value ON; act on Breakout alerts (RVOL gate ≈ 1.10–1.15 typical).
Avoid low-probability fades against the 4H slope unless RVWAP is flat.
Swing (4H–1D)
Continuation: In uptrends, buy pullbacks to RVWAP / Lower Value with sub-threshold RVOL; scale at Upper Containment.
Adds: Post-squeeze Breakout Long adds; trail on RVWAP or Lower Value.
Fades: Prefer when RVWAP flattens and price oscillates between containments.
Position (1D+)
Framework: Daily RVWAP slope + position within containment.
Add rule: Each reclaim of RVWAP after a dip is an add; trim into Upper Containment or near 80% light red.
Sizing: Containment distance is larger—size down and trail on RVWAP.
Inputs & Settings (complete)
Core
Source: Price input for RVWAP.
Rolling VWAP Length: Window of the centerline (higher = smoother).
Volume Baseline (RVOL): SMA window for relative volume.
Inner Value Bands (volatility-based width)
k·StdDev(residuals), k·ATR, k·MAD(residuals): Blend three measures into base width.
StdDev / ATR / MAD Lengths: Lookbacks for each.
Two-Volume Fusion
RVOL Exponent: How aggressively width responds to relative volume.
Dollar-Flow Gain: Adds push from price×volume (value traded).
Dollar-Flow Z-Window: Standardization window for dollar-flow.
Asymmetry (Order-Flow Tilt)
Enable Tilt (OBV): Lets flow skew upper/lower widths.
Tilt Strength (0..1): Gain applied to OBV slope z-score.
OBV Slope Z-Window: Window to standardize OBV slope.
Regime Adapter
Efficiency Ratio Lookback: Measures trend vs chop.
ER Width Min/Max: Maps ER into a width factor (tighter in trend, wider in chop).
Band Tracking (inner value rails)
Tracking Mode:
Base: Pure base rails.
Parallel-Lock: Smooth RVWAP & width; track in parallel.
Slope-Lock: Adds a fraction of recent slope (momentum-friendly).
Forecast-Lock: 1–3 bar extrapolation via linreg (non-repainting on closed bars).
Attach Strength (0..1): Blend tracked rails vs base rails.
Tracking Smooth Length: EMA smoothing of RVWAP and width.
Slope Influence / Forecast Lead Bars: Gains for the chosen mode.
Outer Containment Bands
Show Containment Bands: Master toggle (default ON).
Residual Extremes Lookback: Highest/lowest residual window.
Extreme Smoothing (EMA): Stability on extreme lines.
Margin vs inner width: Extra padding relative to smoothed inner width.
Squeeze & Alerts
Squeeze Window / Threshold: Width vs average; at/under threshold = dot (when enabled).
Min RVOL for Breakout: Required RVOL for breakout alerts.
Style (defaults in this release)
Inner Value rails: OFF (stepline, thin).
Inner & Containment fills: ON.
Containment rails: ON (stepline, medium).
20% / 80% guides: ON — 20% light blue, 80% light red, dashed, thin.
Squeeze dots: OFF by default (orange circles below candles when enabled).
Practical templates (copy/paste into a plan)
Momentum Breakout
Context: Squeeze cluster near RVWAP; Inner Value ON.
Trigger: Breakout Long (close > Upper Value & RVOL ≥ min).
Stop: Below Lower Value (tight) or below RVWAP (safer).
Targets (1:1:1): ⅓ Value → ⅓ Containment → ⅓ trail on RVWAP.
Pullback Continuation
Context: Uptrend; dip to RVWAP / Lower Value with cooling RVOL.
Trigger: Close back above RVWAP or break of reclaim candle’s high.
Stop: Just outside Lower Containment or pullback swing.
Targets: RVWAP → Upper Value → Upper Containment.
Containment Reversion (range)
Context: RVWAP flat; repeated containment tags.
Trigger: Stall at containment, then close back inside.
Stop: A step beyond that containment.
Target: RVWAP; runner only if RVOL stays muted.
Alerts included
DVWAP Breakout Long / Short (Value Bands)
Top Zone / Bottom Zone (20% / 80% guides)
Tip: On lower TFs, act on Breakout alerts with higher-TF bias (e.g., trade 5–15m in the direction of 1H/4H RVWAP slope/position).
Best practices
Let RVWAP be the compass; if unsure, wait until price picks a side.
Respect RVOL; low-RVOL breaks are prone to fail.
Use guides for timing, not certainty. Pair 20/80 zones with flow context.
Start with defaults; change one knob at a time.
Common pitfalls
Fading every containment touch → only fade when RVWAP is flat or RVOL cools.
Over-tuning inputs → the defaults are robust; small tweaks go a long way.
Fighting the higher timeframe on low TFs → expensive habit.
Footer — License & Publishing
License: Mozilla Public License 2.0 (MPL-2.0). You may modify and redistribute; keep this file under MPL and provide source for this file.
Originality: © 2025 JopAlgo. No third-party code reused; Pine built-ins and common formulas only.
Publishing: Keep this header/description intact when releasing on TradingView. Avoid promotional links in the public script text.
Market Cap Landscape 3DHello, traders and creators! 👋
Market Cap Landscape 3D. This project is more than just a typical technical analysis tool; it's an exploration into what's possible when code meets artistry on the financial charts. It's a demonstration of how we can transcend flat, two-dimensional lines and step into a vibrant, three-dimensional world of data.
This project continues a journey that began with a previous 3D experiment, the T-Virus Sentiment, which you can explore here:
The Market Cap Landscape 3D builds on that foundation, visualizing market data—particularly crypto market caps—as a dynamic 3D mountain range. The entire landscape is procedurally generated and rendered in real-time using the powerful drawing capabilities of polyline.new() and line.new() , pushed to their creative limits.
This work is intended as a guide and a design example for all developers, born from the spirit of learning and a deep love for understanding the Pine Script™ language.
---
🧐 Core Concept: How It Works
The indicator synthesizes multiple layers of information into a single, cohesive 3D scene:
The Surface: The mountain range itself is a procedurally generated 3D mesh. Its peaks and valleys create a rich, textured landscape that serves as the canvas for our data.
Crypto Data Integration: The core feature is its ability to fetch market cap data for a list of cryptocurrencies you provide. It then sorts them in descending order and strategically places them onto the 3D surface.
The Summit: The highest point on the mountain is reserved for the asset with the #1 market cap in your list, visually represented by a flag and a custom emblem.
The Mountain Labels: The other assets are distributed across the mountainside, with their rank determining their general elevation. This creates an intuitive visual hierarchy.
The Leaderboard Pole: For clarity, a dedicated pole in the back-right corner provides a clean, ranked list of the symbols and their market caps, ensuring the data is always easy to read.
---
🧐 Example of adjusting the view
To evoke the feeling of flying over mountains
To evoke the feeling of looking at a mountain peak on a low plain
🧐 Example of predefined colors
---
🚀 How to Use
Getting started with the Market Cap Landscape 3D:
Add to Chart: Apply the "Market Cap Landscape 3D" indicator to your active chart.
Open Settings: Double-click anywhere on the 3D landscape or click the "Settings" icon next to the indicator's name.
Customize Your Crypto List: The most important setting is in the Crypto Data tab. In the "Symbols" text area, enter a comma-separated list of the crypto tickers you want to visualize (e.g., BTC,ETH,SOL,XRP ). The indicator supports up to 40 unique symbols.
> Important Note: This indicator exclusively uses TradingView's `CRYPTOCAP` data source. To find valid symbols, use the main symbol search bar on your chart. Type `CRYPTOCAP:` (including the colon) and you will see a list of available options. For example, typing `CRYPTOCAP:BTC` will confirm that `BTC` is a valid ticker for the indicator's settings. Using symbols that do not exist in the `CRYPTOCAP` index will result in a script error. or, to display other symbols, simply type CRYPTOCAP: (including the colon) and you will see a list of available options.
Adjust Your View: Use the settings in the Camera & Projection tab to rotate ( Yaw ), tilt ( Pitch ), and scale the landscape until you find a view you love.
Explore & Customize: Play with the color palettes, flag design, and other settings to make the landscape truly your own!
---
⚙️ Settings & Customization
This indicator is highly customizable. Here’s a breakdown of what each setting does:
#### 🪙 Crypto Data
Symbols: Enter the crypto tickers you want to track, separated by commas. The script automatically handles duplicates and case-insensitivity.
Show Market Cap on Mountain: When checked, it displays the full market cap value next to the symbol on the mountain. When unchecked, it shows a cleaner look with just the symbol and a colored circle background.
#### 📷 Camera & Projection
Yaw (°): Rotates the camera view horizontally (side to side).
Pitch (°): Tilts the camera view vertically (up and down).
Scale X, Y, Z: Stretches or compresses the landscape in width, depth, and height, respectively. Fine-tune these to get the perfect perspective.
#### 🏞️ Grid / Surface
Grid X/Y resolution: Controls the detail level of the 3D mesh. Higher values create a smoother surface but may use more resources.
Fill surface strips: Toggles the beautiful color gradient on the surface.
Show wireframe lines: Toggles the visibility of the grid lines.
Show nodes (markers): Toggles the small dots at each grid intersection point.
#### 🏔️ Peaks / Mountains
Fill peaks volume: Draws vertical lines on high peaks, giving them a sense of volume.
Fill peaks surface: Draws a cross-hatch pattern on the surface of high peaks.
Peak height threshold: Defines the minimum height for a peak to receive the fill effect.
Peak fill color/density: Customizes the appearance of the fill lines.
#### 🚩 Flags (3D)
Show Flag on Summit: A master switch to show or hide the flag and emblem entirely.
Flag height, width, etc.: Provides full control over the dimensions and orientation of the flag on the highest peak.
#### 🎨 Color Palette
Base Gradient Palette: Choose from 13 stunning, pre-designed color themes for the landscape, from the classic SUNSET_WAVE to vibrant themes like NEON_DREAM and OCEANIC .
#### 🛡️ Emblem / Badge Controls
This section gives you granular control over every element of the custom emblem on the flag. Tweak rotation, offsets, and scale to design your unique logo.
---
👨💻 Developer's Corner: Modifying the Core Logic
If you're a developer and wish to customize the indicator's core data source, this section is for you. The script is designed to be modular, making it easy to change what data is being ranked and visualized.
The heart of the data retrieval and ranking logic is within the f_getSortedCryptoData() function. Here’s how you can modify it:
1. Changing the Data Source (from Market Cap to something else):
The current logic uses request.security("CRYPTOCAP:" + syms.get(i), ...) to fetch market capitalization data. To change this, you need to modify this line.
Example: Ranking by RSI (14) on the Daily timeframe.
First, you'll need a function to calculate RSI. Add this function to the script:
f_getRSI(symbol, timeframe, length) =>
request.security(symbol, timeframe, ta.rsi(close, length))
Then, inside f_getSortedCryptoData() , find the `for` loop that populates the `caps` array and replace the `request.security` call:
// OLD LINE:
// caps.set(i, request.security("CRYPTOCAP:" + syms.get(i), timeframe.period, close))
// NEW LINE for RSI:
// Note: You'll need to decide how to format the symbol name (e.g., "BINANCE:" + syms.get(i) + "USDT")
caps.set(i, f_getRSI("BINANCE:" + syms.get(i) + "USDT", "D", 14))
2. Changing the Data Formatting:
The ranking values are formatted for display using the f_fmtCap() function, which currently formats large numbers into "M" (millions), "B" (billions), etc.
If you change the data source to something like RSI, you'll want to change the formatting. You can modify f_fmtCap() or create a new formatting function.
Example: Formatting for RSI.
// Modify f_fmtCap or create f_fmtRSI
f_fmtRSI(float v) =>
str.tostring(v, "#.##") // Simply format to two decimal places
Remember to update the calls to this function in the main drawing loop where the labels are created (e.g., str.format("{0}: {1}", crypto.symbol, f_fmtCap(crypto.cap)) ).
By modifying these key functions ( f_getSortedCryptoData and f_fmtCap ), you can adapt the Market Cap Landscape 3D to visualize and rank almost any dataset you can imagine, from technical indicators to fundamental data.
---
We hope you enjoy using the Market Cap Landscape 3D as much as we enjoyed creating it. Happy charting! ✨
Previous VWAP Levels by Riotwolftrading The "Previous VWAP" indicator calculates and displays the previous session's Volume Weighted Average Price (VWAP) for five timeframes (Daily, Weekly, Monthly, Quarterly, Yearly).
Each VWAP is plotted as a horizontal line extending to the right edge of the chart, with customizable labels at the right to identify each level. The indicator is designed for traders who want to visualize key price levels from prior periods without cluttering the chart with current VWAPs or additional metrics like standard deviations.
**Functionality**:
- **Calculates Previous VWAPs**: Computes the VWAP for the previous session of each timeframe (Daily, Weekly, Monthly, Quarterly, Yearly) based on the input source (default: `hlc3`) and volume.
- **Visual Style** : Uses `line.new` to draw horizontal lines from five bars back to the current bar, ensuring the lines extend to the right edge of the chart. Labels are placed at the right edge using `label.new` for clear identification.
- **Customization** : Allows users to toggle visibility, adjust line styles, widths, colors, and label sizes, and choose between abbreviated or full label text.
- **Minimalist Design**: Focuses solely on previous VWAPs, omitting current VWAPs, rolling VWAPs, and standard deviation bands to keep the chart clean.
**Intended Use**: This indicator is useful for traders who rely on historical VWAP levels as support/resistance or reference points for trading decisions, particularly in strategies involving mean reversion or breakout trading.
---
### Rules and Features
*VWAP Calculation**:
- The VWAP is calculated as the cumulative sum of price (`src`) multiplied by volume (`sumSrcVol`) divided by the cumulative volume (`sumVol`) for each timeframe.
- The "previous VWAP" is the VWAP value from the prior session, captured when a new session begins (e.g., new day, week, month, etc.).
- The indicator uses the `hlc3` (average of high, low, close) as the default source, but users can modify this in the settings.
**Timeframes**:
- **Daily**: Previous day's VWAP.
- **Weekly**: Previous week's VWAP.
- **Monthly**: Previous month's VWAP.
- **Quarterly**: Previous quarter's VWAP (3 months).
- **Yearly**: Previous year's VWAP (12 months).
- New sessions are detected using `ta.change(time(period))` for each timeframe.
**Line Drawing**:
- Lines are drawn using `line.new` from `time ` (five bars back) to the current bar (`time`), ensuring they extend to the right edge of the chart.
- Lines are updated only on the last confirmed bar (`barstate.islast`) to optimize performance and avoid repainting.
- Previous lines are deleted (`line.delete`) to prevent overlapping or clutter.
**Labels**:
- Labels are drawn at the right edge (`x=time`, `xloc=xloc.bar_time`) with `label.new`.
- Users can choose between abbreviated labels (e.g., "pvD" for Previous Daily VWAP) or full labels (e.g., "Prev Daily VWAP").
- Label sizes are customizable (`tiny`, `small`, `normal`, `large`, `huge`).
- Labels are deleted (`label.delete`) on each update to maintain a clean chart.
5. **Customization Options**:
- **Visibility**: Toggle each VWAP (Daily, Weekly, Monthly, Quarterly, Yearly) on or off.
- **Colors**: Individual color settings for each VWAP line and label (default colors: Daily=#E12D7B, Weekly=#F67B52, Monthly=#EDCD3B, Quarterly=#3BBC54, Yearly=#2665BD).
- **Line Style**: Choose from `solid`, `dotted`, or `dashed` lines.
- **Line Width**: Adjustable from 1 to 4 pixels.
- **Label Settings**: Enable/disable labels, abbreviate text, and select label size.
- **Source**: Customize the price source (default: `hlc3`).
**Performance Optimization**:
- The indicator only updates lines and labels on the last confirmed bar to minimize computational overhead.
- Uses `var` to initialize variables and avoid unnecessary recalculations.
- Deletes previous lines and labels to prevent chart clutter.
---
### Usage Instructions
1. **Add to Chart**:
- In TradingView, go to the Pine Editor, paste the script, and click "Add to Chart."
- The indicator will overlay on the price chart, showing previous VWAP lines and labels.
2. **Configure Settings**:
- Open the indicator settings to customize:
- Toggle visibility of each VWAP timeframe.
- Adjust colors, line style, and width.
- Enable/disable labels, choose abbreviation, and set label size.
- Modify the source if needed (e.g., use `close` instead of `hlc3`).
3. **Interpretation**:
- **Previous VWAPs**: Act as dynamic support/resistance levels based on the prior session's volume-weighted price.
- **Timeframes**: Use shorter timeframes (Daily, Weekly) for intraday/swing trading, and longer timeframes (Monthly, Quarterly, Yearly) for positional trading.
- **Labels**: Identify each VWAP level at the right edge of the chart for quick reference.
4. **Best Practices**:
- Use on charts with sufficient volume data, as VWAP relies on volume (a warning is triggered if no volume data is available).
- Combine with other indicators (e.g., moving averages, RSI) for confirmation in trading strategies.
- Adjust line styles and colors to avoid visual overlap with other chart elements.
---
### Example Use Case
A trader using a 1-hour chart can add the "Previous VWAP" indicator to identify key levels from the prior day, week, or month. For example:
- The Previous Daily VWAP might act as a support level for a bullish trend.
- The Previous Weekly VWAP could serve as a target for a swing trade.
- Labels at the right edge make it easy to identify these levels without cluttering the chart.
This indicator provides a clean, customizable way to visualize previous VWAPs, making it ideal for traders who want historical price context with minimal chart noise. For the complete Pine Script code, refer to the artifact provided in the previous response.
RSI and MACD Divergence IndicatorThe RSI and MACD Divergence Indicator is a custom Pine Script v6 indicator designed for TradingView that identifies and visualizes divergences between price movements and two technical indicators: the Relative Strength Index (RSI) and the Moving Average Convergence Divergence (MACD). Here's a brief explanation of its functionality:
Divergence Detection: The indicator detects both regular and hidden divergences for RSI, MACD (MACD Line), and Histogram. Regular bullish divergences occur when price makes a lower low but the indicator makes a higher low (suggesting a potential reversal upward), while regular bearish divergences occur when price makes a higher high but the indicator makes a lower high (suggesting a potential reversal downward). Hidden divergences indicate continuation patterns (e.g., higher low in price with a lower low in the indicator for bullish continuation).
Customizable Inputs:
Pivot Bars: Sets the number of bars used to confirm pivot highs and lows (default: 5).
RSI and MACD Parameters: Allows adjustment of RSI length (default: 14) and MACD settings (fast: 12, slow: 26, signal: 9).
Toggle Options: Enables/disables detection of regular and hidden divergences for RSI, MACD, and Histogram individually.
Confirmation: Option to wait for pivot confirmation (default: true), delaying divergence display until the pivot is fully formed.
Show Only Last Divergence: Toggles between showing only the most recent divergence (default: true) or all detected divergences (false), with previous lines and labels cleared when true.
Minimum Divergences: Sets the minimum number of divergence types required at a pivot to display (default: 1, max: 6).
Maximum Pivot Points: Limits the number of historical pivot points to check (default: 10).
Maximum Bars to Check: Restricts analysis to the last specified number of bars (default: 500).
Visualization:
Draws lines connecting the price pivot points where divergences are detected, with customizable colors, widths, and styles (solid, dashed, dotted) for RSI and MACD.
Displays a single label per pivot with vertically stacked text listing all detected divergence types (e.g., "RSI Bull Div\nMACD Bull Div"), using semi-transparent backgrounds (green for bullish, red for bearish) and white text.
BTC Dominance Zones (For Altseason)Overview
The "BTC Dominance Zones (For Altseason)" indicator is a visual tool designed to help traders navigate the different phases of the altcoin market cycle by tracking Bitcoin Dominance (BTC.D).
It provides clear, color-coded zones directly on the BTC.D chart, offering an intuitive roadmap for the progression of alt season.
Purpose & Problem Solved
Many traders often miss altcoin rotations or get caught at market tops due to emotional decision-making or a lack of a clear framework. This indicator aims to solve that problem by providing an objective, historically informed guide based on Bitcoin Dominance, helping users to prepare before the market makes its decisive moves. It distils complex market dynamics into easily digestible sections.
Key Features & Components
Color-Coded Horizontal Zones: The indicator draws fixed horizontal bands on the BTC.D chart, each representing a distinct phase of the altcoin market cycle.
Descriptive Labels: Each zone is clearly labeled with its strategic meaning (e.g., "Alts are dead," "Danger Zone") and the corresponding BTC.D percentage range, positioned to the right of the price action for clarity.
Consistent Aesthetics: All text within the labels is rendered in white for optimal visibility across the colored zones.
Symbol Restriction: The indicator includes an automatic check to ensure it only draws its visuals when applied specifically to the CRYPTOCAP:BTC.D chart. If applied to another chart, it displays a helpful message and remains invisible to prevent confusion.
Methodology & Interpretation
The indicator's methodology is based on the historical behavior of Bitcoin Dominance during various market cycles, particularly the 2021 bull run. Each zone provides a specific interpretation for altcoin strategy:
Grey Zone (BTC.D 60-70%+): "Alts Are Dead"
Interpretation: When Bitcoin Dominance is in this grey zone (typically above 60%), Bitcoin is king, and capital remains concentrated in BTC. This indicates that alt season is largely inactive or "dead". This phase is generally not conducive for aggressive altcoin trading.
Blue Zone (BTC.D 55-60%): "Alt Season Loading"
Interpretation: As BTC.D drops into this blue zone (below 60%), it signals that the market is "heating up" for altcoins. This is the time to start planning and executing your initial positions in high-conviction large-cap and strong narrative plays, as capital begins to look for more risk.
Green Zone (BTC.D 50-55%): "Alt Season Underway"
Interpretation: Entering this green zone (below 55%) signifies that "real momentum" is building, and alt season is genuinely "underway". Money is actively flowing from Ethereum into large and mid-cap altcoins. If you've positioned correctly, your portfolio should be showing strong gains in this phase.
Orange Zone (BTC.D 45-50%): "Alt Season Ending"
Interpretation: As BTC.D dips into this orange zone (below 50%), it suggests that altcoin dominance is reaching its peak, indicating the "ending" phase of alt season. While euphoria might be high, this is a critical warning zone to prepare for profit-taking, as it's a phase of "peak risk".
Red Zone (BTC.D Below 45%): "Danger Zone - Alts Overheated"
Interpretation: This red zone (below 45%) is the most critical "DANGER ZONE". It historically marks the point of maximum froth and risk, where altcoins are overheated. This is the decisive signal to aggressively take profits, de-risk, and exit positions to preserve your capital before a potential sharp correction. Historically, dominance has gone as low as 39-40% in this phase.
How to Use
Open TradingView and search for the BTC.D symbol to load the Bitcoin Dominance chart and view the indicator.
Double click the indicator to access settings.
Inputs/Settings
The indicator's zone boundaries are set to historically relevant levels for consistency with the Alt Season Blueprint strategy. However, the colors of each zone are fully customizable through the indicator's settings, allowing users to personalize the visual appearance to their preference. You can access these color options in the indicator's "Settings" menu once it's added to your chart.
Disclaimer
This indicator is provided for informational and educational purposes only. It is not financial advice. Trading cryptocurrencies involves substantial risk of loss and is not suitable for every investor. Past performance is not indicative of future results. Always conduct your own research and consult with a qualified financial professional before making any investment decisions.
About the Author
This indicator was developed by Nick from Lab of Crypto.
Release Notes
v1.0 (June 2025): Initial release featuring color-coded horizontal BTC.D zones with descriptive labels, based on Alt Season Blueprint strategy. Includes symbol restriction for correct chart application and consistent white text.
Candle SequenceLooking to easily identify moments of strong market conviction? "Racha Velas" (or your chosen English name like "Consecutive Candles Streak") allows you to visualize clearly and directly sequences of consecutive bullish and bearish candles.
**Key Features:**
* **Real-time Counting:** Displays the number of consecutive candles directly on the chart.
* **Visual Customization:** Adjust the text size and color for optimal visualization.
* **Vertical Offset:** Control the position of the counter to avoid obstructions.
* **Maximum Streaks Table (Optional):** Visualize the largest bullish and bearish streaks found in the chart's history, useful for understanding volatility and price behavior.
* **Easy to Use:** Simply add the indicator to your chart and start analyzing.
This indicator is a valuable tool for traders looking to confirm trends, identify potential exhaustion points, or simply understand price dynamics at a glance. Give it a try and discover the market's streaks!
*****************************************************************************************************
¿Buscas identificar momentos de fuerte convicción del mercado? "Racha Velas" te permite visualizar de forma clara y directa las secuencias de velas consecutivas alcistas y bajistas.
**Características principales:**
* **Conteo en Tiempo Real:** Muestra el número de velas consecutivas directamente en el gráfico.
* **Personalización Visual:** Ajusta el tamaño y color del texto para una visualización óptima.
* **Offset Vertical:** Controla la posición del contador para evitar obstrucciones.
* **Tabla de Rachas Máximas (Opcional):** Visualiza las mayores rachas alcistas y bajistas encontradas en el historial del gráfico, útil para entender la volatilidad y el comportamiento del precio.
* **Fácil de Usar:** Simplemente añade el indicador a tu gráfico y comienza a analizar.
Este indicador es una herramienta valiosa para traders que buscan confirmar tendencias, identificar posibles agotamientos o simplemente entender la dinámica del precio en un vistazo. ¡Pruébalo y descubre las rachas del mercado!
ETF Builder & Backtest System [TradeDots]Create, analyze, and monitor your own custom “ETF-like” portfolio directly on TradingView. This script merges up to 10 different assets with user-defined weightings into a single composite chart, allowing you to see how your personalized portfolio would have performed historically. It is an original tool designed to help traders and investors quickly gauge risk and return profiles without leaving the TradingView platform.
📝 HOW IT WORKS
1. Custom Portfolio Construction
Multiple Assets : Combine up to 10 different stocks, ETFs, cryptocurrencies, or other symbols.
User-Defined Weights : Allocate each asset a percentage weight (e.g., 15% in AAPL, 10% in MSFT, etc.).
Single Composite Value : The script calculates a weighted “ETF-style” price, effectively simulating a merged portfolio curve on your chart.
2. Performance Tracking & Return Analysis
Automatic History Capture : The indicator records each asset’s starting price when it first appears in your chosen date range.
Rolling Updates : As time progresses, all asset prices are continually evaluated and the portfolio value is updated in real time.
Buy & Hold Returns : See how each asset—and the overall portfolio—performed from the “start” date to the most recent bar.
Annualized Return : Automatically calculates CAGR (Compound Annual Growth Rate) to help visualize performance over varying timescales.
3. Table & Visual Output
Performance Table : A comprehensive table displays individual asset returns, annualized returns, and portfolio totals.
Normalized Chart Plot : The composite ETF value is scaled to 100 at the start date, making it easy to compare relative growth or decline.
Optional Time Filter : You can define a specific date range (Start/End Dates) to focus on a particular period or to limit historical data.
⚙️ KEY FEATURES
1. Flexible Asset Selection
Choose any symbols from multiple asset classes. The script will only run calculations when data is available—no need to worry about missing quotes.
2. Dynamic Table Reporting
Start Price for each asset
Percentage Weight in the portfolio
Total Return (%) and Annualized Return (%)
3. Simple Backtesting Logic
This script takes a straightforward Buy & Hold perspective. Once the start date is reached, the portfolio remains static until the end date, so you can quickly assess hypothetical growth.
4. Plot Customization
Toggle the main “ETF” plot on/off.
Alter the visual style for tables and text.
Adjust the time filter to limit or extend your performance measurement window.
🚀 HOW TO USE IT
1. Add the Script
Search for “ETF Builder & Backtest System ” in the Indicators & Strategies tab or manually add it to your chart after saving it in your Pine Editor.
2. Configure Inputs
Enable Time Filter : Choose whether to restrict the analysis to a particular date range.
Start & End Date : Define the period you want to measure performance over (e.g., from 2019-12-31 to 2025-01-01).
Assets & Weights : Enter each symbol and specify a percentage weight (up to 10 assets).
Display Options : Pick where you want the Table to appear and choose background/text colors.
3. Interpret the Table & Plots
Asset Rows : Each asset’s ticker, weighting, start price, and performance metrics.
ETF Total Row : Summarizes total weighting, composite starting value, and overall returns.
Normalized Plot : Tracks growth/decline of the combined portfolio, starting at 100 on the chart.
4. Refine Your Strategy
Compare how different weights or a new mix of assets would have performed over the same period.
Assess if certain assets contribute disproportionately to your returns or volatility.
Use the results to guide allocations in your real trading or paper trading accounts.
❗️LIMITATIONS
1. Buy & Hold Only
This script does not handle rebalancing or partial divestments. Once the portfolio starts, weights remain fixed throughout the chosen timeframe.
2. No Reinvestment Tracking
Dividends or other distributions are not factored into performance.
3. Data Availability
If historical data for a particular asset is unavailable on TradingView, related results may display as “N/A.”
4. Market Regimes & Volatility
Past performance does not guarantee similar future behavior. Markets can change rapidly, which may render historical backtests less predictive over time.
⚠️ RISK DISCLAIMER
Trading and investing carry significant risk and can result in financial loss. The “ETF Builder & Backtest System ” is provided for informational and educational purposes only. It does not constitute financial advice.
Always conduct your own research.
Use proper risk management and position sizing.
Past performance does not guarantee future results.
This script is an original creation by TradeDots, published under the Mozilla Public License 2.0.
Use this indicator as part of a broader trading or investment approach—consider fundamental and technical factors, overall market context, and personal risk tolerance. No trading tool can assure profits; exercise caution and responsibility in all financial decisions.
ZigZag█ Overview
This Pine Script™ library provides a comprehensive implementation of the ZigZag indicator using advanced object-oriented programming techniques. It serves as a developer resource rather than a standalone indicator, enabling Pine Script™ programmers to incorporate sophisticated ZigZag calculations into their own scripts.
Pine Script™ libraries contain reusable code that can be imported into indicators, strategies, and other libraries. For more information, consult the Libraries section of the Pine Script™ User Manual.
█ About the Original
This library is based on TradingView's official ZigZag implementation .
The original code provides a solid foundation with user-defined types and methods for calculating ZigZag pivot points.
█ What is ZigZag?
The ZigZag indicator filters out minor price movements to highlight significant market trends.
It works by:
1. Identifying significant pivot points (local highs and lows)
2. Connecting these points with straight lines
3. Ignoring smaller price movements that fall below a specified threshold
Traders typically use ZigZag for:
- Trend confirmation
- Identifying support and resistance levels
- Pattern recognition (such as Elliott Waves)
- Filtering out market noise
The algorithm identifies pivot points by analyzing price action over a specified number of bars, then only changes direction when price movement exceeds a user-defined percentage threshold.
█ My Enhancements
This modified version extends the original library with several key improvements:
1. Support and Resistance Visualization
- Adds horizontal lines at pivot points
- Customizable line length (offset from pivot)
- Adjustable line width and color
- Option to extend lines to the right edge of the chart
2. Support and Resistance Zones
- Creates semi-transparent zone areas around pivot points
- Customizable width for better visibility of important price levels
- Separate colors for support (lows) and resistance (highs)
- Visual representation of price areas rather than just single lines
3. Zig Zag Lines
- Separate colors for upward and downward ZigZag movements
- Visually distinguishes between bullish and bearish price swings
- Customizable colors for text
- Width customization
4. Enhanced Settings Structure
- Added new fields to the Settings type to support the additional features
- Extended Pivot type with supportResistance and supportResistanceZone fields
- Comprehensive configuration options for visual elements
These enhancements make the ZigZag more useful for technical analysis by clearly highlighting support/resistance levels and zones, and providing clearer visual cues about market direction.
█ Technical Implementation
This library leverages Pine Script™'s user-defined types (UDTs) to create a robust object-oriented architecture:
- Settings : Stores configuration parameters for calculation and display
- Pivot : Represents pivot points with their visual elements and properties
- ZigZag : Manages the overall state and behavior of the indicator
The implementation follows best practices from the Pine Script™ User Manual's Style Guide and uses advanced language features like methods and object references. These UDTs represent Pine Script™'s most advanced feature set, enabling sophisticated data structures and improved code organization.
For newcomers to Pine Script™, it's recommended to understand the language fundamentals before working with the UDT implementation in this library.
█ Usage Example
//@version=6
indicator("ZigZag Example", overlay = true, shorttitle = 'ZZA', max_bars_back = 5000, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500)
import andre_007/ZigZag/1 as ZIG
var group_1 = "ZigZag Settings"
//@variable Draw Zig Zag on the chart.
bool showZigZag = input.bool(true, "Show Zig-Zag Lines", group = group_1, tooltip = "If checked, the Zig Zag will be drawn on the chart.", inline = "1")
// @variable The deviation percentage from the last local high or low required to form a new Zig Zag point.
float deviationInput = input.float(5.0, "Deviation (%)", minval = 0.00001, maxval = 100.0,
tooltip = "The minimum percentage deviation from a previous pivot point required to change the Zig Zag's direction.", group = group_1, inline = "2")
// @variable The number of bars required for pivot detection.
int depthInput = input.int(10, "Depth", minval = 1, tooltip = "The number of bars required for pivot point detection.", group = group_1, inline = "3")
// @variable registerPivot (series bool) Optional. If `true`, the function compares a detected pivot
// point's coordinates to the latest `Pivot` object's `end` chart point, then
// updates the latest `Pivot` instance or adds a new instance to the `ZigZag`
// object's `pivots` array. If `false`, it does not modify the `ZigZag` object's
// data. The default is `true`.
bool allowZigZagOnOneBarInput = input.bool(true, "Allow Zig Zag on One Bar", tooltip = "If checked, the Zig Zag calculation can register a pivot high and pivot low on the same bar.",
group = group_1, inline = "allowZigZagOnOneBar")
var group_2 = "Display Settings"
// @variable The color of the Zig Zag's lines (up).
color lineColorUpInput = input.color(color.green, "Line Colors for Up/Down", group = group_2, inline = "4")
// @variable The color of the Zig Zag's lines (down).
color lineColorDownInput = input.color(color.red, "", group = group_2, inline = "4",
tooltip = "The color of the Zig Zag's lines")
// @variable The width of the Zig Zag's lines.
int lineWidthInput = input.int(1, "Line Width", minval = 1, tooltip = "The width of the Zig Zag's lines.", group = group_2, inline = "w")
// @variable If `true`, the Zig Zag will also display a line connecting the last known pivot to the current `close`.
bool extendInput = input.bool(true, "Extend to Last Bar", tooltip = "If checked, the last pivot will be connected to the current close.",
group = group_1, inline = "5")
// @variable If `true`, the pivot labels will display their price values.
bool showPriceInput = input.bool(true, "Display Reversal Price",
tooltip = "If checked, the pivot labels will display their price values.", group = group_2, inline = "6")
// @variable If `true`, each pivot label will display the volume accumulated since the previous pivot.
bool showVolInput = input.bool(true, "Display Cumulative Volume",
tooltip = "If checked, the pivot labels will display the volume accumulated since the previous pivot.", group = group_2, inline = "7")
// @variable If `true`, each pivot label will display the change in price from the previous pivot.
bool showChgInput = input.bool(true, "Display Reversal Price Change",
tooltip = "If checked, the pivot labels will display the change in price from the previous pivot.", group = group_2, inline = "8")
// @variable Controls whether the labels show price changes as raw values or percentages when `showChgInput` is `true`.
string priceDiffInput = input.string("Absolute", "", options = ,
tooltip = "Controls whether the labels show price changes as raw values or percentages when 'Display Reversal Price Change' is checked.",
group = group_2, inline = "8")
// @variable If `true`, the Zig Zag will display support and resistance lines.
bool showSupportResistanceInput = input.bool(true, "Show Support/Resistance Lines",
tooltip = "If checked, the Zig Zag will display support and resistance lines.", group = group_2, inline = "9")
// @variable The number of bars to extend the support and resistance lines from the last pivot point.
int supportResistanceOffsetInput = input.int(50, "Support/Resistance Offset", minval = 0,
tooltip = "The number of bars to extend the support and resistance lines from the last pivot point.", group = group_2, inline = "10")
// @variable The width of the support and resistance lines.
int supportResistanceWidthInput = input.int(1, "Support/Resistance Width", minval = 1,
tooltip = "The width of the support and resistance lines.", group = group_2, inline = "11")
// @variable The color of the support lines.
color supportColorInput = input.color(color.red, "Support/Resistance Color", group = group_2, inline = "12")
// @variable The color of the resistance lines.
color resistanceColorInput = input.color(color.green, "", group = group_2, inline = "12",
tooltip = "The color of the support/resistance lines.")
// @variable If `true`, the support and resistance lines will be drawn as zones.
bool showSupportResistanceZoneInput = input.bool(true, "Show Support/Resistance Zones",
tooltip = "If checked, the support and resistance lines will be drawn as zones.", group = group_2, inline = "12-1")
// @variable The color of the support zones.
color supportZoneColorInput = input.color(color.new(color.red, 70), "Support Zone Color", group = group_2, inline = "12-2")
// @variable The color of the resistance zones.
color resistanceZoneColorInput = input.color(color.new(color.green, 70), "", group = group_2, inline = "12-2",
tooltip = "The color of the support/resistance zones.")
// @variable The width of the support and resistance zones.
int supportResistanceZoneWidthInput = input.int(10, "Support/Resistance Zone Width", minval = 1,
tooltip = "The width of the support and resistance zones.", group = group_2, inline = "12-3")
// @variable If `true`, the support and resistance lines will extend to the right of the chart.
bool supportResistanceExtendInput = input.bool(false, "Extend to Right",
tooltip = "If checked, the lines will extend to the right of the chart.", group = group_2, inline = "13")
// @variable References a `Settings` instance that defines the `ZigZag` object's calculation and display properties.
var ZIG.Settings settings =
ZIG.Settings.new(
devThreshold = deviationInput,
depth = depthInput,
lineColorUp = lineColorUpInput,
lineColorDown = lineColorDownInput,
textUpColor = lineColorUpInput,
textDownColor = lineColorDownInput,
lineWidth = lineWidthInput,
extendLast = extendInput,
displayReversalPrice = showPriceInput,
displayCumulativeVolume = showVolInput,
displayReversalPriceChange = showChgInput,
differencePriceMode = priceDiffInput,
draw = showZigZag,
allowZigZagOnOneBar = allowZigZagOnOneBarInput,
drawSupportResistance = showSupportResistanceInput,
supportResistanceOffset = supportResistanceOffsetInput,
supportResistanceWidth = supportResistanceWidthInput,
supportColor = supportColorInput,
resistanceColor = resistanceColorInput,
supportResistanceExtend = supportResistanceExtendInput,
supportResistanceZoneWidth = supportResistanceZoneWidthInput,
drawSupportResistanceZone = showSupportResistanceZoneInput,
supportZoneColor = supportZoneColorInput,
resistanceZoneColor = resistanceZoneColorInput
)
// @variable References a `ZigZag` object created using the `settings`.
var ZIG.ZigZag zigZag = ZIG.newInstance(settings)
// Update the `zigZag` on every bar.
zigZag.update()
//#endregion
The example code demonstrates how to create a ZigZag indicator with customizable settings. It:
1. Creates a Settings object with user-defined parameters
2. Instantiates a ZigZag object using these settings
3. Updates the ZigZag on each bar to detect new pivot points
4. Automatically draws lines and labels when pivots are detected
This approach provides maximum flexibility while maintaining readability and ease of use.
Nef33 Forex & Crypto Trading Signals PRO
1. Understanding the Indicator's Context
The indicator generates signals based on confluence (trend, volume, key zones, etc.), but it does not include predefined SL or TP levels. To establish them, we must:
Use dynamic or static support/resistance levels already present in the script.
Incorporate volatility (such as ATR) to adjust the levels based on market conditions.
Define a risk/reward ratio (e.g., 1:2).
2. Options for Determining SL and TP
Below, I provide several ideas based on the tools available in the script:
Stop Loss (SL)
The SL should protect you from adverse movements. You can base it on:
ATR (Volatility): Use the smoothed ATR (atr_smooth) multiplied by a factor (e.g., 1.5 or 2) to set a dynamic SL.
Buy: SL = Entry Price - (atr_smooth * atr_mult).
Sell: SL = Entry Price + (atr_smooth * atr_mult).
Key Zones: Place the SL below a support (for buys) or above a resistance (for sells), using Order Blocks, Fair Value Gaps, or Liquidity Zones.
Buy: SL below the nearest ob_lows or fvg_lows.
Sell: SL above the nearest ob_highs or fvg_highs.
VWAP: Use the daily VWAP (vwap_day) as a critical level.
Buy: SL below vwap_day.
Sell: SL above vwap_day.
Take Profit (TP)
The TP should maximize profits. You can base it on:
Risk/Reward Ratio: Multiply the SL distance by a factor (e.g., 2 or 3).
Buy: TP = Entry Price + (SL Distance * 2).
Sell: TP = Entry Price - (SL Distance * 2).
Key Zones: Target the next resistance (for buys) or support (for sells).
Buy: TP at the next ob_highs, fvg_highs, or liq_zone_high.
Sell: TP at the next ob_lows, fvg_lows, or liq_zone_low.
Ichimoku: Use the cloud levels (Senkou Span A/B) as targets.
Buy: TP at senkou_span_a or senkou_span_b (whichever is higher).
Sell: TP at senkou_span_a or senkou_span_b (whichever is lower).
3. Practical Implementation
Since the script does not automatically draw SL/TP, you can:
Calculate them manually: Observe the chart and use the levels mentioned.
Modify the code: Add SL/TP as labels (label.new) at the moment of the signal.
Here’s an example of how to modify the code to display SL and TP based on ATR with a 1:2 risk/reward ratio:
Modified Code (Signals Section)
Find the lines where the signals (trade_buy and trade_sell) are generated and add the following:
pinescript
// Calculate SL and TP based on ATR
atr_sl_mult = 1.5 // Multiplier for SL
atr_tp_mult = 3.0 // Multiplier for TP (1:2 ratio)
sl_distance = atr_smooth * atr_sl_mult
tp_distance = atr_smooth * atr_tp_mult
if trade_buy
entry_price = close
sl_price = entry_price - sl_distance
tp_price = entry_price + tp_distance
label.new(bar_index, low, "Buy: " + str.tostring(math.round(bull_conditions, 1)), color=color.green, textcolor=color.white, style=label.style_label_up, size=size.tiny)
label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny)
label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_up, size=size.tiny)
if trade_sell
entry_price = close
sl_price = entry_price + sl_distance
tp_price = entry_price - tp_distance
label.new(bar_index, high, "Sell: " + str.tostring(math.round(bear_conditions, 1)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny)
label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_up, size=size.tiny)
label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_down, size=size.tiny)
Code Explanation
SL: Calculated by subtracting/adding sl_distance to the entry price (close) depending on whether it’s a buy or sell.
TP: Calculated with a double distance (tp_distance) for a 1:2 risk/reward ratio.
Visualization: Labels are added to the chart to display SL (red) and TP (blue).
4. Practical Strategy Without Modifying the Code
If you don’t want to modify the script, follow these steps manually:
Entry: Take the trade_buy or trade_sell signal.
SL: Check the smoothed ATR (atr_smooth) on the chart or calculate a fixed level (e.g., 1.5 times the ATR). Also, review nearby key zones (OB, FVG, VWAP).
TP: Define a target based on the next key zone or multiply the SL distance by 2 or 3.
Example:
Buy at 100, ATR = 2.
SL = 100 - (2 * 1.5) = 97.
TP = 100 + (2 * 3) = 106.
5. Recommendations
Test in Demo: Apply this logic in a demo account to adjust the multipliers (atr_sl_mult, atr_tp_mult) based on the market (forex or crypto).
Combine with Zones: If the ATR-based SL is too wide, use the nearest OB or FVG as a reference.
Risk/Reward Ratio: Adjust the TP based on your tolerance (1:1, 1:2, 1:3)
Geometric Momentum Breakout with Monte CarloOverview
This experimental indicator uses geometric trendline analysis combined with momentum and Monte Carlo simulation techniques to help visualize potential breakout areas. It calculates support, resistance, and an aggregated trendline using a custom Geo library (by kaigouthro). The indicator also tracks breakout signals in a way that a new buy signal is triggered only after a sell signal (and vice versa), ensuring no repeated signals in the same direction.
Important:
This script is provided for educational purposes only. It is experimental and should not be used for live trading without proper testing and validation.
Key Features
Trendline Calculation:
Uses the Geo library to compute support and resistance trendlines based on historical high and low prices. The midpoint of these trendlines forms an aggregated trendline.
Momentum Analysis:
Computes the Rate of Change (ROC) to determine momentum. Breakout conditions are met only if the price and momentum exceed a user-defined threshold.
Monte Carlo Simulation:
Simulates future price movements to estimate the probability of bullish or bearish breakouts over a specified horizon.
Signal Tracking:
A persistent variable ensures that once a buy (or sell) signal is triggered, it won’t repeat until the opposite signal occurs.
Geometric Enhancements:
Calculates an aggregated trend angle and channel width (distance between support and resistance), and draws a perpendicular “breakout zone” line.
Table Display:
A built-in table displays key metrics including:
Bullish probability
Bearish probability
Aggregated trend angle (in degrees)
Channel width
Alerts:
Configurable alerts notify when a new buy or sell breakout signal occurs.
Inputs
Resistance Lookback & Support Lookback:
Number of bars to look back for determining resistance and support points.
Momentum Length & Threshold:
Period for ROC calculation and the minimum percentage change required for a breakout confirmation.
Monte Carlo Simulation Parameters:
Simulation Horizon: Number of future bars to simulate.
Simulation Iterations: Number of simulation runs.
Table Position & Text Size:
Customize where the table is displayed on the chart and the size of the text.
How to Use
Add the Script to Your Chart:
Copy the code into the Pine Script editor on TradingView and add it to your chart.
Adjust Settings:
Customize the inputs (e.g., lookback periods, momentum threshold, simulation parameters) to fit your analysis or educational requirements.
Interpret Signals:
A buy signal is plotted as a green triangle below the bar when conditions are met and the state transitions from neutral or sell.
A sell signal is plotted as a red triangle above the bar when conditions are met and the state transitions from neutral or buy.
Alerts are triggered only on the bar where a new signal is generated.
Examine the Table:
The table displays key metrics (breakout probabilities, aggregated trend angle, and channel width) to help evaluate current market conditions.
Disclaimer
This indicator is experimental and provided for educational purposes only. It is not intended as a trading signal or financial advice. Use this script at your own risk, and always perform your own research and testing before using any experimental tools in live trading.
Credit
This indicator uses the Geo library by kaigouthro. Special thanks to Cryptonerds and @Hazzantazzan for their contributions and insights.
12 Month Difference - YoY ComparisonEste script foi desenvolvido para calcular e exibir a variação percentual do preço de um ativo nos últimos 12 meses, de forma simples e visual. Ele utiliza dados históricos de preços e apresenta o resultado diretamente no gráfico, permitindo ao usuário acompanhar a relação entre o valor atual e o valor de 12 meses atrás.
O cálculo é baseado em um período de 12 meses, que equivale a 252 dias úteis no mercado financeiro. O script primeiro identifica o preço atual do ativo e o compara com o preço registrado há exatamente 252 dias úteis. A diferença entre esses dois valores é transformada em uma variação percentual, o que facilita a análise de desempenho do ativo ao longo do período.
Além disso, o script define uma cor para destacar o resultado:
Verde, se a variação percentual for positiva (indicando crescimento).
Vermelho, se a variação for negativa (indicando queda).
O valor calculado é exibido de forma prática no canto inferior direito do gráfico, como uma tabela flutuante. Essa tabela contém o texto "Relação 12M" e o valor percentual correspondente, permitindo uma leitura rápida.
Embora o resultado seja calculado para todos os momentos no gráfico, ele é mostrado apenas como uma tabela no último ponto confirmado da série histórica, ou seja, no momento mais recente com dados disponíveis. Além disso, o script inclui o valor da relação na legenda do gráfico, mas ele está oculto visualmente para evitar sobrecarregar o layout.
Esse indicador é útil para analisar rapidamente o desempenho de um ativo ao longo de um ano, ajudando investidores e analistas a entenderem tendências e mudanças no mercado.
This script was developed to calculate and display the percentage change in the price of an asset over the last 12 months, in a simple and visual way. It uses historical price data and displays the result directly on the chart, allowing the user to monitor the relationship between the current value and the value from 12 months ago.
The calculation is based on a 12-month period, which is equivalent to 252 business days in the financial market. The script first identifies the current price of the asset and compares it with the price recorded exactly 252 business days ago. The difference between these two values is transformed into a percentage change, which makes it easier to analyze the asset's performance over the period.
In addition, the script defines a color to highlight the result:
Green, if the percentage change is positive (indicating growth).
Red, if the change is negative (indicating a decline).
The calculated value is displayed conveniently in the bottom right corner of the chart, as a floating table. This table contains the text "12M Ratio" and the corresponding percentage value, allowing for quick reading.
Although the result is calculated for all points in time on the chart, it is only displayed as a table at the last confirmed point in the historical series, i.e. the most recent point in time with available data. In addition, the script includes the ratio value in the chart legend, but it is visually hidden to avoid cluttering the layout.
This indicator is useful for quickly analyzing the performance of an asset over a year, helping investors and analysts understand trends and changes in the market.
DTS- Dynamic Trend SignalDynamic Trend Signal
The Dynamic Trend Signal indicator is a powerful and highly customizable tool designed for traders who want clear and actionable signals to guide their trading decisions. This indicator leverages the relationship between two moving averages and the current price to provide concise buy/sell recommendations while visually enhancing your chart with professional-grade features.
Key Features:
Actionable Trading Signals:
STRONG BUY / NO SELL: When the price is above both moving averages.
BUY / NO SELL: When the price is above the longer moving average but below the shorter moving average.
NO BUY / SELL: When the price is below the longer moving average but above the shorter moving average.
STRONG SELL / NO BUY: When the price is below both moving averages.
Dynamic Signal Table:
Displays real-time trading signals in a convenient table format.
Automatically updates based on market conditions.
Customizable table position (top-left, top-right, bottom-left, or bottom-right).
Dynamic background and text colors for improved visibility:
Green shades for bullish signals.
Red shades for bearish signals.
Customizable Moving Averages:
Configure each moving average independently:
Choose between Simple Moving Average (SMA) and Exponential Moving Average (EMA).
Set unique lengths, colors, and line thickness for each average.
Default settings:
MA1: Short-term (8-period) with thickness 1.
MA2: Long-term (20-period) with thickness 2.
Optional Crossover Alerts:
Visual and textual alerts for moving average crossovers:
BUY: When the shorter moving average crosses above the longer moving average.
SELL: When the shorter moving average crosses below the longer moving average.
Crossover alerts are disabled by default but can be easily enabled in settings.
Ease of Use:
Intuitive interface with clean and professional visuals.
Fully customizable to fit any trading strategy or chart style.
How It Helps Traders:
The Dynamic Trend Signal simplifies market analysis by removing guesswork and focusing on clear, data-driven signals. Whether you're a beginner looking for straightforward guidance or an experienced trader seeking to enhance your strategy, this indicator provides:
Confidence in decision-making with clear buy/sell signals.
Customization to align with your unique trading approach.
Clarity through visually appealing, color-coded signals and alerts.
Ideal For:
Swing Traders
Day Traders
Trend Followers
Traders looking to integrate a dynamic, rule-based approach to their analysis.
How to Use:
Add the Dynamic Trend Signal indicator to your chart.
Adjust the moving average lengths, types, colors, and thickness to suit your trading strategy.
Monitor the signal table for actionable recommendations.
Optionally enable crossover alerts for real-time buy/sell notifications.
Unlock the power of clear and actionable trading signals with the Dynamic Trend Signal! Add it to your TradingView chart today and take your trading strategy to the next level.
David_candle length with average and candle directionThis indicator,
calculates the difference between the highest and lowest price (High-Low difference) for a specified number of periods and displays it in a table. Here are the functions and details included:
Number of Periods: The user can define the number of periods (e.g., 10) for which the High-Low differences are calculated.
Table Position: The position of the table that displays the results can be selected by the user (top left, top right, bottom left, or bottom right).
High-Low Difference per Candle: For each defined period, the difference between the highest and lowest price of the respective candle is calculated.
Candle Direction: The color of the displayed text in the table changes based on the candle direction:
Green for bullish candles (close price higher than open price).
Red for bearish candles (close price lower than open price).
White for neutral candles (close price equal to open price).
Average: Below the High-Low differences, the average value of the calculated differences is displayed in yellow text.
This indicator is useful for visually analyzing the volatility and movement range within the recent candles by highlighting the average High-Low difference.
Supports & Resistances [UAlgo]The "Supports & Resistances " indicator is designed to identify and visualize key support and resistance levels on the price chart. It utilizes the Average True Range (ATR) and Pivot Points to define the boundaries of S & R zones and considers historical price action to assess the strength of these zones.
🔶 How to Obtain Zones
The script continuously analyzes the price action and identifies potential support and resistance zones based on the following criteria:
Zone Creation: For swing highs, a zone is created with the high price at the zone length as the top and the top minus the Average True Range (ATR) as the bottom. Conversely, for swing lows, the zone is created with the low price at the zone length as the bottom and the low plus the ATR as the top.
Zone Strength Calculation: The script iterates through historical bars within the zone and counts how many times the price (low for support, high for resistance) touched but failed to break entirely through the zone. This count is assigned as the zone's "strength".
Zone Display and Removal: It identifying zones by assigning a "strength" value based on how many times the price has approached but failed to break the zone. This helps prioritize stronger potential support/resistance levels. Only zones exceeding the defined "strength threshold" are visually displayed on the chart. Weaker zones or those broken by price are automatically removed.
🔶 Parameters
Zone Length: Traders can adjust S & R detection sensitivity, length to be used to find pivot points.
Strength Threshold: Set the minimum number of times the price needs to touch but fail to break a zone for it to be considered "strong" and displayed.
Visual Settings: Tailor the appearance of the support/resistance zones by defining separate colors and text size for borders, backgrounds, and zone text.
🔶 Disclaimer
The "Supports & Resistances " indicator is provided for educational and informational purposes only.
It should not be considered as financial advice or a recommendation to buy or sell any financial instrument.
The use of this indicator involves inherent risks, and users should employ their own judgment and conduct their own research before making any trading decisions. Past performance is not indicative of future results.
🔷 Related Scripts
Support and Resistance with Signals
ATR Based Support and Resistance Zones
RSI Screener / Heatmap - By LeviathanThis script allows you to quickly scan the market by displaying the RSI values of up to 280 tickers at once and visualizing them in an easy-to-understand format using labels with heatmap coloring.
📊 Source
The script can display the RSI from a custom timeframe (MTF) and custom length for the following data:
- Price
- OBV (On Balance Volume)
- Open Interest (for crypto tickers)
📋 Ticker Selection
This script uses a different approach for selecting tickers. Instead of inputting them one by one via input.symbol(), you can now copy-paste or edit a list of tickers in the text area window. This approach allows users to easily exchange ticker lists between each other and, for example, create multiple lists of tickers by sector, market cap, etc., and easily input them into the script. Full credit to @allanster for his functions for extracting tickers from the text. Users can switch between 7 groups of 40 tickers each, totaling 280 tickers.
🖥️ Display Types
- Screener with Labels: Each ticker has its own color-coded label located at its RSI value.
- Group Average RSI: A standard RSI plot that displays the average RSI of all tickers in the group.
- RSI Heatmap (coming soon): Color-coded rows displaying current and historical values of tickers.
- RSI Divergence Heatmap (coming soon): Color-coded rows displaying current and historical regular/hidden bullish/bearish divergences for tickers.
🎨 Appearance
Appearance is fully customizable via user inputs, allowing you to change heatmap/gradient colors, zone coloring, and more.
KeitoFX Dynamic Indicator Free vers.This script represents a versatile dynamic indicator called "KeitoFX Dynamic Indicator Free version." It is developed by the author "KeitoFX" and operates as a custom indicator overlaying on financial charts. The indicator utilizes a unique algorithm to dynamically identify bullish and bearish candlestick patterns with specific criteria.
Key Features:
- The indicator visually marks bullish and bearish candlestick patterns using triangle shapes, providing quick visual cues to traders.
- Bullish patterns are detected when the closing price is higher than the opening price and the high and low prices of the candlestick form a narrow range.
- Bearish patterns are identified when the closing price is lower than the opening price, and the high and low prices also form a narrow range.
The indicator incorporates flexible settings that users can customize to fit their trading preferences:
- Users can choose the table's placement, either at the "Top Right," "Middle Right," or "Bottom Right" of the chart.
- Customizable dimensions for the width and height of the table are available.
- Adjustable text size settings ranging from "Auto" to "Huge" are provided for the displayed text.
- A descriptive table containing trading rules and conditions is optionally displayed below the price chart.
Additional Information:
- The indicator's color scheme is harmonious, with shades of purple and neutral tones.
- The "Require FVG" setting influences the pattern detection's sensitivity.
- A dynamic standard deviation is calculated based on the selected displacement settings and historical candle ranges.
- A "FVG" condition enhances pattern accuracy.
- Bullish and bearish pattern detection includes overlapping with other predefined arrays to increase pattern significance.
Note:
This indicator is provided under the Mozilla Public License 2.0, as indicated by the source code comment at the beginning of the script. Users are encouraged to review and comply with the license terms when using this indicator in their trading activities.
Any Screener (Multiple)I suppose it's time to publish something relatively useful :). Here's the first try, Any Screener.
This script is an advanced version of the Alphatrend - Screener that I've coded as a humble "thank you" to Kıvanç Özbilgiç (KivancOzbilgic), who always inspired me.
INTRODUCTION
I developed this version with a unique method because I couldn't find an example with the following features:
It presents the valid signal status of multiple indicators for 15 different symbols in the form of a report.
It indicates how many bars have passed after the signal has occurred.
It indicates the signal direction with dynamic colors and chars.
It can also be used for data (just indicator value) that is only intended to be displayed as text. (Default color is grey).
Long and short signals can optionally be ploted on the chart.
It includes advanced configuration settings.
USAGE OF PANEL
The screener panel is simple to use. On the far left, assets are listed. The names of the indicators appear at the top. In the column with the name of each indicator, the signals of that indicator appear as green or red. The green ones represent the long signals (uptrend) and the red ones represent the short signals (down trend). The numbers in square brackets indicate how many bars have passed after the last signal has occurred. (For example: According to the indicator at the top, when the green bullish triangle and 21 appeared on allign of BTCUSDT, Bitcoin switched to buy signal 21 bars ago. A tip : If the signal distance is 0, the signal occurred at the current bar. It is recommended to wait for the bar to close before entering the trade). Signal distance is an essential output for both manual and algorithmic trading. Users often require mentioned data the most during real time trading.
THE SCRIPT
There are two sections in the script; indicators and screener.
SECTION 1 : "INDICATORS"
In the indicator section, you'll find efficient details about switch methods, normalization, avoid pyramyding (in momentum oscillators) etc. On the other hand, I intended to present a "how to example" of a multiple screener, so it has to include more than one indicator.
OTT : Optimized Trend Tracker is developed by dear Anıl Özekşi, known as the "Old Fisherman" :). In my opinion, it is a pretty cool trend-following indicator that offers a mathematical elegance. This indicator aim to detect the current market trend direction, the indicator detect an up-trending market when the support line is superior to the OTT, and a down trending market when the support line is inferior to the OTT. It has three parameters; moving average type, length and percentage. In this version when the percentage parameter is set to 0.0, OTT turns into the selected moving average. And the signals are generated by the crossing of the closing price. It means, this screener is able to compile and present status of moving averages as well. Also VAR (VIDYA) and EVWMA has been re-designed, both moving averages no longer start at zero at the beginning of the chart (That was a big problem for backtests).
PSAR : J. Welles Wilder's Parabolic Stop And Reversal is an important trend following indicator. PSAR detects an up-trending market when below the market price and a down-trend when above. It can work in harmony with OTT according to the parameter combinations.
OSCILLATORS : Also optional three momentum oscillators have been added. MFI (Money Flow Index), RSI (Relative Strength Index) and STOCH (Stochastic %k). All three oscillators are widely used in markets and quite successful in explaining price movements by using different sources. Oscillators generate long and short signals based on oversold and overbought parameters.
VOLATILITY & TREND : There are three optional indicators. ADX (Average Directional Index), BBW-N (Normalized Bollinger Bandwidth) and REG-N (Normalized value of standard error of linear regression). These three indicators don't generate any long or short signals. Instead, they are used to measure the strength of trends and volatility. Therefore, only the numerical results (0-100) are displayed in screener panel and it is grey. (Note : The second length parameter of ADX has the same value with the first one. Bollinger Bandwith's multiplier is 2.0. REG-N is a variable that developed by Paul Kirshenbaum for Kirshenbaum Bands.)
SECTION 2 : "SCREENER"
The second section processes the main idea. This Screener model is based on generating an integer direction variable from boolean signals. The direction value serves multiple purposes: calculating the distance of signal, determining the color based on the direction, and creating "clean" data for the security function. The final step is to present the obtained data as text to the user.
HOW CAN I "SCREEN" MY CONDITIONS?
That's piece a cake, delete the Section 1 in the script :). If you change totally 11 variables according to your own strategy, you can create your new screener! The method is explained at lines 169-171.
SINCERELY THANKS
To allanster for patiently answering my primitive questions,
And to KivancOzbilgic for mind blowing suggestions (especially while we're drinking Raki) :)...
DISCLEIMER
This is just an indicator, nothing more. The script is for informational and educational purposes only. The use of the script does not constitute professional and/or financial advice. The responsibility for risks associated with the use of the script is solely owned by the user. Do not forget to manage your risk. And trade as safely as possible. Good luck!
Cleaner Screeners LibraryLibrary "cleanscreens"
Screener Panel.
This indicator displays a panel with a list of symbols and their indications.
It can be used as a screener for multiple timess and symbols
in any timeframe and with any indication in any combination.
#### Features
Multiple timeframes
Multiple symbols
Multiple indications per group
Vertical or horizontal layouts
Acceepts External Inputs
Customizable colors with 170 presets included (dark and light)
Customizable icons
Customizable text size and font
Customizable cell size width and height
Customizable frame width and border width
Customizable position
Customizable strong and weak values
Accepts any indicator as input
Only 4 functions to call, easy to use
#### Usage
Initialize the panel with _paneel = cleanscreens.init()
Add groupd with _screener = cleanscreens.Screener(_paneel, "Group Name")
Add indicators to screeener groups with cleanscreens.Indicator(_screener, "Indicator Name", _source)
Update the panel with cleanscreens.display(_paneel)
Thanks @ PineCoders , and the Group members for setting the bar high.
# local setup for methods on our script
import kaigouthro/cleanscreen/1
method Screener ( panel p, string _name) => cleanscreens.Screener ( p, _name)
method Indicator ( screener s , string _tf, string name, float val) => cleanscreens.Indicator ( s , _tf, name, val)
method display ( panel p ) => cleanscreens.display ( p )
init(_themein, loc)
# Panel init
> init a panel for all the screens
Parameters:
_themein (string) : string: Theme Preset Name
loc (int) : int :
1 = left top,
2 = middle top,
3 = right top,
4 = left middle,
5 = middle middle,
6 = right middle,
7 = left bottom,
8 = middle bottom,
9 = right bottom
Returns: panel
method Screener(p, _name)
# Screener - Create a new screener
### Example:
cleanscreens.new(panel, 'Crpyto Screeners')
Namespace types: panel
Parameters:
p (panel)
_name (string)
method Indicator(s, _tf, name, val)
# Indicator - Create a new Indicator
### Example:
cleanscreens.Inidcator('1h', 'RSI', ta.rsi(close, 14))
Namespace types: screener
Parameters:
s (screener)
_tf (string)
name (string)
val (float)
method display(p)
# Display - Display the Panel
### Example:
cleanscreens.display(panel)
Namespace types: panel
Parameters:
p (panel)
indication
single indication for a symbol screener
Fields:
name (series string)
icon (series string)
rating (series string)
value (series float)
col (series color)
tf (series string)
tooltip (series string)
normalized (series float)
init (series bool)
screener
single symbol screener
Fields:
ticker (series string)
icon (series string)
rating (series string)
value (series float)
bg (series color)
fg (series color)
items (indication )
init (series bool)
config
screener configuration
Fields:
strong (series float)
weak (series float)
theme (series string)
vert (series bool)
cellwidth (series float)
cellheight (series float)
textsize (series string)
font (series int)
framewidth (series int)
borders (series int)
position (series string)
icons
screener Icons
Fields:
buy (series string)
sell (series string)
strong (series string)
panel
screener panel object
Fields:
items (screener )
table (series table)
config (config)
theme (theme type from kaigouthro/theme_engine/1)
icons (icons)
Lex_3CR_Functions_Library2Library "Lex_3CR_Functions_Library2"
This is a source code for a technical analysis library in Pine Script language,
designed to identify and mark Bullish and Bearish Three Candle Reversal (3CR) chart patterns.
The library provides three functions to be used in a trading algorithm.
The first function, Bull_3crMarker, adds a dashed line and label to a Bullish 3CR chart pattern, indicating the 3CR point.
The second function, Bear_3crMarker, adds a dashed line and label to a Bearish 3CR chart pattern.
The third function, Bull_3CRlogicals, checks for a Bullish 3CR pattern where the first candle's low is greater than the second candle's low and the second candle's low is less than the third candle's low.
If found, creates a line at the breakout point and a label at the fail point,
if specified. All functions take parameters such as the chart pattern's characteristics and output colors, labels, and markers.
Bull_3crMarker(bulllinearray, barnum, breakpoint, failpointB, failpoint, linecolorbull, bulllabelarray, labelcolor, textcolor, labelon)
Bull_3crMarker Adds a 3CR marker to a Bullish 3CR chart pattern
@description Adds a dashed line and label to a 3CR up chart pattern, indicating the 3CR (3 Candle Reversal) point.
Parameters:
bulllinearray (line )
barnum (int)
breakpoint (float)
failpointB (float )
failpoint (float)
linecolorbull (color)
bulllabelarray (label )
labelcolor (color)
textcolor (color)
labelon (bool)
Bear_3crMarker(bearlinearray, barnum, breakpoint, failpointB, failpoint, linecolorbear, bearlabelarray, labelcolor, textcolor, labelon)
Bear_3crMarker Adds a 3CR marker to a Bearish 3CR chart pattern
@description Adds a dashed line and label to a 3CR down chart pattern, indicating the 3CR (3 Candle Reversal) point.
Parameters:
bearlinearray (line )
barnum (int)
breakpoint (float)
failpointB (float )
failpoint (float)
linecolorbear (color)
bearlabelarray (label )
labelcolor (color)
textcolor (color)
labelon (bool)
Bull_3CRlogicals(low1, low2, low3, bulllinearray, bulllabelarray, failpointB, linecolorbull, labelcolor, textcolor, labelon)
Checks for a bullish three candle reversal pattern and creates a line and label at the breakout point if found
@description Checks for a bullish three candle reversal pattern where the first candle's low is greater than the second candle's low and the second candle's low is less than the third candle's low. If found, creates a line at the breakout point and a label at the fail point, if specified.
Parameters:
low1 (float)
low2 (float)
low3 (float)
bulllinearray (line )
bulllabelarray (label )
failpointB (float )
linecolorbull (color)
labelcolor (color)
textcolor (color)
labelon (bool)
Bear_3CRlogicals(high1, high2, high3, bearlinearray, bearlabelarray, failpointB, linecolorbear, labelcolor, textcolor, labelon)
Checks for a Bearish 3CR pattern and draws a bearish marker on the chart at the appropriate location
@description This function checks for a Bearish 3CR (Three-Candle Reversal) pattern, which is defined as the second candle having a higher high than the first and third candles, and the third candle having a lower high than the first candle. If the pattern is detected, a bearish marker is drawn on the chart at the appropriate location, and an optional label can be added to the marker.
Parameters:
high1 (float)
high2 (float)
high3 (float)
bearlinearray (line )
bearlabelarray (label )
failpointB (float )
linecolorbear (color)
labelcolor (color)
textcolor (color)
labelon (bool)
bullLineDelete(i, bulllinearray, failarray, bulllabelarray, labelon)
Removes a bullish line from a specified position in a line array, and optionally removes a label associated with that line
@description Removes a bullish line from a specified position in a line array, and optionally removes a label associated with that line.
Parameters:
i (int)
bulllinearray (line )
failarray (float )
bulllabelarray (label )
labelon (bool)
bearLineDelete(i, bearlinearray, failarray, bearlabelarray, labelon)
Removes a bearish line from a specified position in a line array, and optionally removes a label associated with that line
@description Removes a bearish line from a specified position in a line array, and optionally removes a label associated with that line.
Parameters:
i (int)
bearlinearray (line )
failarray (float )
bearlabelarray (label )
labelon (bool)
bulloffsetdelete(i, bulllinearray, failarray, bulllabelarray, labelon)
Removes a bullish line from a specified position in a line array, and optionally removes a label associated with that line
@description Removes a bullish line from a specified position in a line array, and optionally removes a label associated with that line.
Parameters:
i (int)
bulllinearray (line )
failarray (float )
bulllabelarray (label )
labelon (bool)
bearoffsetdelete(i, bearlinearray, failarray, bearlabelarray, labelon)
Removes a bearish line from a specified position in a line array, and optionally removes a label associated with that line
@description Removes a bearish line from a specified position in a line array, and optionally removes a label associated with that line.
Parameters:
i (int)
bearlinearray (line )
failarray (float )
bearlabelarray (label )
labelon (bool)
BullEntry_setter(i, bulllinearray, failpointB, entrystopB, entryB, entryboolB)
Checks if the specified value is greater than the break point of any bullish line in an array, and removes that line if true
@description Checks if the s pecified value is greater than the break point of any bullish line in an array, and removes that line if true.
Parameters:
i (int)
bulllinearray (line )
failpointB (float )
entrystopB (float )
entryB (float )
entryboolB (bool )
Bull3CRchecker(close1, bulllinearray, FailpointB, rsiB, bulllabelarray, labelt, bullcolored, directionarray, rsi, secondbullline, entrystopB, entryB, entryboolB)
Parameters:
close1 (float)
bulllinearray (line )
FailpointB (float )
rsiB (float )
bulllabelarray (label )
labelt (bool)
bullcolored (color)
directionarray (label )
rsi (float)
secondbullline (line )
entrystopB (float )
entryB (float )
entryboolB (bool )
Bear3CRchecker(close1, bearlinearray, FailpointB, bearlabelarray, labelt, bearcolored, directionarray, rsi, secondbearline, rsiB)
Checks if the specified value is less than the break point of any bearish line in an array, and removes that line if true
@description Checks if the specified value is less than the break point of any bearish line in an array, and removes that line if true.
Parameters:
close1 (float)
bearlinearray (line )
FailpointB (float )
bearlabelarray (label )
labelt (bool)
bearcolored (color)
directionarray (label )
rsi (float)
secondbearline (line )
rsiB (float )
Bulloffsetcheck(FailpointB, bulllabelarray, linearray, labelt, offset)
Checks the offset of bullish lines and deletes them if they are beyond a certain offset from the current bar index
@description Checks the offset of bullish lines and deletes them if they are beyond a certain offset from the current bar index
Parameters:
FailpointB (float )
bulllabelarray (label )
linearray (line )
labelt (bool)
offset (int)
Bearoffsetcheck(FailpointB, bearlabelarray, linearray, labelt, offset)
Checks the offset of bearish lines and deletes them if they are beyond a certain offset from the current bar index
@description Checks the offset of bearish lines and deletes them if they are beyond a certain offset from the current bar index
Parameters:
FailpointB (float )
bearlabelarray (label )
linearray (line )
labelt (bool)
offset (int)
Bullfailchecker(close1, FailpointB, bulllabelarray, linearray, labelt)
Checks if the current price has crossed above a bullish fail point and deletes the corresponding line and label
@description Checks if the current price has crossed above a bullish fail point and deletes the corresponding line and label
Parameters:
close1 (float)
FailpointB (float )
bulllabelarray (label )
linearray (line )
labelt (bool)
Bearfailchecker(close1, FailpointB, bearlabelarray, linearray, labelt)
Checks for bearish lines that have failed to trigger and removes them from the chart
@description This function checks for bearish lines that have failed to trigger (i.e., where the current price is above the fail point) and removes them from the chart along with any associated label.
Parameters:
close1 (float)
FailpointB (float )
bearlabelarray (label )
linearray (line )
labelt (bool)
rsibullchecker(rsiinput, rsiBull, secondbullline)
Checks for bullish RSI lines that have failed to trigger and removes them from the chart
@description This function checks for bullish RSI lines that have failed to trigger (i.e., where the current RSI value is below the line's trigger level) and removes them from the chart along with any associated line.
Parameters:
rsiinput (float)
rsiBull (float )
secondbullline (line )
rsibearchecker(rsiinput, rsiBear, secondbearline)
Checks for bearish RSI lines that have failed to trigger and removes them from the chart
@description This function checks for bearish RSI lines that have failed to trigger (i.e., where the current RSI value is above the line's trigger level) and removes them from the chart along with any associated line.
Parameters:
rsiinput (float)
rsiBear (float )
secondbearline (line )
Generalized Black-Scholes-Merton Option Pricing Formula [Loxx]Generalized Black-Scholes-Merton Option Pricing Formula is an adaptation of the Black-Scholes-Merton Option Pricing Model including Numerical Greeks aka "Option Sensitivities" and implied volatility calculations. The following information is an excerpt from Espen Gaarder Haug's book "Option Pricing Formulas".
Black-Scholes-Merton Option Pricing
The BSM formula and its binomial counterpart may easily be the most used "probability model/tool" in everyday use — even if we con- sider all other scientific disciplines. Literally tens of thousands of people, including traders, market makers, and salespeople, use option formulas several times a day. Hardly any other area has seen such dramatic growth as the options and derivatives businesses. In this chapter we look at the various versions of the basic option formula. In 1997 Myron Scholes and Robert Merton were awarded the Nobel Prize (The Bank of Sweden Prize in Economic Sciences in Memory of Alfred Nobel). Unfortunately, Fischer Black died of cancer in 1995 before he also would have received the prize.
It is worth mentioning that it was not the option formula itself that Myron Scholes and Robert Merton were awarded the Nobel Prize for, the formula was actually already invented, but rather for the way they derived it — the replicating portfolio argument, continuous- time dynamic delta hedging, as well as making the formula consistent with the capital asset pricing model (CAPM). The continuous dynamic replication argument is unfortunately far from robust. The popularity among traders for using option formulas heavily relies on hedging options with options and on the top of this dynamic delta hedging, see Higgins (1902), Nelson (1904), Mello and Neuhaus (1998), Derman and Taleb (2005), as well as Haug (2006) for more details on this topic. In any case, this book is about option formulas and not so much about how to derive them.
Provided here are the various versions of the Black-Scholes-Merton formula presented in the literature. All formulas in this section are originally derived based on the underlying asset S follows a geometric Brownian motion
dS = mu * S * dt + v * S * dz
where t is the expected instantaneous rate of return on the underlying asset, a is the instantaneous volatility of the rate of return, and dz is a Wiener process.
The formula derived by Black and Scholes (1973) can be used to value a European option on a stock that does not pay dividends before the option's expiration date. Letting c and p denote the price of European call and put options, respectively, the formula states that
c = S * N(d1) - X * e^(-r * T) * N(d2)
p = X * e^(-r * T) * N(d2) - S * N(d1)
where
d1 = (log(S / X) + (r + v^2 / 2) * T) / (v * T^0.5)
d2 = (log(S / X) + (r - v^2 / 2) * T) / (v * T^0.5) = d1 - v * T^0.5
Inputs
S = Stock price.
X = Strike price of option.
T = Time to expiration in years.
r = Risk-free rate
b = Cost of carry
v = Volatility of the underlying asset price
cnd (x) = The cumulative normal distribution function
nd(x) = The standard normal density function
convertingToCCRate(r, cmp ) = Rate compounder
gImpliedVolatilityNR(string CallPutFlag, float S, float x, float T, float r, float b, float cm, float epsilon) = Implied volatility via Newton Raphson
gBlackScholesImpVolBisection(string CallPutFlag, float S, float x, float T, float r, float b, float cm) = implied volatility via bisection
Implied Volatility: The Bisection Method
The Newton-Raphson method requires knowledge of the partial derivative of the option pricing formula with respect to volatility (vega) when searching for the implied volatility. For some options (exotic and American options in particular), vega is not known analytically. The bisection method is an even simpler method to estimate implied volatility when vega is unknown. The bisection method requires two initial volatility estimates (seed values):
1. A "low" estimate of the implied volatility, al, corresponding to an option value, CL
2. A "high" volatility estimate, aH, corresponding to an option value, CH
The option market price, Cm, lies between CL and cH. The bisection estimate is given as the linear interpolation between the two estimates:
v(i + 1) = v(L) + (c(m) - c(L)) * (v(H) - v(L)) / (c(H) - c(L))
Replace v(L) with v(i + 1) if c(v(i + 1)) < c(m), or else replace v(H) with v(i + 1) if c(v(i + 1)) > c(m) until |c(m) - c(v(i + 1))| <= E, at which point v(i + 1) is the implied volatility and E is the desired degree of accuracy.
Implied Volatility: Newton-Raphson Method
The Newton-Raphson method is an efficient way to find the implied volatility of an option contract. It is nothing more than a simple iteration technique for solving one-dimensional nonlinear equations (any introductory textbook in calculus will offer an intuitive explanation). The method seldom uses more than two to three iterations before it converges to the implied volatility. Let
v(i + 1) = v(i) + (c(v(i)) - c(m)) / (dc / dv(i))
until |c(m) - c(v(i + 1))| <= E at which point v(i + 1) is the implied volatility, E is the desired degree of accuracy, c(m) is the market price of the option, and dc/dv(i) is the vega of the option evaluaated at v(i) (the sensitivity of the option value for a small change in volatility).
Numerical Greeks or Greeks by Finite Difference
Analytical Greeks are the standard approach to estimating Delta, Gamma etc... That is what we typically use when we can derive from closed form solutions. Normally, these are well-defined and available in text books. Previously, we relied on closed form solutions for the call or put formulae differentiated with respect to the Black Scholes parameters. When Greeks formulae are difficult to develop or tease out, we can alternatively employ numerical Greeks - sometimes referred to finite difference approximations. A key advantage of numerical Greeks relates to their estimation independent of deriving mathematical Greeks. This could be important when we examine American options where there may not technically exist an exact closed form solution that is straightforward to work with. (via VinegarHill FinanceLabs)
Things to know
Only works on the daily timeframe and for the current source price.
You can adjust the text size to fit the screen
TR_Base_LibLibrary "TR_Base_Lib"
TODO: add library description here
SetHighLowArray()
ChangeHighLowArray()
ShowLabel(_Text, _X, _Y, _Style, _Size, _Yloc, _Color)
TODO: Function to display labels
Parameters:
_Text : TODO: text (series string) Label text.
_X : TODO: x (series int) Bar index.
_Y : TODO: y (series int/float) Price of the label position.
_Style : TODO: style (series string) Label style.
_Size : TODO: size (series string) Label size.
_Yloc : TODO: yloc (series string) Possible values are yloc.price, yloc.abovebar, yloc.belowbar.
_Color : TODO: color (series color) Color of the label border and arrow
Returns: TODO: No return values
GetColor(_Index)
TODO: Function to take out 12 colors in order
Parameters:
_Index : TODO: color number.
Returns: TODO: color code
Tbl_position(_Pos)
TODO: Table display position function
Parameters:
_Pos : TODO: position.
Returns: TODO: Table position
Tbl_position_JP(_Pos)
TODO: テーブル表示位置 日本語表示位置を定数に変換
Parameters:
_Pos : TODO: 日本語表示位置
Returns: TODO: _result:表示位置の定数を返す
TfInMinutes(_Tf)
TODO: 足変換、TimeFrameを分に変換
Parameters:
_Tf : TODO: TimeFrame文字
Returns: TODO: _result:TimeFrameを分に変換した値、_chartTf:チャートのTimeFrameを分に変換した値
TfName_JP(_tf)
TODO: TimeFrameを日本語足名に変換して返す関数 引数がブランクの時はチャートの日本語足名を返す
Parameters:
_tf : TODO: TimeFrame文字
Returns: TODO: _result:日本語足名
DeleteLine()
TODO: Delete Line
Parameters:
: TODO: No parameter
Returns: TODO: No return value
DeleteLabel()
TODO: Delete Label
Parameters:
: TODO: No parameter
Returns: TODO: No return value
