ابدأ الآن

ابحث في النصوص البرمجية عن "文华财经tick价格"

BIN Based Support and Resistance [SS]This indicator presents a version of an alternative way to determine support and resistance, using a method called "Bins". Bins provide for a flexible and interesting way to determine support and resistance levels. First off, let's discuss BINS: Bins are ranges or containers into which your data points can be sorted. For example, if you're grouping ages, you might have bins like 0–18, 19–35, 36–50, and 51+. Any data point within these intervals gets placed in the corresponding bin. Binning simplifies complex data sets by grouping values into categories. This is useful for such things as Visualizing data in histograms or bar charts. Reducing noise and highlighting trends. This indicator groups the price action into 10 separate bins. It determines the Support / Resistance level by averaging the values in the Bins to find an iteration of the "central tendency" or average reoccurring value. Pros and Cons Since this is a different approach to support and resistance, I think its important to highlight some of the pros and advantages, but also be open about the cons. First off the PROS Bin Based Support and Resistance Levels dynamically adjust to ranges as opposed to hard / fast peaks and valleys. This makes them better at analyzing price action vs simply drawing lines at random peaks and valleys. Because Bins are analyzing ALL PA within a period's max and min range, Bin Support and Resistance can actually be used similar to Volume profile, where you are able to identify a pseudo-POC, or areas where price tends to consolidate. Take a look at this example on SPY: You can see these 2 SR lines are close together. This represents that this general price range is an area where price likes to accumulate/consolidate. You can see the SPY ended up coming back to this range and consolidating there for a bit. This is a strength of using a BIN based approach to calculating support and resistance, because as indicated before, it looks at price action vs peaks and valleys. As a tip, these areas are areas you want to wait for a break in one direction or the other. The indicator provides for backtest results of the support and resistance lines, to see how many times certain areas acted as resistance or support. Because this is analyzing and distributing PA evenly throughout the period's max and min, the indicator can tell you which areas tend to have higher rejection zones and which have higher support zones.   Now the CONS Because bin based SR take an average approach, the SR lines can sometimes be slightly broken before the ticker finds rejection: To combat this, make sure there is confirmed support. How the indicator actually backtests these lines is by waiting to see if the ticker has 3 consecutive closes above the support line or below the resistance line. So these are things to be mindful of. It doesn't consider pivots. Most support and resistance indicators either identify max and min peaks and valleys or use pivot points. Pivot points are a great way to identify peaks and valleys and thus by extension support and resistance. However, this is also somewhat of a strength, as using BINS forces the indicator to consider ALL price action and not just the extremes (highs and lows). Can be slightly skewed in highly volatile environments. Any time there is a massive drop or rally, it can skew the indicator to give extreme ranges to both ends. For example, the Tariff news collapse on ES1!: Owning to limitations in lookback length, sometimes the min and max range can be exceeded and other traditional areas of support / resistance is where a ticker will find support. Using the indicator Here are some basic use/functionalities of the indicator: Selecting display of backtest results: You can select to have the backtest results shown in a table: Or directly on the lines: Inversely, you can toggle them off completely: You can modify the lookback length. The suggested lookback length is between 250 to 500 candles on smaller timeframes. I also suggest 252 on daily timeframes (which represents 1 trading year). And that's the indicator! It is very easy to use, so you should pick it up in no time! Enjoy and as always, 🚀🚀 safe trades! 🚀🚀
مؤشر Pine Script®
من ‎Steversteves‎
16
Cartera SuperTrends v4 PublicDescription This script creates a screener with a list of ETFs ordered by their average ROC in three different periods representing 4, 6 and 8 months by default. The ETF BIL is always included as a reference. The previous average ROC value shows the calculation using the closing price from last month. The current average ROC value shows the calculation using the current price. The previous average column background color represents if the ETF average ROC is positive or negative. The current average column background color represents if the ETF average ROC is positive or negative. The current average column letters color represents if the current ETF average ROC is improving or not from the previous month. Changes from V2 to V3 Added the option to make the calculation monthly, weekly or daily Changes from V3 to V4 Adding up to 25 symbols Highlight the number of tickers selected Highlight the sorted column Complete refactor of the code using a matrix of arrays Options The options available are: Make the calculation monthly, weekly or daily Adjust Data for Dividends Manual calculation instead of using ta.roc function Sort table Sort table by the previous average ROC or the current average ROC Number of tickers selected to highlight First Period in months, weeks or days Second Period in months, weeks or days Third Period in months, weeks or days Select the assets (max 25) Usage Just add the indicator to your favorite indicators and then add it to your chart.
مؤشر Pine Script®
من ‎RoberGV‎
1
Casa_VolumeProfileSessionLibrary "Casa_VolumeProfileSession" Analyzes price and volume during regular trading hours to provide a session volume profile, including Point of Control (POC), Value Area High (VAH), and Value Area Low (VAL). Calculates and displays these levels historically and for the developing session. Offers customizable visualization options for the Value Area, POC, histogram, and labels. Uses lower timeframe data for increased accuracy and supports futures sessions. The number of rows used for the volume profile can be fixed or dynamically calculated based on the session's price range and the instrument's minimum tick increment, providing optimal resolution. calculateEffectiveRows(configuredRows, dayHigh, dayLow)   Determines the optimal number of rows for the volume profile, either using the configured value or calculating dynamically based on price range and tick size   Parameters:      configuredRows (int) : User-specified number of rows (0 means auto-calculate)      dayHigh (float) : Highest price of the session      dayLow (float) : Lowest price of the session   Returns: The number of rows to use for the volume profile debug(vp, position)   Helper function to write some information about the supplied SVP object to the screen in a table.   Parameters:      vp (Object) : The SVP object to debug      position (string) : The position.* to place the table. Defaults to position.bottom_center getLowerTimeframe()   Depending on the timeframe of the chart, determines a lower timeframe to grab volume data from for the analysis   Returns: The timeframe string to fetch volume for get(volumeProfile, lowerTimeframeHigh, lowerTimeframeLow, lowerTimeframeVolume, lowerTimeframeTime, lowerTimeframeSessionIsMarket)   Populated the provided SessionVolumeProfile object with vp data on the session.   Parameters:      volumeProfile (Object) : The SessionVolumeProfile object to populate      lowerTimeframeHigh (array) : The lower timeframe high values      lowerTimeframeLow (array) : The lower timeframe low values      lowerTimeframeVolume (array) : The lower timeframe volume values      lowerTimeframeTime (array) : The lower timeframe time values      lowerTimeframeSessionIsMarket (array) : The lower timeframe session.ismarket values (that are futures-friendly) drawPriorValueAreas(todaySessionVolumeProfile, extendYesterdayOverToday, showLabels, labelSize, pocColor, pocStyle, pocWidth, vahlColor, vahlStyle, vahlWidth, vaColor)   Given a SessionVolumeProfile Object, will render the historical value areas for that object.   Parameters:      todaySessionVolumeProfile (Object) : The SessionVolumeProfile Object to draw      extendYesterdayOverToday (bool) : Defaults to true      showLabels (bool) : Defaults to true      labelSize (string) : Defaults to size.small      pocColor (color) : Defaults to #e500a4      pocStyle (string) : Defaults to line.style_solid      pocWidth (int) : Defaults to 1      vahlColor (color) : The color of the value area high/low lines. Defaults to #1592e6      vahlStyle (string) : The style of the value area high/low lines. Defaults to line.style_solid      vahlWidth (int) : The width of the value area high/low lines. Defaults to 1      vaColor (color) : The color of the value area background. Defaults to #00bbf911) drawHistogram(volumeProfile, bgColor, showVolumeOnHistogram)   Given a SessionVolumeProfile object, will render the histogram for that object.   Parameters:      volumeProfile (Object) : The SessionVolumeProfile object to draw      bgColor (color) : The baseline color to use for the histogram. Defaults to #00bbf9      showVolumeOnHistogram (bool) : Show the volume amount on the histogram bars. Defaults to false. Object   Object Contains all settings and calculated values for a Volume Profile Session analysis   Fields:      numberOfRows (series int) : Number of price levels to divide the range into. If set to 0, auto-calculates based on price range and tick size      valueAreaCoverage (series int) : Percentage of total volume to include in the Value Area (default 70%)      trackDevelopingVa (series bool) : Whether to calculate and display the Value Area as it develops during the session      valueAreaHigh (series float) : Upper boundary of the Value Area - price level containing specified % of volume      pointOfControl (series float) : Price level with the highest volume concentration      valueAreaLow (series float) : Lower boundary of the Value Area      startTime (series int) : Session start time in Unix timestamp format      endTime (series int) : Session end time in Unix timestamp format      dayHigh (series float) : Highest price of the session      dayLow (series float) : Lowest price of the session      step (series float) : Size of each price row (calculated as price range divided by number of rows)      pointOfControlLevel (series int) : Index of the row containing the Point of Control      valueAreaHighLevel (series int) : Index of the row containing the Value Area High      valueAreaLowLevel (series int) : Index of the row containing the Value Area Low      lastTime (series int) : Tracks the most recent timestamp processed      volumeRows (map) : Stores volume data for each price level row (key=row number, value=volume)      ltfSessionHighs (array) : Stores high prices from lower timeframe data      ltfSessionLows (array) : Stores low prices from lower timeframe data      ltfSessionVols (array) : Stores volume data from lower timeframe data
مكتبة Pine Script®
من ‎Mupsje‎
1
TradFi Fundamentals: Momentum Trading with Macroeconomic DataIntroduction This indicator combines traditional price momentum with key macroeconomic data. By retrieving GDP, inflation, unemployment, and interest rates using security calls, the script automatically adapts to the latest economic data. The goal is to blend technical analysis with fundamental insights to generate a more robust momentum signal. Original Research Paper by Mohit Apte, B. Tech Scholar, Department of Computer Science and Engineering, COEP Technological University, Pune, India Link to paper Explanation Price Momentum Calculation: The indicator computes price momentum as the percentage change in price over a configurable lookback period (default is 50 days). This raw momentum is then normalized using a rolling simple moving average and standard deviation over a defined period (default 200 days) to ensure comparability with the economic indicators. Fetching and Normalizing Economic Data: Instead of manually inputting economic values, the script uses TradingView’s security function to retrieve: GDP from ticker "GDP" Inflation (CPI) from ticker "USCCPI" Unemployment rate from ticker "UNRATE" Interest rates from ticker "USINTR" Each series is normalized over a configurable normalization period (default 200 days) by subtracting its moving average and dividing by its standard deviation. This standardization converts each economic indicator into a z-score for direct integration into the momentum score. Combined Momentum Score: The normalized price momentum and economic indicators are each multiplied by user-defined weights (default: 50% price momentum, 20% GDP, and 10% each for inflation, unemployment, and interest rates). The weighted components are then summed to form a comprehensive momentum score. A horizontal zero line is plotted for reference. Trading Signals: Buy signals are generated when the combined momentum score crosses above zero, and sell signals occur when it crosses below zero. Visual markers are added to the chart to assist with trade timing, and alert conditions are provided for automated notifications. Settings Price Momentum Lookback: Defines the period (in days) used to compute the raw price momentum. Normalization Period for Price Momentum: Sets the window over which the price momentum is normalized. Normalization Period for Economic Data: Sets the window over which each macroeconomic series is normalized. Weights: Adjust the influence of each component (price momentum, GDP, inflation, unemployment, and interest rate) on the overall momentum score. Conclusion This implementation leverages TradingView’s economic data feeds to integrate real-time macroeconomic data into a momentum trading strategy. By normalizing and weighting both technical and economic inputs, the indicator offers traders a more holistic view of market conditions. The enhanced momentum signal provides additional context to traditional momentum analysis, potentially leading to more informed trading decisions and improved risk management. The next script I release will be an improved version of this that I have added my own flavor to, improving the signals.
مؤشر Pine Script®
من ‎theheirophant‎
Volume Delta with Bollinger Bands [EMA]TL;DR This indicator displays a “Volume Delta” candle chart based on a lower timeframe approximation of up vs. down volume. Bollinger Bands (using an EMA and a configurable standard deviation multiplier) highlight when Volume Delta exceeds typical volatility thresholds. Green bars will darken when Volume Delta is above the upper Bollinger band, and red bars will darken when Volume Delta is below the lower Bollinger band. You can optionally include wicks in the Bollinger calculations. Note : TradingView uses tick-based volume data, so these values may not precisely match true market orders. What Is Volume Delta ? • Volume Delta is a metric that identifies buying vs. selling activity in a market by distinguishing between orders transacting at the ask (buy volume) and orders transacting at the bid (sell volume). • A positive Volume Delta indicates more buy volume during a bar, while a negative Volume Delta indicates more sell volume. How TradingView Calculates Volume Delta • TradingView relies on tick data to approximate up/down volume. This may not perfectly capture true order-flow distribution, particularly on higher timeframes or illiquid symbols. • While it can provide useful insights into volume flow, keep in mind the underlying data’s limitations. Key Features of This Indicator 1. Automatic or Custom Lower Timeframe Data • The script can automatically select a lower timeframe for Volume Delta, or you can manually specify one in the settings. 2. Bollinger Bands on Volume Delta • Uses an EMA of the Volume Delta (or a wick-based average) and calculates a standard deviation. • The upper and lower bands highlight when activity deviates from typical volatility. 3. Configurable Wick Inclusion • Decide whether to use only the “close” (lastVolume) of the Volume Delta bar or the average of its wicks ((maxVolume + minVolume) / 2) for Bollinger calculations. 4. Dynamic Bar Colors • Positive Volume Delta bars turn dark green if they exceed the upper Bollinger band, otherwise lighter green . • Negative Volume Delta bars turn dark red if they fall below the lower Bollinger band, otherwise lighter red . How To Use 1. Add the Indicator to Your Chart • Apply it to any symbol and timeframe in TradingView. • Configure the lower timeframe for Volume Delta if desired. 2. Adjust Bollinger Settings • Bollinger Length defines the EMA and standard deviation period. • Bollinger Multiplier sets how far the bands lie from the EMA. 3. Choose Whether To Use Wicks • Toggle to use the average of high/low for a potentially more volatile reading. • Turn it off to rely solely on the Volume Delta “close.” 4. Interpret the Signals • Dark Green Above the Upper Band : Suggests strong buying pressure above normal. • Lighter Green : Positive but within typical volatility bounds. • Dark Red Below the Lower Band : Suggests strong selling pressure below normal. • Lighter Red : Negative but within typical volatility. Important Caveats • TradingView Volume Data : Tick-based and aggregated data may not reflect actual order-flow precisely. • Context Matters : Combine Volume Delta with other forms of analysis (price action, support/resistance, etc.) to form a more comprehensive strategy.
مؤشر Pine Script®
من ‎itisfilipe‎
Milvetti_TraderPost_LibraryLibrary "Milvetti_TraderPost_Library" This library has methods that provide practical signal transmission for traderpost.Developed By Milvetti cancelOrders(symbol)   This method generates a signal in JSON format that cancels all orders for the specified pair. (If you want to cancel stop loss and takeprofit orders together, use the “exitOrder” method.   Parameters:      symbol (string) exitOrders(symbol)   This method generates a signal in JSON format that close all orders for the specified pair.   Parameters:      symbol (string) createOrder(ticker, positionType, orderType, entryPrice, signalPrice, qtyType, qty, stopLoss, stopType, stopValue, takeProfit, profitType, profitValue, timeInForce)   This function is designed to send buy or sell orders to traderpost. It can create customized orders by flexibly specifying parameters such as order type, position type, entry price, quantity calculation method, stop-loss, and take-profit. The purpose of the function is to consolidate all necessary details for opening a position into a single structure and present it as a structured JSON output. This format can be sent to trading platforms via webhooks.   Parameters:      ticker (string) : The ticker symbol of the instrument. Default value is the current chart's ticker (syminfo.ticker).      positionType (string) : Determines the type of order (e.g., "long" or "buy" for buying and "short" or "sell" for selling).      orderType (string) : Defines the order type for execution. Options: "market", "limit", "stop". Default is "market"      entryPrice (float) : The price level for entry orders. Only applicable for limit or stop orders. Default is 0 (market orders ignore this).      signalPrice (float) : Optional. Only necessary when using relative take profit or stop losses, and the broker does not support fetching quotes to perform the calculation. Default is 0      qtyType (string) : Determines how the order quantity is calculated. Options: "fixed_quantity", "dollar_amount", "percent_of_equity", "percent_of_position".      qty (float) : Quantity value. Can represent units of shares/contracts or a dollar amount, depending on qtyType.      stopLoss (bool) : Enable or disable stop-loss functionality. Set to `true` to activate.      stopType (string) : Specifies the stop-loss calculation type. Options: percent, "amount", "stopPrice", "trailPercent", "trailAmount". Default is "stopPrice"      stopValue (float) : Stop-loss value based on stopType. Can be a percentage, dollar amount, or a specific stop price. Default is "stopPrice"      takeProfit (bool) : Enable or disable take-profit functionality. Set to `true` to activate.      profitType (string) : Specifies the take-profit calculation type. Options: "percent", "amount", "limitPrice". Default is "limitPrice"      profitValue (float) : Take-profit value based on profitType. Can be a percentage, dollar amount, or a specific limit price. Default is 0      timeInForce (string) : The time in force for your order. Options: day, gtc, opg, cls, ioc and fok   Returns: Return result in Json format. addTsl(symbol, stopType, stopValue, price)   This method adds trailing stop loss to the current position. “Price” is the trailing stop loss starting level. You can leave price blank if you want it to start immediately   Parameters:      symbol (string)      stopType (string) : Specifies the trailing stoploss calculation type. Options: "trailPercent", "trailAmount".      stopValue (float) : Stop-loss value based on stopType. Can be a percentage, dollar amount.      price (float) : The trailing stop loss starting level. You can leave price blank if you want it to start immediately. Default is current price.
مكتبة Pine Script®
من ‎Milvetti‎
Swing High/Low Pivots Strategy [LV]The Swing High/Low Pivots Strategy was developed as a counter-momentum trading tool. The strategy is suitable for any market and the default values used in the input settings menu are set for Bitcoin (best on 15min). These values, expressed in minimum ticks (or pips if symbol is Forex) make this tool perfectly adaptable to every symbol and/or timeframe. Check tooltips in the settings menu for more details about every user input. STRTEGY ENTRY & EXIT MECHANISMS: Trades Entry based on the detection of swing highs and lows for short and long entries respectively, validated by: - Limit orders placed after each new pivot level confirmation - Moving averages trend filter (if enabled) - No active trade currently open Trades Exit when the price reaches take-profit or stop-loss level as defined in the settings menu. A double entry/second take-profit level can be enabled for partial exits, with dynamic stop-loss adjustment for the remaining position. Enhanced Trade Precision: By limiting entries to confirmed swing high (HH, LH) or swing low (HL, LL) pivot points, the strategy ensures that trades occur at levels of significant price reversals. This precision reduces the likelihood of entering trades in the midst of a trend or during uncertain price action. Risk Management Optimization: The strategy incorporates clearly defined stop-loss (SL) and take-profit (TP) levels derived from the pivot points. This structured approach minimizes potential losses while locking in profits, which is critical for consistent performance in volatile markets. Trend Filtering for Better Entry: The use of a configurable moving average filter adds a layer of trend validation. This prevents entering trades against the dominant market trend, increasing the probability of success for each trade. Avoidance of Noise: The lookback period (length parameter) confirms pivots only after a set number of bars, effectively filtering out market noise and ensuring that entries are based on reliable, well-defined price movements. Adaptability Across Markets: The strategy is versatile and can be applied across different markets (Forex, stocks, crypto) due to its dynamic use of ticks and pips converters. It adapts seamlessly to varying price scales and asset types. Dual Quantity Entries: The original and optionnal double-entry mechanism allows traders to capture both short-term and extended profits by scaling out of positions. This adaptive approach caters to varying risk appetites and market conditions. Clear Visualization: The plotted pivot points, entry limits, SL, and TP levels provide visual clarity, making it easy for traders to track the strategy's behavior and make informed decisions. Automated Execution with Alerts: Integrated alerts for both entries and exits ensure timely actions without the need for constant market monitoring, enhancing efficiency. Configurable alert messages are suitable for API use. Any feedback, comments, or suggestions for improvement are always welcome. Hope you enjoy!
استراتيجية Pine Script®
من ‎LucasVivien‎
14
MES Position Sizing EstimatorDescription and Use: Here is an indicator which aims to help all Micro-ES futures traders who struggle with risk management! I created this indicator designed as a general guideline to help short term traders (designed for 1 minute candles) determine how many contracts to trade on the MES for their desired profit target. To use the indicator, simply go to MES on the 1 minute timeframe, apply the indicator, and enter your Holding Period (how long you want to have your position open for), Value Per Tick (usually 1.25 for MES since one point is $5) and your target PnL for the trade in the inputs tab. It will then show in a table the recommended position sizing, as well as the estimated price change for your holding period. Additionally, there are two plotted lines also showing the position sizing and estimated price change historically. How the indicator works On the technical level, I made calculations for this indicator using Python. I downloaded 82 days of 1 minute OHLC data from TradingView, and then ran regression (log-transformed linear regression specifically) to calculate how the average price change in MES futures scales with the amount of time a position is held for, and then ran these regressions for every hour of the day. I then copied the equations from those regressions into Pinescript, and used the assumption that: position size = target PnL / (estimated price change for time * tick value) Therefore, Choosing the number of contracts to trade position sizing for Micro E-mini S&P 500 Futures (MES) based on time of day, holding period, and tick value. This tool leverages historical volatility patterns and log-transformed linear regression models to provide precise recommendations tailored to your trading strategy. If you want to check out how the regression code worked in python, it is all open source and available on my Github repository for it . Notes: The script assumes a log-normal distribution of price movements and is intended as an educational tool to aid in risk management. It is not a standalone trading system and should be used in conjunction with other trading strategies and risk assessments. Past performance is not indicative of future results, and traders should exercise caution and adjust their strategies based on personal risk tolerance. This script is open-source and available for use and modification by the TradingView community. It aims to provide a valuable resource for traders seeking to enhance their risk management practices through data-driven insights.
مؤشر Pine Script®
من ‎spiritualhealer117‎
DCA Valuation & Unrealized GainsThis Pine Script for TradingView calculates and visualizes the relationship between a Dollar Cost Average (DCA) price and the All-Time High (ATH) price for over 50 different cryptocurrencies. Here's what it does: 1. Inputs for DCA Prices: - Users can manually input DCA prices for specific cryptocurrencies (e.g., BTC, ETH, BNB). 2. Dynamic ATH Calculation: - Dynamically calculates the ATH price for the current asset using the highest price in the chart's loaded data and persists this value across bars. 3. Percentage Change from DCA to ATH: - Computes the percentage gain from the DCA price to the ATH price. 4. Visualizations: - Draws a line at the DCA price and the ATH price, both extended to the right. - Adds an arrow pointing from the DCA price to the ATH, offset by 10 bars into the future. - Displays labels for: - The percentage gain from DCA to ATH. - "No DCA Configured" if no valid DCA price is set for the asset. 5. Color Coding: - Labels and arrows are color-coded to indicate positive or negative percentage changes: - Green for gains. - Red for losses. 6. Adaptability: - The script dynamically adjusts to the current asset based on its ticker and uses the corresponding DCA price. This functionality provides traders with clear insights into their investment's performance relative to its ATH, aiding in decision-making. ----- To add a new asset to the script: 1. Define the DCA Input: Add a new input for the asset's DCA price using the `input.float` function. For example: dcaPriceNEW = input.float(title="NEW DCA Price", defval=0.1, tooltip="Set the DCA price for NEW") 2. Add the Asset Logic: Include a conditional check for the new asset in the ticker matching logic: if str.contains(currentAsset, "NEW") and dcaPriceNEW != 0 dcaPrice := dcaPriceNEW Where NEW is the ticker symbol of the asset you're adding. NOTE: SOLO had to be put before SOL because otherwise the indicator was pulling the DCA price from SOL even on the SOLO chart. If you have a similar issue, try that fix. Adding an asset requires only these two changes. Once done, the script dynamically incorporates the new asset into its calculations and visualizations.
مؤشر Pine Script®
من ‎IonicOcelot‎
Trading IQ - ICT LibraryLibrary "ICTlibrary" Used to calculate various ICT related price levels and strategies. An ongoing project. Hello Coders! This library is meant for sourcing ICT related concepts. While some functions might generate more output than you require, you can specify "Lite Mode" as "true" in applicable functions to slim down necessary inputs. isLastBar(userTF)   Identifies the last bar on the chart before a timeframe change   Parameters:      userTF (simple int) : the timeframe you wish to calculate the last bar for, must be converted to integer using 'timeframe.in_seconds()'   Returns: bool true if bar on chart is last bar of higher TF, dalse if bar on chart is not last bar of higher TF necessaryData(atrTF)   returns necessaryData UDT for historical data access   Parameters:      atrTF (float) : user-selected timeframe ATR value.   Returns: logZ. log return Z score, used for calculating order blocks. method gradBoxes(gradientBoxes, idColor, timeStart, bottom, top, rightCoordinate)   creates neon like effect for box drawings   Namespace types: array   Parameters:      gradientBoxes (array) : an array.new() to store the gradient boxes      idColor (color)      timeStart (int) : left point of box      bottom (float) : bottom of box price point      top (float) : top of box price point      rightCoordinate (int) : right point of box   Returns: void checkIfTraded(tradeName)   checks if recent trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent trade id matches target name, false otherwise checkIfClosed(tradeName)   checks if recent closed trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent closed trade id matches target name, false otherwise IQZZ(atrMult, finalTF)   custom ZZ to quickly determine market direction.   Parameters:      atrMult (float) : an atr multiplier used to determine the required price move for a ZZ direction change      finalTF (string) : the timeframe used for the atr calcuation   Returns: dir market direction. Up => 1, down => -1 method drawBos(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showBOS, isUp)   calculates and draws Break Of Structure   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the BoS line / label      showBOS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether BoS happened during price increase or price decrease.   Returns: void method drawMSS(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showMSS, isUp, upRejections, dnRejections, highArr, lowArr, timeArr, closeArr, openArr, atrTFarr, upRejectionsPrices, dnRejectionsPrices)   calculates and draws Market Structure Shift. This data is also used to calculate Rejection Blocks.   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the MSS line / label      showMSS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether MSS happened during price increase or price decrease.      upRejections (array)      dnRejections (array)      highArr (array) : array containing historical highs, should be taken from the UDT "necessaryData" defined above      lowArr (array) : array containing historical lows, should be taken from the UDT "necessaryData" defined above      timeArr (array) : array containing historical times, should be taken from the UDT "necessaryData" defined above      closeArr (array) : array containing historical closes, should be taken from the UDT "necessaryData" defined above      openArr (array) : array containing historical opens, should be taken from the UDT "necessaryData" defined above      atrTFarr (array) : array containing historical atr values (of user-selected TF), should be taken from the UDT "necessaryData" defined above      upRejectionsPrices (array) : array containing up rejections prices. Is sorted and used to determine selective looping for invalidations.      dnRejectionsPrices (array) : array containing down rejections prices. Is sorted and used to determine selective looping for invalidations.   Returns: void method getTime(id, compare, timeArr)   gets time of inputted price (compare) in an array of data this is useful when the user-selected timeframe for ICT concepts is greater than the chart's timeframe   Namespace types: array   Parameters:      id (array) : the array of data to search through, to find which index has the same value as "compare"      compare (float) : the target data point to find in the array      timeArr (array) : array of historical times   Returns: the time that the data point in the array was recorded method OB(id, highArr, signArr, lowArr, timeArr, sign)   store bullish orderblock data   Namespace types: array   Parameters:      id (array)      highArr (array) : array of historical highs      signArr (array) : array of historical price direction "math.sign(close - open)"      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      sign (int) : orderblock direction, -1 => bullish, 1 => bearish   Returns: void OTEstrat(OTEstart, future, closeArr, highArr, lowArr, timeArr, longOTEPT, longOTESL, longOTElevel, shortOTEPT, shortOTESL, shortOTElevel, structureDirection, oteLongs, atrTF, oteShorts)   executes the OTE strategy   Parameters:      OTEstart (chart.point)      future (int) : future time point for drawings      closeArr (array) : array of historical closes      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      longOTEPT (string) : user-selected long OTE profit target, please create an input.string() for this using the example below      longOTESL (int) : user-selected long OTE stop loss, please create an input.string() for this using the example below      longOTElevel (float) : long entry price of selected retracement ratio for OTE      shortOTEPT (string) : user-selected short OTE profit target, please create an input.string() for this using the example below      shortOTESL (int) : user-selected short OTE stop loss, please create an input.string() for this using the example below      shortOTElevel (float) : short entry price of selected retracement ratio for OTE      structureDirection (string) : current market structure direction, this should be "Up" or "Down". This is used to cancel pending orders if market structure changes      oteLongs (bool) : input.bool() for whether OTE longs can be executed      atrTF (float) : atr of the user-seleceted TF      oteShorts (bool) : input.bool() for whether OTE shorts can be executed @exampleInputs oteLongs = input.bool(defval = false, title = "OTE Longs", group = "Optimal Trade Entry") longOTElevel = input.float(defval = 0.79, title = "Long Entry Retracement Level", options = , group = "Optimal Trade Entry") longOTEPT = input.string(defval = "-0.5", title = "Long TP", options = , group = "Optimal Trade Entry") longOTESL = input.int(defval = 0, title = "How Many Ticks Below Swing Low For Stop Loss", group = "Optimal Trade Entry") oteShorts = input.bool(defval = false, title = "OTE Shorts", group = "Optimal Trade Entry") shortOTElevel = input.float(defval = 0.79, title = "Short Entry Retracement Level", options = , group = "Optimal Trade Entry") shortOTEPT = input.string(defval = "-0.5", title = "Short TP", options = , group = "Optimal Trade Entry") shortOTESL = input.int(defval = 0, title = "How Many Ticks Above Swing Low For Stop Loss", group = "Optimal Trade Entry")   Returns: void (0) displacement(logZ, atrTFreg, highArr, timeArr, lowArr, upDispShow, dnDispShow, masterCoords, labelLevels, dispUpcol, rightCoordinate, dispDncol, noBorders)   calculates and draws dispacements   Parameters:      logZ (float) : log return of current price, used to determine a "significant price move" for a displacement      atrTFreg (float) : atr of user-seleceted timeframe      highArr (array) : array of historical highs      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      upDispShow (int) : amount of historical upside displacements to show      dnDispShow (int) : amount of historical downside displacements to show      masterCoords (map) : a map to push the most recent displacement prices into, useful for having key levels in one data structure      labelLevels (string) : used to determine label placement for the displacement, can be inside box, outside box, or none, example below      dispUpcol (color) : upside displacement color      rightCoordinate (int) : future time for displacement drawing, best is "last_bar_time"      dispDncol (color) : downside displacement color      noBorders (bool) : input.bool() to remove box borders, example below @exampleInputs labelLevels = input.string(defval = "Inside" , title = "Box Label Placement", options = ) noBorders = input.bool(defval = false, title = "No Borders On Levels")   Returns: void method getStrongLow(id, startIndex, timeArr, lowArr, strongLowPoints)   unshift strong low data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the low before an upside BoS      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      strongLowPoints (array) : array of strong low prices. Used to retrieve highest strong low price and see if need for removal of invalidated strong lows   Returns: void method getStrongHigh(id, startIndex, timeArr, highArr, strongHighPoints)   unshift strong high data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the high before a downside BoS      timeArr (array) : array of historical times      highArr (array) : array of historical highs      strongHighPoints (array)   Returns: void equalLevels(highArr, lowArr, timeArr, rightCoordinate, equalHighsCol, equalLowsCol, liteMode)   used to calculate recent equal highs or equal lows   Parameters:      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      rightCoordinate (int) : a future time (right for boxes, x2 for lines)      equalHighsCol (color) : user-selected color for equal highs drawings      equalLowsCol (color) : user-selected color for equal lows drawings      liteMode (bool) : optional for a lite mode version of an ICT strategy. For more control over drawings leave as "True", "False" will apply neon effects   Returns: void quickTime(timeString)   used to quickly determine if a user-inputted time range is currently active in NYT time   Parameters:      timeString (string) : a time range   Returns: true if session is active, false if session is inactive macros(showMacros, noBorders)   used to calculate and draw session macros   Parameters:      showMacros (bool) : an input.bool() or simple bool to determine whether to activate the function      noBorders (bool) : an input.bool() to determine whether the box anchored to the session should have borders   Returns: void po3(tf, left, right, show)   use to calculate HTF po3 candle @tip only call this function on "barstate.islast"   Parameters:      tf (simple string)      left (int) : the left point of the candle, calculated as bar_index + left,      right (int) : :the right point of the candle, calculated as bar_index + right,      show (bool) : input.bool() whether to show the po3 candle or not   Returns: void silverBullet(silverBulletStratLong, silverBulletStratShort, future, userTF, H, L, H2, L2, noBorders, silverBulletLongTP, historicalPoints, historicalData, silverBulletLongSL, silverBulletShortTP, silverBulletShortSL)   used to execute the Silver Bullet Strategy   Parameters:      silverBulletStratLong (simple bool)      silverBulletStratShort (simple bool)      future (int) : a future time, used for drawings, example "last_bar_time"      userTF (simple int)      H (float) : the high price of the user-selected TF      L (float) : the low price of the user-selected TF      H2 (float) : the high price of the user-selected TF      L2 (float) : the low price of the user-selected TF      noBorders (bool) : an input.bool() used to remove the borders from box drawings      silverBulletLongTP (series silverBulletLevels)      historicalPoints (array)      historicalData (necessaryData)      silverBulletLongSL (series silverBulletLevels)      silverBulletShortTP (series silverBulletLevels)      silverBulletShortSL (series silverBulletLevels)   Returns: void method invalidFVGcheck(FVGarr, upFVGpricesSorted, dnFVGpricesSorted)   check if existing FVGs are still valid   Namespace types: array   Parameters:      FVGarr (array)      upFVGpricesSorted (array) : an array of bullish FVG prices, used to selective search through FVG array to remove invalidated levels      dnFVGpricesSorted (array) : an array of bearish FVG prices, used to selective search through FVG array to remove invalidated levels   Returns: void (0) method drawFVG(counter, FVGshow, FVGname, FVGcol, data, masterCoords, labelLevels, borderTransp, liteMode, rightCoordinate)   draws FVGs on last bar   Namespace types: map   Parameters:      counter (map) : a counter, as map, keeping count of the number of FVGs drawn, makes sure that there aren't more FVGs drawn than int FVGshow      FVGshow (int) : the number of FVGs to show. There should be a bullish FVG show and bearish FVG show. This function "drawFVG" is used separately for bearish FVG and bullish FVG.      FVGname (string) : the name of the FVG, "FVG Up" or "FVG Down"      FVGcol (color) : desired FVG color      data (FVG)      masterCoords (map) : a map containing the names and price points of key levels. Used to define price ranges.      labelLevels (string) : an input.string with options "Inside", "Outside", "Remove". Determines whether FVG labels should be inside box, outside, or na.      borderTransp (int)      liteMode (bool)      rightCoordinate (int) : the right coordinate of any drawings. Must be a time point.   Returns: void invalidBlockCheck(bullishOBbox, bearishOBbox, userTF)   check if existing order blocks are still valid   Parameters:      bullishOBbox (array) : an array declared using the UDT orderBlock that contains bullish order block related data      bearishOBbox (array) : an array declared using the UDT orderBlock that contains bearish order block related data      userTF (simple int)   Returns: void (0) method lastBarRejections(id, rejectionColor, idShow, rejectionString, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws rejectionBlocks on last bar   Namespace types: array   Parameters:      id (array) : the array, an array of rejection block data declared using the UDT rejection block      rejectionColor (color) : the desired color of the rejection box      idShow (int)      rejectionString (string) : the desired name of the rejection blocks      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void method OBdraw(id, OBshow, BBshow, OBcol, BBcol, bullishString, bearishString, isBullish, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws orderblocks and breaker blocks for data stored in UDT array()   Namespace types: array   Parameters:      id (array) : the array, an array of order block data declared using the UDT orderblock      OBshow (int) : the number of order blocks to show      BBshow (int) : the number of breaker blocks to show      OBcol (color) : color of order blocks      BBcol (color) : color of breaker blocks      bullishString (string) : the title of bullish blocks, which is a regular bullish orderblock or a bearish orderblock that's converted to breakerblock      bearishString (string) : the title of bearish blocks, which is a regular bearish orderblock or a bullish orderblock that's converted to breakerblock      isBullish (bool) : whether the array contains bullish orderblocks or bearish orderblocks. If bullish orderblocks, the array will naturally contain bearish BB, and if bearish OB, the array will naturally contain bullish BB      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void FVG   UDT for FVG calcualtions   Fields:      H (series float) : high price of user-selected timeframe      L (series float) : low price of user-selected timeframe      direction (series string) : FVG direction => "Up" or "Down"      T (series int) : => time of bar on user-selected timeframe where FVG was created      fvgLabel (series label) : optional label for FVG      fvgLineTop (series line) : optional line for top of FVG      fvgLineBot (series line) : optional line for bottom of FVG      fvgBox (series box) : optional box for FVG labelLine   quickly pair a line and label together as UDT   Fields:      lin (series line) : Line you wish to pair with label      lab (series label) : Label you wish to pair with line orderBlock   UDT for order block calculations   Fields:      orderBlockData (array) : array containing order block x and y points      orderBlockBox (series box) : optional order block box      vioCount (series int) : = 0 violation count of the order block. 0 = Order Block, 1 = Breaker Block      traded (series bool)      status (series string) : = "OB" status == "OB" => Level is order block. status == "BB" => Level is breaker block.      orderBlockLab (series label) : options label for the order block / breaker block. strongPoints   UDT for strong highs and strong lows   Fields:      price (series float) : price of the strong high or strong low      timeAtprice (series int) : time of the strong high or strong low      strongPointLabel (series label) : optional label for strong point      strongPointLine (series line) : optional line for strong point      overlayLine (series line) : optional lines for strong point to enhance visibility      overlayLine2 (series line) : optional lines for strong point to enhance visibility displacement   UDT for dispacements   Fields:      highPrice (series float) : high price of displacement      lowPrice (series float) : low price of displacement      timeAtPrice (series int) : time of bar where displacement occurred      displacementBox (series box) : optional box to draw displacement      displacementLab (series label) : optional label for displacement po3data   UDT for po3 calculations   Fields:      dHigh (series float) : higher timeframe high price      dLow (series float) : higher timeframe low price      dOpen (series float) : higher timeframe open price      dClose (series float) : higher timeframe close price      po3box (series box) : box to draw po3 candle body      po3line (array) : line array to draw po3 wicks      po3Labels (array) : label array to label price points of po3 candle macros   UDT for session macros   Fields:      sessions (array) : Array of sessions, you can populate this array using the "quickTime" function located above "export macros".      prices (matrix) : Matrix of session data -> open, high, low, close, time      sessionTimes (array) : Array of session names. Pairs with array sessions.      sessionLines (matrix) : Optional array for sesion drawings. OTEtimes   UDT for data storage and drawings associated with OTE strategy   Fields:      upTimes (array) : time of highest point before trade is taken      dnTimes (array) : time of lowest point before trade is taken      tpLineLong (series line) : line to mark tp level long      tpLabelLong (series label) : label to mark tp level long      slLineLong (series line) : line to mark sl level long      slLabelLong (series label) : label to mark sl level long      tpLineShort (series line) : line to mark tp level short      tpLabelShort (series label) : label to mark tp level short      slLineShort (series line) : line to mark sl level short      slLabelShort (series label) : label to mark sl level short sweeps   UDT for data storage and drawings associated with liquidity sweeps   Fields:      upSweeps (matrix) : matrix containing liquidity sweep price points and time points for up sweeps      dnSweeps (matrix) : matrix containing liquidity sweep price points and time points for down sweeps      upSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns,      dnSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns, raidExitDrawings   UDT for drawings associated with the Liquidity Raid Strategy   Fields:      tpLine (series line) : tp line for the liquidity raid entry      tpLabel (series label) : tp label for the liquidity raid entry      slLine (series line) : sl line for the liquidity raid entry      slLabel (series label) : sl label for the liquidity raid entry m2022   UDT for data storage and drawings associated with the Model 2022 Strategy   Fields:      mTime (series int) : time of the FVG where entry limit order is placed      mIndex (series int) : array index of FVG where entry limit order is placed. This requires an array of FVG data, which is defined above.      mEntryDistance (series float) : the distance of the FVG to the 50% range. M2022 looks for the fvg closest to 50% mark of range.      mEntry (series float) : the entry price for the most eligible fvg      fvgHigh (series float) : the high point of the eligible fvg      fvgLow (series float) : the low point of the eligible fvg      longFVGentryBox (series box) : long FVG box, used to draw the eligible FVG      shortFVGentryBox (series box) : short FVG box, used to draw the eligible FVG      line50P (series line) : line used to mark 50% of the range      line100P (series line) : line used to mark 100% (top) of the range      line0P (series line) : line used to mark 0% (bottom) of the range      label50P (series label) : label used to mark 50% of the range      label100P (series label) : label used to mark 100% (top) of the range      label0P (series label) : label used to mark 0% (bottom) of the range      sweepData (array) silverBullet   UDT for data storage and drawings associated with the Silver Bullet Strategy   Fields:      session (series bool)      sessionStr (series string) : name of the session for silver bullet      sessionBias (series string)      sessionHigh (series float) : = high high of session // use math.max(silverBullet.sessionHigh, high)      sessionLow (series float) : = low low of session // use math.min(silverBullet.sessionLow, low)      sessionFVG (series float) : if applicable, the FVG created during the session      sessionFVGdraw (series box) : if applicable, draw the FVG created during the session      traded (series bool)      tp (series float) : tp of trade entered at the session FVG      sl (series float) : sl of trade entered at the session FVG      sessionDraw (series box) : optional draw session with box      sessionDrawLabel (series label) : optional label session with label silverBulletDrawings   UDT for trade exit drawings associated with the Silver Bullet Strategy   Fields:      tpLine (series line) : tp line drawing for strategy      tpLabel (series label) : tp label drawing for strategy      slLine (series line) : sl line drawing for strategy      slLabel (series label) : sl label drawing for strategy unicornModel   UDT for data storage and drawings associated with the Unicorn Model Strategy   Fields:      hPoint (chart.point)      hPoint2 (chart.point)      hPoint3 (chart.point)      breakerBlock (series box) : used to draw the breaker block required for the Unicorn Model      FVG (series box) : used to draw the FVG required for the Unicorn model      topBlock (series float) : price of top of breaker block, can be used to detail trade entry      botBlock (series float) : price of bottom of breaker block, can be used to detail trade entry      startBlock (series int) : start time of the breaker block, used to set the "left = " param for the box      includes (array) : used to store the time of the breaker block, or FVG, or the chart point sequence that setup the Unicorn Model.      entry (series float) : // eligible entry price, for longs"math.max(topBlock, FVG.get_top())",      tpLine (series line) : optional line to mark PT      tpLabel (series label) : optional label to mark PT      slLine (series line) : optional line to mark SL      slLabel (series label) : optional label to mark SL rejectionBlocks   UDT for data storage and drawings associated with rejection blocks   Fields:      rejectionPoint (chart.point)      bodyPrice (series float) : candle body price closest to the rejection point, for "Up" rejections => math.max(open, close),      rejectionBox (series box) : optional box drawing of the rejection block      rejectionLabel (series label) : optional label for the rejection block equalLevelsDraw   UDT for data storage and drawings associated with equal highs / equal lows   Fields:      connector (series line) : single line placed at the first high or low, y = avgerage of distinguished equal highs/lows      connectorLab (series label) : optional label to be placed at the highs or lows      levels (array) : array containing the equal highs or lows prices      times (array) : array containing the equal highs or lows individual times      startTime (series int) : the time of the first high or low that forms a sequence of equal highs or lows      radiate (array) : options label to "radiate" the label in connector lab. Can be used for anything necessaryData   UDT for data storage of historical price points.   Fields:      highArr (array) : array containing historical high points      lowArr (array) : array containing historical low points      timeArr (array) : array containing historical time points      logArr (array) : array containing historical log returns      signArr (array) : array containing historical price directions      closeArr (array) : array containing historical close points      binaryTimeArr (array) : array containing historical time points, uses "push" instead of "unshift" to allow for binary search      binaryCloseArr (array) : array containing historical close points, uses "push" instead of "unshift" to allow the correct      binaryOpenArr (array) : array containing historical optn points, uses "push" instead of "unshift" to allow the correct      atrTFarr (array) : array containing historical user-selected TF atr points      openArr (array) : array containing historical open points
مكتبة Pine Script®
من ‎Trading-IQ‎
Theta Shield | Flux Charts💎 GENERAL OVERVIEW Introducing our new Theta Shield indicator! Theta is the options risk factor concerning how fast there is a decline in the value of an option over time. This indicator aims to help the trader avoid sideways market phases in the current ticker, to minimize the risk of theta decay. For more information, please check the "How Does It Work" section. Features of the new Theta Shield Indicator : Foresight Of Accumulation Zones Decrease Risk Of Theta Decay Clear "Valid" & "Non-Valid" Signals Validness Trail Alerts 📌 HOW DOES IT WORK ? In options trading, theta is defined as the rate of decline in the value of an option due to the passage of time. Traders want to avoid this kind of decay in the value of an option. One of the best ways to avoid it is not holding an option contract when the market is going sideways. This indicator uses a stochastic oscillator to try to get a foresight of sideways markets, warning the trader to not hold an option contract while the price is in a range. The indicator starts by calculating the stochastic value using close, high & low prices of the candlesticks. Then a stoch threshold & a theta length are determined depending on the option contract type defined by the user in the settings of the indicator. Each candlestick that falls above or below the stoch threshold value is counted, and a "theta valid strength" is calculated using the counted candlesticks, which has a value between -100 & 100. Here is the formula of the "theta valid strength" value : f_lin_interpolate(float x0, float x1, float y0, float y1, float x) => y0 + (x - x0) * (y1 - y0) / (x1 - x0) thetaValid = Total Candlesticks That Fall Above & Below The Threshold In Last "Theta Length" bars. thetaValidStrength = f_lin_interpolate(0, thetaLength, -100, 100, thetaValid) Then a trail is rendered, and "Valid" & "Non-Valid" signals are given using this freshly calculated strength value. Valid means that the indicator currently thinks that no accumulation will happen in the near future, so the option positions in the current ticker are protected from the theta decay. Non-Valid means that the indicator thinks the ticker has entered the accumulation phase, so holding any option position is not recommended, as they may be affected by the theta decay. 🚩 UNIQUENESS This indicator offers a unique way to avoid theta decay in options trading. It uses a stochastic oscillator and thresholds to calculate a "theta strength" value, which is used for rendering validness signals and a trail. Traders can follow the valid & non-valid signals when deciding to hold their options position or not. The indicator also has an alerts feature, so you can get notified when a ticker is about to enter a range, or when it's about to get out of it. ⚙️ SETTINGS 1. General Configuration Contract Type -> You can set the option contract type here. The indicator will adjust itself to get a better foresight depending on the contract length. 2. Style Fill Validness -> Will render a trail based on "theta strength" value.
مؤشر Pine Script®
من ‎fluxchart‎
3
Basic FVGBasic Fair Value Gap (FVG) Indicator The Basic Fair Value Gap (FVG) Indicator is a tool designed for traders using the TradingView platform to identify and visualize Fair Value Gaps (FVGs) on any given chart. Key Features: Bullish and Bearish FVG Detection: The indicator automatically detects and highlights both bullish and bearish Fair Value Gaps on the chart. Bullish gaps are highlighted in blue, while bearish gaps are marked in red, with customizable transparency for clear visibility. Customizable Parameters: Max Bars Back: Users can set the maximum number of bars to look back in order to find potential FVGs. Box Length: The length of the FVG box can be adjusted to fit the user's preference, allowing for better visual management on different timeframes. Tick Buffer for Close Validation: The indicator only considers an FVG filled if the price closes beyond the gap by a customizable tick buffer, ensuring precise gap closure recognition. Automatic Removal of Filled Gaps: Once an FVG is filled (i.e., the price closes beyond the gap by the defined tick buffer), the corresponding FVG box is automatically removed from the chart. This keeps the chart clean and focused on active gaps. Real-Time Updates: The indicator updates in real-time, ensuring that traders have the most current information about potential gaps in price, which could signify strong support or resistance levels.
مؤشر Pine Script®
من ‎nacho-fx‎
Swing Trend AnalysisIntroducing the Swing Trend Analyzer: A Powerful Tool for Swing and Positional Trading The Swing Trend Analyzer is a cutting-edge indicator designed to enhance your swing and positional trading by providing precise entry points based on volatility contraction patterns and other key technical signals. This versatile tool is packed with features that cater to traders of all timeframes, offering flexibility, clarity, and actionable insights. Key Features: 1. Adaptive Moving Averages: The Swing Trend Analyzer offers multiple moving averages tailored to the timeframe you are trading on. On the daily chart, you can select up to four different moving average lengths, while all other timeframes provide three moving averages. This flexibility allows you to fine-tune your analysis according to your trading strategy. Disabling a moving average is as simple as setting its value to zero, making it easy to customize the indicator to your needs. 2. Dynamic Moving Average Colors Based on Relative Strength: This feature allows you to compare the performance of the current ticker against a major index or any symbol of your choice. The moving average will change color based on whether the ticker is outperforming or underperforming the selected index over the chosen period. For example, on a daily chart, if the 21-day moving average turns blue, it indicates that the ticker has outperformed the selected index over the last 21 days. This visual cue helps you quickly identify relative strength, a key factor in successful swing trading. 3. Visual Identification of Price Contractions: The Swing Trend Analyzer changes the color of price bars to white (on a dark theme) or black (on a light theme) when a contraction in price is detected. Price contractions are highlighted when either of the following conditions is met: a) the current bar is an inside bar, or b) the price range of the current bar is less than the 14-period Average Daily Range (ADR). This feature makes it easier to spot price contractions across all timeframes, which is crucial for timing entries in swing trading. 4. Overhead Supply Detection with Automated Resistance Lines: The indicator intelligently detects the presence of overhead supply and draws a single resistance line to avoid clutter on the chart. As price breaches the resistance line, the old line is automatically deleted, and a new resistance line is drawn at the appropriate level. This helps you focus on the most relevant resistance levels, reducing noise and improving decision-making. 5. Buyable Gap Up Marker: The indicator highlights bars in blue when a candle opens with a gap that remains unfilled. These bars are potential Buyable Gap Up (BGU) candidates, signaling opportunities for long-side entries. 6. Comprehensive Swing Trading Information Table: The indicator includes a detailed table that provides essential data for swing trading: a. Sector and Industry Information: Understand the sector and industry of the ticker to identify stocks within strong sectors. b. Key Moving Averages Distances (10MA, 21MA, 50MA, 200MA): Quickly assess how far the current price is from key moving averages. The color coding indicates whether the price is near or far from these averages, offering vital visual cues. c. Price Range Analysis: Compare the current bar's price range with the previous bar's range to spot contraction patterns. d. ADR (20, 10, 5): Displays the Average Daily Range over the last 20, 10, and 5 periods, crucial for identifying contraction patterns. On the weekly chart, the ADR continues to provide daily chart information. e. 52-Week High/Low Data: Shows how close the stock is to its 52-week high or low, with color coding to highlight proximity, aiding in the identification of potential breakout or breakdown candidates. f. 3-Month Price Gain: See the price gain over the last three months, which helps identify stocks with recent momentum. 7. Pocket Pivot Detection with Visual Markers: Pocket pivots are a powerful bullish signal, especially relevant for swing trading. Pocket pivots are crucial for swing trading and are effective across all timeframes. The indicator marks pocket pivots with circular markers below the price bar: a. 10-Day Pocket Pivot: Identified when the volume exceeds the maximum selling volume of the last 10 days. These are marked with a blue circle. b. 5-Day Pocket Pivot: Identified when the volume exceeds the maximum selling volume of the last 5 days. These are marked with a green circle. The Swing Trend Analyzer is designed to provide traders with the tools they need to succeed in swing and positional trading. Whether you're looking for precise entry points, analyzing relative strength, or identifying key price contractions, this indicator has you covered. Experience the power of advanced technical analysis with the Swing Trend Analyzer and take your trading to the next level.
مؤشر Pine Script®
من ‎PrasadJoshi12‎
4
Portfolio Index Generator [By MUQWISHI]▋ INTRODUCTION: The “Portfolio Index Generator” simplifies the process of building a custom portfolio management index, allowing investors to input a list of preferred holdings from global securities and customize the initial investment weight of each security. Furthermore, it includes an option for rebalancing by adjusting the weights of assets to maintain a desired level of asset allocation. The tool serves as a comprehensive approach for tracking portfolio performance, conducting research, and analyzing specific aspects of portfolio investment. The output includes an index value, a table of holdings, and chart plotting, providing a deeper understanding of the portfolio's historical movement. _______________________ ▋ OVERVIEW: The image can be taken as an example of building a custom portfolio index. I created this index and named it “My Portfolio Performance”, which comprises several global companies and crypto assets. _______________________ ▋ OUTPUTS: The output can be divided into 4 sections: 1. Portfolio Index Title (Name & Value). 2. Portfolio Specifications. 3. Portfolio Holdings. 4. Portfolio Index Chart. 1. Portfolio Index Title, displays the index name at the top, and at the bottom, it shows the index value, along with the chart timeframe, e.g., daily change in points and percentage. 2. Portfolio Specifications, displays the essential information on portfolio performance, including the investment date range, initial capital, returns, assets, and equity. 3. Portfolio Holdings, a list of the holding securities inside a table that contains the ticker, average entry price, last price, return percentage of the portfolio's initial capital, and customized weighted percentage of the portfolio. Additionally, a tooltip appears when the user passes the cursor over a ticker's cell, showing brief information about the company, such as the company's name, exchange market, country, sector, and industry. 4. Index Chart, display a plot of the historical movement of the index in the form of a bar, candle, or line chart. _______________________ ▋ INDICATOR SETTINGS: Section(1): Style Settings (1) Naming the index. (2) Table location on the chart and cell size. (3) Sorting Holdings Table. By securities’ {Return(%) Portfolio, Weight(%) Portfolio, or Ticker Alphabetical} order. (4) Choose the type of index: {Equity or Return (%)}, and the plot type for the index: {Candle, Bar, or Line}. (5) Positive/Negative colors. (6) Table Colors (Title, Cell, and Text). (7) To show/hide any indicator’s components. Section(2): Performance Settings (1) Calculation window period: from DateTime to DateTime. (2) Initial Capital and specifying currency. (3) Option to enable portfolio rebalancing in {Monthly, Quarterly, or Yearly} intervals. Section(3): Portfolio Holdings (1) Enable and count security in the investment portfolio. (2) Initial weight of security. For example, if the initial capital is $100,000 and the weight of XYZ stock is 4%, the initial value of the shares would be $4,000. (3) Select and add up to 30 symbols that interested in. Please let me know if you have any questions.
مؤشر Pine Script®
من ‎MUQWISHI‎
17
BB Position CalculatorPosition Size Calculator Instructions Overview The Position Size Calculator is designed to help traders automatically determine the appropriate lot size based on the dollar amount they are willing to risk. It includes features for automatic lot sizing, fixed lot risk calculations, take profit calculations (both automatic and fixed), max run-up, and max drawdown. Calculated values are displayed in ticks, points, and USD. Key Features • Automatic Lot Sizing: Automatically calculates lot size based on the amount of money you are willing to risk. • Fixed Lot Risk Calculations: Provides risk calculations for fixed lot sizes. • Take Profit Calculations: Offers both automatic and fixed take profit calculations. • Max Run-Up and Max Drawdown: Monitors and displays the maximum run-up and drawdown of your trade. • Detailed Metrics: Displays all calculated values in ticks, points, and USD. Setup Instructions 1. Add and Remove for Each Position: The calculator is designed to be added to your chart for each new position. Once your preferences are set the first time, save them as your default to retain your settings for future use. 2. Adding the Indicator to Favorites: • Use the TradingView keyboard shortcut “/” then type “pos.” • Use the arrow key to select the Position Size Calculator and press enter. • Close the indicator selection pop-up. 3. Setting the Trigger Price: • A blue pop-up labeled “SET TRIGGER PRICE” will appear at the bottom of the chart. • Click on the chart at the price level where you want to enter the trade. 4. Setting the Stop Loss: • The pop-up will change to “SET STOP LOSS.” • Click on the chart at the price level where your stop loss will be set. 5. Setting the Take Profit: • The pop-up will change to “SET TAKE PROFIT.” • Click on the chart at the price level where you want to take profit. If you have selected the option to overwrite with a set risk/reward ratio (R:R), the calculation will use this price level. 6. Setting the Trade Window Start: • The pop-up will change to “SET TRADE WINDOW START.” • Click on the bar in time where you want the indicator to start monitoring for price to trigger the position. 7. Adjusting the Position: • Clicking on any part of the indicator will display draggable lines, allowing you to fine-tune the position that was previously plotted by the first four chart clicks. Additional Notes • Compatibility: This calculator has only been tested with futures trading. • Customization: Once your preferences are set, save them as your default to make setup quicker for future trades. • Support: If you have any questions or feature requests, please feel free to reach out.
مؤشر Pine Script®
من ‎Bender_Bot‎
3
ATR/ADR Support and Resistance LevelsATR/ADR Support and Resistance Levels Indicator This script is designed to provide traders with precise ATR (Average True Range) and ADR (Average Daily Range) support and resistance levels. It can be effectively used to identify price breakouts or rejections near these critical lines and assist in confirming trend retests. How It Works: Support and Resistance Lines: The script plots ATR/ADR-based support and resistance lines, which can be toggled on or off. Daily Data Integration: It incorporates daily open and close prices to enhance the accuracy of the support and resistance levels. Clear Visuals: The indicator uses distinct colors for support (green) and resistance (red) levels, providing clear visual cues. Default Settings: The default settings are optimized for most trading environments. Adjusting the ATR/ADR Length can fine-tune the indicator's responsiveness to market movements. Key Features: ATR & ADR Calculation: Choose between using ATR, ADR, or both. ATR is recommended for most scenarios. Customizable Lengths: Adjust the ATR/ADR Length to refine the average calculation to your preference, with 14 being the standard value. EMA for Market Bias: The EMA helps determine the ticker bias. It is colored green when the market is above the average price and red when it is below. This allows you to more easily determine whether or not the ADR/ATR levels are valid. Versatile Usage: Suitable for various trading types, ensuring broad applicability across different market conditions. How to Use: ATR vs ADR: You should use ADR if you are day trading AND do not want to include gap data in the levels. It is recommended you use ATR. Bounces off Levels: When price bounces off of a support/resistance level, it is very likely that price will respect this level. This indicates that price is unlikely to move beyond the ticker's average volatility. You should wait for an additional bounce to confirm. Breakthroughs of Levels: When price breaks through a support/resistance level, it is very likely that price will continue beyond this level. This indicates that price has moved beyond that ticker's average volatility. You should wait for a bounce off the level to confirm. This indicator is a valuable tool for traders seeking to enhance their technical analysis with support and resistance levels based on ATR and ADR calculations. It is perfect for identifying key price points and understanding market trends.
مؤشر Pine Script®
من ‎skyzlimit‎
OrderFlow Absorption IndicatorWhat it Does The OrderFlow Absorption Indicator marks areas where the price absorbs a large volume of aggressive market trades. This indicates areas where price may bounce back due to large limit (resting) orders absorbing significant aggressor volume (market orders). Absorption can also be seen as "preventing" or "stopping" the other side from breaking through a price level (e.g. bids stopping an influx of sell market orders). Absorption may signal a change in sentiment, potentially leading to a pullback or reversal. An Example of Absorption Of course, it is not always the case that such bullish absorption will initiate a trend as the example above. The OrderFlow Absorption Indicator merely serves as a tool for spotting possible absorption points in the market which you can incorporate into your trading arsenal. How it Works The indicator actively monitors price changes and records volume accumulated at a price level. If the price bounces back to at least where it was before the current price move, the indicator records this as absorption, provided it meets the Volume Requirement and optional Time Requirement. How to Use it 1. Set Parameters Choose your desired tick size and volume filter value. If unsure, refer to the table on the top right of the chart for recommended values. An automatic volume limit filter mode is also available. Automatic Limit Mode : Enable this mode to have the indicator automatically select a volume filter value. It calculates the standard deviation of the last n minutes of volume and multiplies it by a volume multiplier. You can adjust these parameters. Higher Volume Filter : Setting a higher volume filter value results in fewer, but higher quality detections, reducing noise. 2. Enabling the Time Limit Enabling the time limit further improves detection quality by filtering out price levels that can defend against quick, sudden aggressive orders, acting as confirmation and indicating strong sentiment and resilient liquidity. 3. Enabling Historical Data Absorption The indicator can also detect absorption in historical data, though less accurately than in real-time due to OHLCV aggregation. You can select the granularity of historical data. Lower granularity (e.g., 1 second) : Provides more accurate detections but may slow down the indicator. Higher granularity : Improves speed but reduces detection accuracy. Other Features Hovering : When hovering over an absorption point, the interface reveals the price where the absorption occurred, along with the volume absorbed by the bids and asks, as well as the volume filter value used. Delta Mode : In Delta mode, the system calculates the difference between the volume absorbed by bids and asks, revealing points only when the absolute value of this difference exceeds the volume filter value. Especially useful for larger tick sizes. Troubleshooting If the indicator doesn't mark anything, it means the traded volume hasn't exceeded the set volume filter value within the specified price intervals(tick size) and time limit. Adjust these settings as necessary.
مؤشر Pine Script®
من ‎nico-von‎
9
Footprint strategyThis strategy uses imbalance volume data obtained by footprint calculation technology. There are two signals to enter a trade: trend - the current buy volume on the bar is greater than the current sell volume and there is at least one imbalance line. reversal - the current bar is falling, but the general market trend is positive (growing) and the imbalance buy volume exceeds the imbalance sell volume. When any of the conditions is triggered, two orders are placed: Take Profit and Stop loss (according to the percentage value from the inputs). A little advice on use: The strategy performs best on a 15 minute timeframe. It is necessary to choose acceptable values of Take Profit and Stop loss depending on the order of symbol prices. Inputs related to the strategy: Stop loss - percentage size of stop loss to exit the trade. Enable stop loss - stop loss activation. Take Profit - percentage size of Take Profit. Calculation timeframe - this is the timeframe from which the volume will be collected for distribution to buy and sell (if you do not have access to the seconds chart, set here 1 minute, the accuracy will be less, but it will work). Trend timeframe - this is the timeframe from which the trend will be calculated. Enable trend - activation of trend calculation. Inputs related to the calculation of footprints (collection of the volume of purchases and sales): Count show bars - Number of bars from rt bar to history to calculate. Display all available bars - Strategy calculation on all available bars (based on the available amount of data with reduced resolution (set in Calculation timeframe)). Ticks Per Row - Sets the price step, calculated by multiplying the entered value by syminfo.mintick. Auto - The automatic "Ticks Per Row" calculation is based on the first available bar and applied to subsequent bars. Max row - sets the acceptable number of rows within a bar. Imbalance Percent - A percentage coefficient to determine the Imbalance of price levels. Stacked levels - And minimum number of consecutive Imbalance levels required to draw extended lines. If you have suggestions for improving the strategy and adding new conditions for entering and exiting the trade, please write).
استراتيجية Pine Script®
من ‎dboichenko‎
5
Index Generator [By MUQWISHI]▋ INTRODUCTION : The “Index Generator” simplifies the process of building a custom market index, allowing investors to enter a list of preferred holdings from global securities. It aims to serve as an approach for tracking performance, conducting research, and analyzing specific aspects of the global market. The output will include an index value, a table of holdings, and chart plotting, providing a deeper understanding of historical movement. _______________________ ▋ OVERVIEW: The image can be taken as an example of building a custom index. I created this index and named it “My Oil & Gas Index”. The index comprises several global energy companies. Essentially, the indicator weights each company by collecting the number of shares and then computes the market capitalization before sorting them as seen in the table. _______________________ ▋ OUTPUTS: The output can be divided into 3 sections: 1. Index Title (Name & Value). 2. Index Holdings. 3. Index Chart. 1. Index Title , displays the index name at the top, and at the bottom, it shows the index value, along with the daily change in points and percentage. 2. Index Holdings , displays list the holding securities inside a table that contains the ticker, price, daily change %, market cap, and weight %. Additionally, a tooltip appears when the user passes the cursor over a ticker's cell, showing brief information about the company, such as the company's name, exchange market, country, sector, and industry. 3. Index Chart , display a plot of the historical movement of the index in the form of a bar, candle, or line chart. _______________________ ▋ INDICATOR SETTINGS: (1) Naming the index. (2) Entering a currency. To unite all securities in one currency. (3) Table location on the chart. (4) Table’s cells size. (5) Table’s colors. (6) Sorting table. By securities’ (Market Cap, Change%, Price, or Ticker Alphabetical) order. (7) Plotting formation (Candle, Bar, or Line) (8) To show/hide any indicator’s components. (9) There are 34 fields where user can fill them with symbols. Please let me know if you have any questions.
مؤشر Pine Script®
من ‎MUQWISHI‎
20
Volatility Adjusted Weighted DEMA [BackQuant]Volatility Adjusted Weighted DEMA The Volatility Adjusted Weighted Double Exponential Moving Average (VAWDEMA) by BackQuant is a sophisticated technical analysis tool designed for traders seeking to integrate volatility into their moving average calculations. This innovative indicator adjusts the weighting of the Double Exponential Moving Average (DEMA) according to recent volatility levels, offering a more dynamic and responsive measure of market trends. Primarily, the single Moving average is very noisy, but can be used in the context of strategy development, where as the crossover, is best used in the context of defining a trading zone/ macro uptrend on higher timeframes. Why Volatility Adjustment is Beneficial Volatility is a fundamental aspect of financial markets, reflecting the intensity of price changes. A volatility adjustment in moving averages is beneficial because it allows the indicator to adapt more quickly during periods of high volatility, providing signals that are more aligned with the current market conditions. This makes the VAWDEMA a versatile tool for identifying trend strength and potential reversal points in more volatile markets. Understanding DEMA and Its Advantages DEMA is an indicator that aims to reduce the lag associated with traditional moving averages by applying a double smoothing process. The primary benefit of DEMA is its sensitivity and quicker response to price changes, making it an excellent tool for trend following and momentum trading. Incorporating DEMA into your analysis can help capture trends earlier than with simple moving averages. The Power of Combining Volatility Adjustment with DEMA By adjusting the weight of the DEMA based on volatility, the VAWDEMA becomes a powerful hybrid indicator. This combination leverages the quick responsiveness of DEMA while dynamically adjusting its sensitivity based on current market volatility. This results in a moving average that is both swift and adaptive, capable of providing more relevant signals for entering and exiting trades. Core Logic Behind VAWDEMA The core logic of the VAWDEMA involves calculating the DEMA for a specified period and then adjusting its weighting based on a volatility measure, such as the average true range (ATR) or standard deviation of price changes. This results in a weighted DEMA that reflects both the direction and the volatility of the market, offering insights into potential trend continuations or reversals. Utilizing the Crossover in a Trading System The VAWDEMA crossover occurs when two VAWDEMAs of different lengths cross, signaling potential bullish or bearish market conditions. In a trading system, a crossover can be used as a trigger for entry or exit points: Bullish Signal: When a shorter-period VAWDEMA crosses above a longer-period VAWDEMA, it may indicate an uptrend, suggesting a potential entry point for a long position. Bearish Signal: Conversely, when a shorter-period VAWDEMA crosses below a longer-period VAWDEMA, it might signal a downtrend, indicating a possible exit point or a short entry. Incorporating VAWDEMA crossovers into a trading strategy can enhance decision-making by providing timely and adaptive signals that account for both trend direction and market volatility. Traders should combine these signals with other forms of analysis and risk management techniques to develop a well-rounded trading strategy. Alert Conditions For Trading alertcondition(vwdema>vwdema , title="VWDEMA Long", message="VWDEMA Long - {{ticker}} - {{interval}}") alertcondition(vwdema
مؤشر Pine Script®
من ‎BackQuant‎
4
Volume Liqidations [EagleVSniper]The Volume Liquidations Indicator is designed for traders who want to spot significant liquidation events in the cryptocurrency markets, particularly between spot and futures volumes. This powerful tool auto-detects the trading asset and compares the volume data from both spot and futures markets to highlight potential high-volume liquidation points that can significantly impact price movement. Raw source code owner - tartigradia Features: Auto-Detect Functionality: Automatically identifies the current trading asset, providing an option for manual selection for both spot and futures symbols. Volume Comparison: Calculates the difference between futures and spot volumes within a user-defined timeframe, helping to identify liquidation events. Customizable Parameters: Offers customizable options for multipliers, lookback periods, and timeframe selection to tailor the indicator to your trading strategy. Visual Indicators: Displays liquidation volumes as color-coded columns, with green indicating potential long liquidations and red for short liquidations. It also highlights bars that exceed the high-volume threshold, providing a clear visual cue for significant liquidation events. Spot and Futures Volume MA: Includes optional moving average plots for both spot and futures volumes, allowing for a deeper analysis of market trends. Highlighting High-Volatility Candles: The indicator uniquely colors candles that reach a predefined volatility threshold, determined by the user-set multiplier. This functionality aims to spotlight moments of significant market volatility, providing traders with immediate visual cues. Dynamic Ticker Selection: Seamlessly switches between auto and manual ticker selection, providing flexibility for all types of traders. How to Use: Setup: Configure the indicator to your preferences. You can choose between automatic or manual ticker selection, set the multiplier for the high-volume threshold, and define the lookback period for the moving average calculation. Analysis: The indicator plots differences in volume between futures and spot markets as columns on your chart, color-coded to indicate the direction of potential liquidations. Decision Making: Use the indicator to identify potential liquidation events. High-volume thresholds are highlighted, suggesting significant market movements. Combine this information with other analysis tools to make informed trading decisions.
مؤشر Pine Script®
من ‎EagleVSniper‎
Debasement Adjusted CAGREquity growth may appear less significant when juxtaposed with the expansion of the money supply. This is because markets tend to adjust prices to reflect changes in money supply almost immediately. Our indicator offers a unique perspective by adjusting the current ticker price for the M2 money supply and normalizing this data to show the percentage appreciation since the first visible bar on the chart. Users can also select alternative money supply measures, such as the EU-M2, via the indicator's settings. This approach essentially redefines the price as the "growth of the relative share of the total money supply," providing a novel lens through which to view equity performance. Additionally, the indicator computes both the Compound Annual Growth Rate (CAGR) and the total growth observed from this adjusted standpoint. These metrics are calculated within the context of the selected time range, adding depth to the analysis. Although this indicator is compatible with all timeframes, it is primarily designed as a macroeconomic tool. It yields the most meaningful insights when applied to longer-term perspectives, such as weekly or monthly timeframes. This tool builds upon the foundational work presented in the "Inflation Adjusted Performance Ticker," accessible at Inflation Adjusted Performance Ticker , enhancing its application by normalizing the results and computing CAGR and total growth.
مؤشر Pine Script®
من ‎Gradient-Descent‎
Custom Dual SMADescription The Custom Dual SMA Indicator is designed for traders who wish to track and compare the moving averages of two different financial instruments simultaneously on the same chart, usually if there is correlation between to different asset such as TQQQ vs SQQQ. This indicator is particularly useful for those who engage in comparative analysis or pairs trading strategies. Features Dual Ticker Input: Users can input any two ticker symbols (e.g., stocks, currencies, commodities) to analyze. This flexibility allows for a broad range of comparative analyses across different markets or sectors. Customizable SMA Length: The indicator provides the option to set the length of the SMA for each ticker symbol independently. This feature is critical for traders who wish to analyze the moving averages over different time periods, depending on their trading strategy or the specific characteristics of the instruments being analyzed. Overlay on Price Chart: The calculated SMAs are overlaid directly on the price chart, enabling users to easily visualize how the moving averages of the two instruments move in relation to each other and to their respective price actions. Color-Coded for Clarity: Each SMA is plotted in a different color (red and blue by default), ensuring clear differentiation and easy interpretation at a glance. Use Case This indicator is particularly beneficial for: Comparative Analysis: Traders can compare the performance and trends of two different instruments, observing how their moving averages converge or diverge over time. Pairs Trading: Those involved in pairs trading can use this tool to identify potential entry and exit points by analyzing the moving averages of two correlated or inversely correlated instruments. Diversification Analysis: Investors looking to diversify their portfolio can use this indicator to understand the moving average trends of various instruments, helping them make informed decisions about asset allocation. Summary The Custom Dual SMA Indicator is a versatile tool for traders and investors who require a comparative view of the moving averages of two different instruments on the same chart. Its customizable nature and ease of use make it suitable for a wide range of trading strategies and market analyses.
مؤشر Pine Script®
من ‎cumhurunveren‎