Mulakan

Penunjuk dan strategi

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.
Penunjuk Pine Script®
oleh Canhoto-Medium
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.
Strategi Pine Script®
oleh kriptomist
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
Perpustakaan Pine Script®
oleh 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
Penunjuk Pine Script®
oleh 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.
Penunjuk Pine Script®
oleh 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!
Penunjuk Pine Script®
oleh 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.”
Penunjuk Pine Script®
oleh TradeQUO
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.
Penunjuk Pine Script®
oleh TechnoBlooms
Open Interest-RSI + Funding + Fractal DivergencesIndicator — “Open Interest-RSI + Funding + Fractal Divergences” A multi-factor oscillator that fuses Open-Interest RSI, real-time Funding-Rate data and price/OI fractal divergences. It paints BUY/SELL arrows in its own pane and directly on the price chart, helping you spot spots where crowd positioning, leverage costs and price action contradict each other. 1 Purpose OI-RSI – measures conviction behind position changes instead of price momentum. Funding Rate – shows who pays to hold positions (longs → bull bias, shorts → bear bias). Fractal Divergences – detects HH/LL in price that are not confirmed by OI-RSI. Optional Funding filter – hides signals when funding is already extreme. Together these elements highlight exhaustion points and potential mean-reversion trades. 2 Inputs RSI / Divergence RSI length – default 14. High-OI level / Low-OI level – default 70 / 30. Fractal period n – default 2 (swing width). Fractals to compare – how many past swings to scan, default 3. Max visible arrows – keeps last 50 BUY/SELL arrows for speed. Funding Rate mode – choose FR, Avg Premium, Premium Index, Avg Prem + PI or FR-candle. Visual scale (×) – multiplies raw funding to fit 0-100 oscillator scale (default 10). specify symbol – enable only if funding symbol differs from chart. use lower tf – averages 1-min premiums for smoother intraday view. show table – tiny two-row widget at chart edge. Signal Filter Use Funding filter – ON hides long signals when funding > Buy-threshold and short signals when funding < Sell-threshold. BUY threshold (%) – default 0.00 (raw %). SELL threshold (%) – default 0.00 (raw %). (Enter funding thresholds as raw percentages, e.g. 0.01 = +0.01 %). 3 Visual Outputs Sub-pane Aqua OI-RSI curve with 70 / 50 / 30 reference lines. Funding visualised according to selected mode (green above 0, red below 0, or other). BUY / SELL arrows at oscillator extremes. Price chart Identical BUY / SELL arrows plotted with force_overlay = true above/below candles that formed qualifying fractals. Optional table Shows current asset ticker and latest funding value of the chosen mode. 4 Signal Logic (Summary) Load _OI series and compute RSI. Retrieve Funding-Rate + Premium Index (optionally from lower TF). Find fractal swings (n bars left & right). Check divergence: Bearish – price HH + OI-RSI LH. Bullish – price LL + OI-RSI HL. If Funding-filter enabled, require funding < Buy-thr (long) or > Sell-thr (short). Plot arrows and trigger two built-in alerts (Bearish OI-RSI divergence, Bullish OI-RSI divergence). Signals are fixed once the fractal bar closes; they do not repaint afterwards. 5 How to Use Attach to a liquid perpetual-futures chart (BTC, ETH, major Binance contracts). If _OI or funding series is missing you’ll see an error. Choose timeframe: 15 m – 4 h for intraday; 1 D+ for swing trades. Lower TFs → more signals; raise Fractals to compare or use Funding filter to trim noise. Trade checklist Funding positive and rising → longs overcrowded. Price makes higher high; OI-RSI makes lower high; Funding above Sell-threshold → consider short. Reverse logic for longs. Combine with trend filter (EMA ribbon, SuperTrend, etc.) so you fade only when price is stretched. Automation – set TradingView alerts on the two alertconditions and send to webhooks/bots. Performance tips Keep Max visible arrows ≤ 50. Disable lower-TF premium aggregation if script feels heavy. 6 Limitations Some symbols lack _OI or funding history → script stops with a console message. Binance Premium Index begins mid-2020; older dates show na. Divergences confirm only after n bars (no forward repaint). 7 Changelog v1.0 – 10 Jun 2025 Initial public release. Added price-chart arrows via force_overlay.
Penunjuk Pine Script®
oleh RezzoRedPriest
6
Mark the last 20th candleThis Pine Script indicator, titled "Mark last 20 candle" (short name: "Last 20"), was designed to visually highlight a specific candle on your TradingView chart. What the indicator does: The main function of this script is to exclusively mark the first candle within the most recent window of 20 candles on your chart . Instead of coloring all 20 candles, it precisely identifies and highlights only the beginning of this 20-candle sequence. How the indicator works: Number of candles: The script uses a user-defined variable, num_candles_to_mark , set to 20 , to specify the size of the relevant candle window. Dynamic Identification: The indicator uses the built-in Pine Script variables: bar_index: Represents the index of the currently processed candle (starting at 0). last_bar_index: Represents the index of the very last available candle in your chart (the most recent). Precise Marking: The core logic bar_index == last_bar_index - num_candles_to_mark + 1 calculates the exact index of the candle that is 20 bars before the last_bar_index . If the bar_index of the currently processed candle matches this calculated position, that specific candle is colored blue with 80% transparency. Automatic Shift: As new candles appear on your chart (and last_bar_index increases accordingly), the calculated target index ( last_bar_index - num_candles_to_mark + 1 ) also automatically shifts one bar to the right. This ensures that the marked candle automatically "moves along" and always highlights the first candle of the current 20-candle window. Usage: This indicator is useful for traders who want to visually track the starting point of a fixed window of recent price action. It can help identify patterns or apply strategies relative to that specific candle. To use it, simply copy the provided Pine Script code into your TradingView Pine Editor and add it to your chart. The marked candle will dynamically update as new data arrives.
Penunjuk Pine Script®
oleh x9x5gy7s
Mark last 20 CandleThis Pine Script indicator, titled "Mark last 20 candle" (short name: "Last 20"), was designed to visually highlight a specific candle on your TradingView chart. What the indicator does: The main function of this script is to exclusively mark the first candle within the most recent window of 20 candles on your chart . Instead of coloring all 20 candles, it precisely identifies and highlights only the beginning of this 20-candle sequence. How the indicator works: Number of candles: The script uses a user-defined variable, num_candles_to_mark , set to 20 , to specify the size of the relevant candle window. Dynamic Identification: The indicator uses the built-in Pine Script variables: bar_index: Represents the index of the currently processed candle (starting at 0). last_bar_index: Represents the index of the very last available candle in your chart (the most recent). Precise Marking: The core logic bar_index == last_bar_index - num_candles_to_mark + 1 calculates the exact index of the candle that is 20 bars before the last_bar_index . If the bar_index of the currently processed candle matches this calculated position, that specific candle is colored blue with 80% transparency. Automatic Shift: As new candles appear on your chart (and last_bar_index increases accordingly), the calculated target index ( last_bar_index - num_candles_to_mark + 1 ) also automatically shifts one bar to the right. This ensures that the marked candle automatically "moves along" and always highlights the first candle of the current 20-candle window. Usage: This indicator is useful for traders who want to visually track the starting point of a fixed window of recent price action. It can help identify patterns or apply strategies relative to that specific candle. To use it, simply copy the provided Pine Script code into your TradingView Pine Editor and add it to your chart. The marked candle will dynamically update as new data arrives.
Penunjuk Pine Script®
oleh x9x5gy7s
Zero Lag MACD + Kijun-sen + EOM StrategyThis strategy offers a robust approach to identifying high-probability trading opportunities in the fast-paced cryptocurrency markets, particularly on lower timeframes (e.g., 5-minute). It leverages the synergistic power of three distinct indicators to confirm entries, ensuring a disciplined approach to risk management. Key Components: Zero Lag MACD Enhanced Version 1.2: This core momentum indicator is used to identify precise shifts in trend and momentum, offering reduced lag compared to traditional MACD. Entry signals are filtered based on the histogram's position (below for buys, above for sells) to enhance signal reliability. Kijun-sen (Ichimoku Cloud): Acting as a dynamic support/resistance and trend filter, the Kijun-sen line confirms the prevailing market direction. Long entries are confirmed when price is above Kijun-sen, and short entries when price is below. Ease of Movement (EoM): This volume-based oscillator provides crucial confirmation of price movements by measuring the ease with which price changes. Positive EoM confirms buying pressure, while negative confirms selling pressure, adding an essential layer of validation to trade setups. How it Works: The strategy generates entry signals only when all three indicators align simultaneously: For Long Entries: A Zero Lag MACD buy signal (crossover below histogram) must coincide with price trading above the Kijun-sen, and the Ease of Movement indicator being above its zero line. For Short Entries: A Zero Lag MACD sell signal (crossover above histogram) must coincide with price trading below the Kijun-sen, and the Ease of Movement indicator being below its zero line. Entries are executed at the open of the candle immediately following the signal confirmation. Risk Management: Disciplined risk management is paramount to this strategy: Dynamic Stop-Loss: An Average True Range (ATR) based stop-loss is implemented, set at 2.5 times the current ATR. This adapts the stop-loss distance to market volatility, ensuring sensible risk sizing. Fixed Take-Profit: A consistent Risk-to-Reward (R:R) ratio of 1:1.2 is applied for all trades, promoting stable profit realization. Customization & Optimization: The strategy is built with fully customizable input parameters for each indicator (MACD lengths, Kijun-sen period, ATR period, ATR multiplier, and Risk-to-Reward ratio). This allows users to fine-tune the strategy for different assets, timeframes, and market conditions, facilitating robust backtesting and optimization. Disclaimer: Trading involves substantial risk and is not suitable for all investors. Past performance is not indicative of future results. This strategy is provided for educational and informational purposes only. Always use proper risk management and conduct your own due diligence.
Strategi Pine Script®
oleh danila_leontyev
1
Pivot Points StandardThis Pivot Points indicator calculates and plots pivot levels on your chart according to several popular methods (such as Traditional, Fibonacci, Woodie, Classic, Camarilla, etc.), helping traders identify key support and resistance levels. Pivot points are essential tools for predicting market reversal points, and this indicator does so efficiently in real-time. Features: Pivot Calculation Methods: Traditional, Fibonacci, Woodie, Classic, Camarilla, and more. Customization Options: Adjust the pivot type, number of visible pivots, and other parameters like line color and thickness. Custom Alerts: Receive automatic alerts when the price crosses any pivot level (S1, S2, R1, R2, etc.), helping you react quickly to potential market reversals. Multiple Timeframe Support: Set the timeframe for the pivot calculations and view corresponding pivot levels for that period. Visible Pivot Levels: Choose to show or hide the pivot levels directly on the chart, with the option to display the exact price of each level. Flexible Label Positioning: Select whether pivot labels should appear on the left or right side of the pivot line. Benefits: Facilitates Decision-Making: Pivot levels help identify key zones where price is likely to reverse or stay within a range. Real-Time Alerts: Alerts notify you as soon as the price crosses any key pivot level, enabling you to make quick and precise decisions without constantly monitoring the chart. Customization: Easily adjust the indicator to suit your trading style and visual preferences. Ideal For: Traders looking for technical analysis tools to identify key market levels. Those who want to receive automatic alerts about pivot level crossovers to streamline decision-making. Investors using pivot analysis in their trading strategy to determine entry or exit points.
Penunjuk Pine Script®
oleh AMarco1981
HA EMA Cross MTF Strategy + ATR SL/TP + Visuals📜 Strategy Description: HA EMA Cross MTF Strategy + ATR SL/TP + Visuals Hello Traders, This is a multi-timeframe, Heikin Ashi-based trend-following strategy that integrates EMA crossovers and ATR-driven exits. The goal is to filter out noise, confirm directional bias using higher timeframe structure, and manage risk through volatility-adaptive exits. 🔍 How the Strategy Works * Heikin Ashi candles help smooth out minor price fluctuations, allowing for clearer trend detection. * A Fast EMA crossing above or below a Slow EMA determines the local trend bias. * A Higher Timeframe Heikin Ashi confirmation is used to validate entries only when both timeframes agree in direction. * Session filters can restrict trading to custom hours (e.g., U.S. market open). ⚙️ Risk Management Features This strategy includes optional ATR-based Stop-Loss and Take-Profit logic, designed to adapt dynamically to market volatility: * ATR Stop-Loss: Based on a user-defined multiplier (default: 1.5×ATR) * ATR Take-Profit: Based on a separate multiplier (default: 2.5×ATR) * Users can toggle this logic on/off and customize ATR length and multipliers in the settings. 📊 Visual Aids Included To help understand market behavior and trade execution visually, the script includes: * Entry arrows (long and short) * Real-time Fast EMA / Slow EMA overlays * Stop-Loss / Take-Profit level plots * Optional Heikin Ashi Close line for trend visualization 🔧 Customization Parameters Users can adjust: * EMA periods (fast and slow) * ATR period and multipliers for SL/TP * Session time filters * Higher timeframe input * Toggle ATR logic and visual overlays 🧪 Backtest Defaults (for reference only) * Initial Capital: $10,000 * Order Size: 100% of equity * Slippage: 1 tick * Commission: 0.075% * Recommended Timeframe: 1H or 15min * Minimum Trades Suggested: 100+ * All these values can be adjusted in the strategy settings panel. ⚠️ Disclaimer This strategy is provided for educational and research purposes only. It does not constitute financial advice, nor does it guarantee future performance. Please forward-test and adapt to your own risk tolerance before using in live trading. This strategy is fully open-source and editable. Feel free to customize it for your use case and timeframes.
Strategi Pine Script®
oleh AIScripts
Multi-Timeframe Price Action AnalysisMulti-Timeframe Price Action Analysis This indicator analyzes price action across multiple timeframes to determine bullish and bearish signals. It creates a dashboard showing how price interacts with previous candles' highs and lows. Features - Analyzes 4 customizable timeframes simultaneously - Detects when price: -- Grabs lows and comes back inside (bullish) -- Grabs highs and comes back inside (bearish) -- Grabs both highs and lows -- Moves above previous high -- Moves below previous low -- Calculates bullish/bearish percentages for each timeframe -- Visual dashboard with color-coded signals Adjustable confirmation settings -- Settings -- Customize timeframes (default: 15min, 1H, 4H, D) -- Toggle confirmation waiting -- Set number of confirmation candles This is a very rudimentary version.. I will make a more robust version soon For it to be considered a "grab" the current price must be within the previous candle's range.. This also does not focus on candle closures just highs and lows Also note that this is a little aggressive in that it does not require a bullish close for example to be considered bullish, a bearish close inside the previous candle is considered valid, this is to handle the morning stars that have a slightly bearish close in middle candle etc.. obviously do not rely on this indicator.. look at the price action and determine if you think its worth taking.. Same goes for bullish closes inside previous candle after grabbing highs..
Penunjuk Pine Script®
oleh steamedTrash