Inizia

Indicatori e strategie

ATR-Stop-SurvivalHow to Use the ATR-Stop-Survival Indicator This indicator was designed to prioritize functionality, removing unnecessary elements and focusing only on what is essential for survival in the financial market. It is easy to understand for both beginner and experienced traders, avoiding visual clutter and unnecessary buttons. Key Features: Uses only 1 indicator on the chart, unlike the previous version, which consumed 2 indicators. Recommended for 4-hour timeframes. If desired, it can also be used in 2-hour or 3-hour intervals. Not recommended for daily, weekly, or monthly timeframes, as they are too long and may lead to significant financial losses due to stop-loss activation. ATR Period Adjustment: The default is 14, but it can be set to 20, if preferred. ATR Multiplier Settings: 1.5 (Conservative) → For calm and stable assets. 2.0 (Aggressive) → For volatile, fast-moving assets with high candle retracement. This indicator is a practical tool that ensures clarity and efficiency, allowing traders to focus only on critical market movements without distractions.
Indicatore Pine Script®
di Canhoto-Medium
Demo GPT - Bollinger Bands StrategyHere’s a professional and detailed description for publishing your **"iNsTiNcT - Bollinger Bands Strategy"** on TradingView: --- ### **Strategy Description: iNsTiNcT - Bollinger Bands Strategy** #### **Overview** This strategy uses **Bollinger Bands®** to identify potential breakouts and trend reversals. It goes **long** when the price closes **above the upper band** (indicating strong bullish momentum) and **exits the position** when the price closes **below the lower band** (signaling a potential reversal or weakness). Unlike traditional Bollinger Bands strategies that may trade both long and short, this version **only takes long positions**, making it suitable for trending markets while avoiding short-side risks. --- ### **Key Features** ✅ **Long-Only Trend Strategy** – Capitalizes on strong uptrends when price breaks above the upper band. ✅ **Clear Exit Signal** – Closes the trade when price falls below the lower band, locking in profits or cutting losses. ✅ **Customizable Parameters** – Adjustable length, standard deviation multiplier, and MA type for different market conditions. ✅ **Date Range Filter** – Test or trade between **January 2018 and December 2069**. ✅ **Professional Risk Management** – **0.1% commission** and **zero slippage** for realistic backtesting. ✅ **Visual Preservation** – Maintains the original Bollinger Bands indicator plots for easy comparison. --- ### **Input Parameters** | Parameter | Description | Default Value | |-----------|------------|--------------| | **Start Date** | Backtest/trade start date | Jan 1, 2018 | | **End Date** | Backtest/trade end date | Dec 31, 2069 | | **Length** | Period for Bollinger Bands calculation | 20 | | **Basis MA Type** | Type of moving average (SMA, EMA, SMMA, WMA, VWMA) | SMA | | **Source** | Price source for calculations | Close | | **StdDev** | Multiplier for standard deviation | 2.0 | | **Offset** | Shifts bands forward/backward | 0 | --- ### **Strategy Logic** #### **Entry Condition (Long)** ➡ **Buy Signal:** `Close > Upper Bollinger Band` #### **Exit Condition (Close Long)** ➡ **Sell Signal:** `Close < Lower Bollinger Band` *(No short trades are taken—only long and flat positions.)* --- ### **How to Use This Strategy** 1. **Apply to Chart** – Works on any timeframe (best on **1H, 4H, or Daily** for swing trading). 2. **Optimize Settings** – Adjust `Length` and `StdDev` for different volatility conditions. 3. **Combine with Filters** – Add volume confirmation or RSI for stronger signals. 4. **Backtest** – Use the **date range** to test different market cycles. --- ### **Risk & Limitations** ⚠ **Works Best in Trending Markets** – May produce false signals in choppy or sideways conditions. ⚠ **Single Indicator Reliance** – Consider adding confirmation filters (e.g., RSI, MACD). ⚠ **No Stop-Loss by Default** – Exits only when price touches the lower band. --- ### **Final Notes** This strategy is designed for **educational and experimental purposes**. Always conduct **forward testing** before live trading. 🔹 **Happy Trading!** 🚀 --- ### **Publishing Tags (For SEO)** `Bollinger Bands Strategy`, `Trend Following`, `Breakout Trading`, `Long-Only Strategy`, `Technical Analysis`, `TradingView Strategy`, `Pine Script v6`, `Swing Trading` --- This description is **clear, engaging, and optimized for TradingView’s audience**. It highlights the strategy’s logic, strengths, and limitations while encouraging users to experiment with it. Would you like any refinements?
Strategia Pine Script®
di iNsTiNcT_2025
TrendWay Strategy📈 TrendWay Strategy – Smart Trend Following Algorithm The TrendWay Strategy is a powerful trend-following algorithm designed for traders who aim to capture sustained market movements with clarity and precision. Built on the principle of combining volatility with trend strength, this strategy utilizes the Average True Range (ATR) and dynamic support/resistance levels to generate high-probability buy and sell signals. 🔍 Key Features: ATR-Based Volatility Filter: Adjusts sensitivity based on market volatility using customizable ATR periods and multipliers. Dynamic Trend Lines: Adapts trailing stop levels based on price action, helping to stay in trends longer and reduce false signals. Clear Entry/Exit Signals: Visual Buy (🔼) and Sell (🔽) markers provide intuitive decision-making on the chart. Signal Highlighting Option: Easily switch between visual trend highlighting or a clean chart view. ⚙️ Parameters: ATR Period (default: 10) ATR Multiplier (default: 3.0) Source (e.g., hl2) Option to toggle ATR method (SMA or standard) Optional signal markers and trend coloring ✅ Suitable For: Swing traders and intraday traders Crypto, forex, and stock markets Traders looking for a reliable way to trail trends and exit on reversal signals Note: Like all strategies, TrendWay should be used in conjunction with sound risk management and market awareness. Always backtest and forward-test before using with live capital.
Strategia Pine Script®
di kriptomist
Deep: 2 Consecutive Candle Color + OB + CPR + MAs🔍 For TradingView or Technical Traders: 1. 💡 All-in-One Price Action Tool Candle Patterns ✅ | Order Blocks ✅ | CPR Levels ✅ | MA Crossovers ✅ One script to filter high-probability trades — test it now! 2. 📊 Precision Meets Price Action This multi-tool Pine Script blends CPR, OB, MA Crossovers, and Candle Color Logic for sharper entries. Optimize your edge — visually. 3. 🎯 Smart Visual Trading Assistant No more clutter — just clean, rule-based signals using: ✔️ OB Detection ✔️ CPR Levels ✔️ Dual MA Crossovers ✔️ 2-Candle Confirmation 🤖 For Algo-Trading / Strategy Developers: 4. 🚀 Power-up your trading algorithm! This script combines institutional price levels (CPR + OB) with price action and trend logic. Test, tweak, trade smarter. 5. 🔧 Built for traders, by traders Detect trends, reversals, and OB zones with a clean overlay. Try this visual assistant on your charts today!
Indicatore Pine Script®
di khardo11
2
StatMetricsLibrary "StatMetrics" A utility library for common statistical indicators and ratios used in technical analysis. Includes Z-Score, correlation, PLF, SRI, Sharpe, Sortino, Omega ratios, and normalization tools. zscore(src, len)   Calculates the Z-score of a series   Parameters:      src (float) : The input price or series (e.g., close)      len (simple int) : The lookback period for mean and standard deviation   Returns: Z-score: number of standard deviations the input is from the mean corr(x, y, len)   Computes Pearson correlation coefficient between two series   Parameters:      x (float) : First series      y (float) : Second series      len (simple int) : Lookback period   Returns: Correlation coefficient between -1 and 1 plf(src, longLen, shortLen, smoothLen)   Calculates the Price Lag Factor (PLF) as the difference between long and short Z-scores, normalized and smoothed   Parameters:      src (float) : Source series (e.g., close)      longLen (simple int) : Long Z-score period      shortLen (simple int) : Short Z-score period      smoothLen (simple int) : Hull MA smoothing length   Returns: Smoothed and normalized PLF oscillator sri(signal, len)   Computes the Statistical Reliability Index (SRI) based on trend persistence   Parameters:      signal (float) : A price or signal series (e.g., smoothed PLF)      len (simple int) : Lookback period for smoothing and deviation   Returns: Normalized trend reliability score sharpe(src, len)   Calculates the Sharpe Ratio over a period   Parameters:      src (float) : Price series (e.g., close)      len (simple int) : Lookback period   Returns: Sharpe ratio value sortino(src, len)   Calculates the Sortino Ratio over a period, using only downside volatility   Parameters:      src (float) : Price series      len (simple int) : Lookback period   Returns: Sortino ratio value omega(src, len)   Calculates the Omega Ratio as the ratio of upside to downside return area   Parameters:      src (float) : Price series      len (simple int) : Lookback period   Returns: Omega ratio value beta(asset, benchmark, len)   Calculates beta coefficient of asset vs benchmark using rolling covariance   Parameters:      asset (float) : Series of the asset (e.g., close)      benchmark (float) : Series of the benchmark (e.g., SPX close)      len (simple int) : Lookback window   Returns: Beta value (slope of linear regression) alpha(asset, benchmark, len)   Calculates rolling alpha of an asset relative to a benchmark   Parameters:      asset (float) : Series of the asset (e.g., close)      benchmark (float) : Series of the benchmark (e.g., SPX close)      len (simple int) : Lookback window   Returns: Alpha value (excess return not explained by Beta exposure) skew(x, len)   Computes skewness of a return series   Parameters:      x (float) : Input series (e.g., returns)      len (simple int) : Lookback period   Returns: Skewness value kurtosis(x, len)   Computes kurtosis of a return series   Parameters:      x (float) : Input series (e.g., returns)      len (simple int) : Lookback period   Returns: Kurtosis value cv(x, len)   Calculates Coefficient of Variation   Parameters:      x (float) : Input series (e.g., returns or prices)      len (simple int) : Lookback period   Returns: CV value autocorr(x, len)   Calculates autocorrelation with 1-lag   Parameters:      x (float) : Series to test      len (simple int) : Lookback window   Returns: Autocorrelation at lag 1 stderr(x, len)   Calculates rolling standard error of a series   Parameters:      x (float) : Input series      len (simple int) : Lookback window   Returns: Standard error (std dev / sqrt(n)) info_ratio(asset, benchmark, len)   Calculates the Information Ratio   Parameters:      asset (float) : Asset price series      benchmark (float) : Benchmark price series      len (simple int) : Lookback period   Returns: Information ratio (alpha / tracking error) tracking_error(asset, benchmark, len)   Measures deviation from benchmark (Tracking Error)   Parameters:      asset (float) : Asset return series      benchmark (float) : Benchmark return series      len (simple int) : Lookback window   Returns: Tracking error value max_drawdown(x, len)   Computes maximum drawdown over a rolling window   Parameters:      x (float) : Price series      len (simple int) : Lookback window   Returns: Rolling max drawdown percentage (as a negative value) zscore_signal(z, ob, os)   Converts Z-score into a 3-level signal   Parameters:      z (float) : Z-score series      ob (float) : Overbought threshold      os (float) : Oversold threshold   Returns: -1, 0, or 1 depending on signal state r_squared(x, y, len)   Calculates rolling R-squared (coefficient of determination)   Parameters:      x (float) : Asset returns      y (float) : Benchmark returns      len (simple int) : Lookback window   Returns: R-squared value (0 to 1) entropy(x, len)   Approximates Shannon entropy using log returns   Parameters:      x (float) : Price series      len (simple int) : Lookback period   Returns: Approximate entropy zreversal(z)   Detects Z-score reversals to the mean   Parameters:      z (float) : Z-score series   Returns: +1 on upward reversal, -1 on downward momentum_rank(x, len)   Calculates relative momentum strength   Parameters:      x (float) : Price series      len (simple int) : Lookback window   Returns: Proportion of lookback where current price is higher normalize(x, len)   Normalizes a series to a 0–1 range over a period   Parameters:      x (float) : The input series      len (simple int) : Lookback period   Returns: Normalized value between 0 and 1 composite_score(score1, score2, score3)   Combines multiple normalized scores into a composite score   Parameters:      score1 (float)      score2 (float)      score3 (float)   Returns: Average composite score
Libreria Pine Script®
di RWCS_LTD
Seasonality Monthly v2.0//@version=5 indicator("dvp Seasonality Monthly v2.0", "Seasonality Monthly v2.0", format = format.volume) if not timeframe.ismonthly and not timeframe.isdaily runtime.error("Please switch timeframe to either Daily or Monthly") i_year_start = input(2000, "Start Year") // i_method = input.string("time", "Method", options= ) i_method = "time_close" i_text_size = input.string(size.auto, "Text Size", ) //--------------------------------------------------------Functions---------------------------------------------------- f_array_stats(array_) => count_pos_ = 0 count_neg_= 0 count_ = 0 sum_ = 0.0 if not na(array_) and array.size(array_) > 0 for i_ = 0 to array.size(array_) - 1 elem_ = array.get(array_, i_) if not na(elem_) sum_ += elem_ count_ += 1 switch elem_ > 0 => count_pos_ += 1 elem_ < 0 => count_neg_ += 1 avg_ = count_ > 0 ? sum_ / count_ : 0.0 //------------------------------------------------------------------------------------------------------------------- = request.security(syminfo.tickerid, "M", [year(time_close), month(time_close), nz(close/close -1)], gaps = barmerge.gaps_on, lookahead = barmerge.lookahead_on ) // month_ = switch i_method // "time" => month(time) // "time_close" => month(time_close) // year_ = switch i_method // "time" => year(time) // "time_close" => year(time_close) var year_start_ = math.max(year_, i_year_start) var no_years_ = year(timenow) - year_start_ + 1 var matrix data_ = matrix.new(no_years_,13,na) var table table_ = na var text_color_ = color.white var bg_color_ = color.gray // chg_pct_ = nz(close/close -1) if year_ >= year_start_ // log.info(str.format("Time {0} Year {1} Month {2} ChgPct {3,number,#.##%}", str.format_time(time_close), year_, month_, chg_pct_)) cur_val_ = nz(matrix.get(data_, year_-year_start_, month_-1)) matrix.set(data_, year_-year_start_, month_-1, cur_val_ + chg_pct_) // if barstate.islast // log.info("ROWS {0}", no_years_ + 7 ) if barstate.islast table_ := table.new(position.middle_center, 13, no_years_ + 7, border_width = 1) // log.info("ROWS {0}", year_ - year_start_ + 7 ) table.cell(table_, 0, 0, str.format("Seasonality Monthly Performance - {0}:{1}", syminfo.prefix, syminfo.ticker), text_color = text_color_, bgcolor = color.blue, text_size = i_text_size) table.merge_cells(table_, 0,0,12,0) row = 1 table.cell(table_, 0, row, "Year", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 1, row, "Jan", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 2, row, "Feb", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 3, row, "Mar", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 4, row, "Apr", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 5, row, "May", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 6, row, "Jun", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 7, row, "Jul", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 8, row, "Aug", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 9, row, "Sep", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 10, row, "Oct", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 11, row, "Nov", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 12, row, "Dec", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) for row_ = 0 to no_years_ - 1 table.cell(table_, 0, 2+row_, str.tostring(row_ + year_start_), text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) for col_ = 0 to 11 val_ = nz(matrix.get(data_, row_, col_),0.0) val_color_ = val_ > 0.0 ? color.green : val_ < 0.0 ? color.red : color.gray table.cell(table_, 1+col_, 2+row_, str.format("{0,number,###.##%}", val_), bgcolor = color.new(val_color_,80), text_color = val_color_, text_size = i_text_size) true //Aggregates row_ = no_years_ + 2 table.cell(table_, 0, row_, "AVG", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 0, row_+1, "SUM", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 0, row_+2, "+ive", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) table.cell(table_, 0, row_+3, "WR", text_color = text_color_, bgcolor = bg_color_, text_size = i_text_size) for col_ = 0 to 11 arr_ = matrix.col(data_, col_) // val_ = array.sum(arr_) = f_array_stats(arr_) val_color_ = sum_ > 0 ? color.green : sum_ < 0 ? color.red : color.gray table.cell(table_, 1+col_, row_, str.format("{0,number,###.##%}", avg_), bgcolor = color.new(val_color_,50), text_color = val_color_, text_size = i_text_size) table.cell(table_, 1+col_, row_+1, str.format("{0,number,###.##%}", sum_), bgcolor = color.new(val_color_,50), text_color = val_color_, text_size = i_text_size) table.cell(table_, 1+col_, row_+2, str.format("{0}/{1}", count_pos_, count_), bgcolor = color.new(val_color_,50), text_color = color.new(color.white, 50), text_size = i_text_size) table.cell(table_, 1+col_, row_+3, str.format("{0,number,#.##%}", count_pos_/count_), bgcolor = color.new(val_color_,50), text_color = color.new(color.white, 50), text_size = i_text_size) true
Indicatore Pine Script®
di dharmeshparikh2
Events assistantThis script gives an ability to manually add events to your charts. There is no option to define events for different pairs. I trade only 2-3 pairs and it helps me a lot. It also draws vertical lines that separate trading period of your selection: daily, weekly and monthly. It is also possible to strictly define trading period. I use trading period every time during backtesting so it is easy to know when to start and when to finish. It also helps to remember that I already written down trading news during selected period.
Indicatore Pine Script®
di monetico
TradeQUO Herrick Payoff RSIHerrick Payoff Index RSI (HPI-RSI) with Signal Line An advanced oscillator that measures market strength not just by price, but by "smart money flow." This indicator is not a typical RSI. Instead of applying the Relative Strength Index to price alone, it calculates it on the cumulative Herrick Payoff Index (HPI) . This creates a unique oscillator that reflects the underlying sentiment and capital flow in the market. What is the Herrick Payoff Index (HPI)? The HPI is a classic sentiment indicator that combines three crucial elements to determine if money is flowing into or out of an asset: Price Change: The direction and momentum of the market. Trading Volume: The conviction behind the price movement. Open Interest (OI): The total number of open contracts (mainly in futures), which indicates if new capital is entering the market. By combining these factors, the HPI provides a more comprehensive picture of market strength than indicators based solely on price. How This Indicator Works The script follows a logical, multi-step process: It calculates the raw Herrick Payoff Index for each bar. It creates a cumulative sum of this index to generate a continuous money flow value. This cumulative value is smoothed with a short-period EMA to reduce noise. The RSI is then applied to this smoothed HPI value. An additional, configurable signal line (moving average) is added to facilitate trading signals. Interpretation and Application You can use this indicator much like a standard RSI, but with the added context of money flow: Overbought/Oversold: Values above 70 suggest an overbought condition, while values below 30 signal an oversold condition. Signal Line Crossovers: A cross of the HPI-RSI line above the signal line can be seen as a bullish signal. A cross below can be seen as a bearish signal. Divergences: Look for divergences between the indicator and the price. A bullish divergence (price makes a lower low, indicator makes a higher low) can indicate an upcoming move to the upside. A bearish divergence (price makes a higher high, indicator makes a lower high) can signal a potential move to the downside. Settings The indicator has been deliberately kept simple: HPI Smoothing Length: Smoothing length (1-5) for the cumulative HPI. RSI Length: The lookback period for the RSI calculation. Signal Line Settings: Here you can enable/disable the signal line and customize its type and length. Display Settings: Adjust the colors of the RSI and signal lines to your preference. This indicator is a tool for analysis and should always be used in combination with other methods and a solid risk management strategy. Happy trading!
Indicatore Pine Script®
di TradeQUO
StochFusion – Multi D-LineStochFusion – Multi D-Line An advanced fusion of four Stochastic %D lines into one powerful oscillator. What it does: Combines four user-weighted Stochastic %D lines—from fastest (9,3) to slowest (60,10)—into a single “Fusion” line that captures both short-term and long-term momentum in one view. How to use: Adjust the four weights (0–10) to emphasize the speed of each %D component. Watch the Fusion line crossing key zones: – Above 80 → overbought condition, potential short entry. – Below 20 → oversold condition, potential long entry. – Around 50 → neutral/midline, watch for trend shifts. Applications: Entry/exit filter: Only take trades when the Fusion line confirms zone exits. Trend confirmation: Analyze slope and cross of the midline for momentum strength. Multi-timeframe alignment: Use on different chart resolutions to find confluence. Tips & Tricks: Default weights give more influence to slower %D—good for trend-focused strategies. Equal weights provide a balanced oscillator that mimics an ensemble average. Experiment: Increase the fastest weight to capture early reversal signals. Developed by: TradeQUO — inspired by DayTraderRadio John “The best momentum indicator is the one you adapt to your own trading rhythm.”
Indicatore Pine Script®
di TradeQUO
Synthetic Euro Index (24/5) - CustomizableThis indicator provides a synthetic Euro index by aggregating major EUR currency pairs to give a comprehensive view of the Euro’s strength or weakness across the forex market. It supports: Multi-timeframe analysis Optional Heikin Ashi candles for smoother trend visualization Customizable input for selecting base pairs and weights Real-time updates to track Euro momentum Ideal for traders who want a single index to quickly assess the Euro’s overall market position without checking multiple pairs separately.
Indicatore Pine Script®
di ialexnwafor124
Quantum RSI (TechnoBlooms)The Next Evolution of Momentum Analysis 📘 Overview Quantum RSI is an advanced momentum oscillator based on Quantum Price Theory, designed as a superior alternative to the traditional RSI. It incorporates a Gaussian decay function to weigh price changes, creating a more responsive and intuitive measure of trend strength. This indicator excels in identifying micro-trends and subtle momentum shifts — especially in narrow or low-volatility environments where standard RSI typically lags or gives false signals. With its enhanced smoothing, intuitive color gradients, and customizable moving average, Quantum RSI offers a powerful tool for traders seeking clarity and precision. 🔍 Key Features • ⚛️ Quantum Momentum Engine: Measures net momentum using quantum-inspired Gaussian decay weighting. • 🎨 Color-Reversed Gradient Zones: o Green (Overbought): Shows momentum strength, not weakness. o Red (Oversold): Highlights momentum exhaustion and potential bounce. • 🧠 Smoothing with MA: Option to apply moving average (SMA/EMA/WMA/SMMA/VWMA) to the Quantum RSI line. • 📊 Levels at 30 / 50 / 70: Standard RSI levels for decision-making guidance. • 📈 Intuitive Visuals: Gradient fills for cleaner interpretation of zones and transitions. 👤 Who Is It For? • Technical traders seeking a modern alternative to RSI. • Quantitative analysts who value precision and smooth signal flow. • Visual traders looking for intuitive, color-coded trend zones. • Traders focused on market microstructure and early trend detection. 💡 Pro Tips • Pair with order blocks, market structure tools, or Fibonacci confluences for high-probability entries. • Use on assets with frequent compression or consolidation, where traditional RSI often misleads. • Combine with volume-based indicators or smart money concepts for added confirmation. • Ideal for sideways markets, false breakouts, or low-volatility zones where typical RSI lags.
Indicatore Pine Script®
di TechnoBlooms