Inizia

Cerca negli script per " TABLE "

Indicator PanelHello All, This script shows Indicator panel in a Table. Table.new() is a new feature and released today! Thanks a lot to Pine Team to add this new great feature! This new feature is a game changer! The script shows indicator values for each symbol and changes background color of each cell by using current and last values of the indicators for each symbol. if current value is greater than last value then backgroung color is green, if lower than last value then red, if they are equals then gray. You can choose the indicators to display. Number of columns in the table is dynamic and is changed by number of the indicators. You can choose 5 different Symbols, 6 Indicators and 2 Simple or Exponential Moving averages, you can set type of moving averages and the lengths. You can also set the lengths for each Indicators. Indicators: - RSI - MACD ( MACD and Signal and Histogram ) - DMI ( +DI and -DI + and ADX ) - CCI - MFI - Momentum - MA with Length 50 (length can be set) - MA with Length 200 (length can be set) In this example RSI, MACD and MA 200 were chosen, you can see how table size changes dynamically: Enjoy!
Indicatore Pine Script®
di LonesomeTheBlue
80
Up/Down Volume with Table (High Contrast)Up/Down Volume with Table (High Contrast) — Script Summary & User Guide Purpose of the Script This TradingView indicator, Up/Down Volume with Table (High Contrast), visually separates and quantifies up-volume and down-volume for each bar, providing both a color-coded histogram and a dynamic table summarizing the last five bars. The indicator helps traders quickly assess buying and selling pressure, recent volume shifts, and their relationship to price changes, all in a highly readable format. Key Features Up/Down Volume Columns: Green columns represent volume on bars where price closed higher than the previous bar (up volume). Red columns represent volume on bars where price closed lower than the previous bar (down volume). Delta Line: Plots the net difference between up and down volume for each bar. Green when up-volume exceeds down-volume; red when down-volume dominates. Interactive Table: Displays the last five bars, showing up-volume, down-volume, delta, and close price. Color-coding for quick interpretation. Table position, decimal places, and timeframe are all user-configurable. Custom Timeframe Support: Calculate all values on the chart’s timeframe or a custom timeframe of your choice (e.g., daily, hourly). High-Contrast Design: Table and plot colors are chosen for maximum clarity and accessibility. User Inputs & Configuration Use custom timeframe: Toggle between the chart’s timeframe and a user-specified timeframe. Custom timeframe: Set the timeframe for calculations if custom mode is enabled (e.g., "D" for daily, "60" for 60 minutes). Decimal Places: Choose how many decimal places to display in the table. Table Location: Select where the table appears on your chart (e.g., Bottom Right, Top Left, etc.). How to Use Add the Script to Your Chart: Copy and paste the code into a new Pine Script indicator on TradingView. Add the indicator to your chart. Configure Inputs: Open the indicator settings. Adjust the timeframe, decimal places, and table location as desired. Read the Table: The table appears on your chart (location is user-selectable) and displays the following for the last five bars: Bar: "Now" for the current bar, then "Bar -1", "Bar -2", etc. for previous bars. Up Vol: Volume on bars where price closed higher than previous bar, shown in black text. Down Vol: Volume on bars where price closed lower than previous bar, shown in black text. Delta: Up Vol minus Down Vol, colored green for positive, red for negative, black for zero. Close: Closing price for each bar, colored green if price increased from previous bar, red if decreased, black if unchanged. Interpret the Histogram and Lines: Green Columns: Represent up-volume. Tall columns indicate strong buying volume. Red Columns: Represent down-volume. Tall columns indicate strong selling volume. Delta Line: Plotted as a line (not a column), colored green for positive values (more up-volume), red for negative (more down-volume). Large positive or negative spikes may indicate strong buying or selling pressure, respectively. How to Interpret the Table Column Meaning Color Coding Bar "Now" (current bar), "Bar -1" (previous bar), etc. Black text Up Vol Volume for bars with higher closes than previous bar Black text Down Vol Volume for bars with lower closes than previous bar Black text Delta Up Vol - Down Vol. Green if positive, red if negative, black if zero Green/Red/Black Close Closing price for the bar. Green if price increased, red if decreased, black if unchanged Green/Red/Black Green Delta: Indicates net buying pressure for that bar. Red Delta: Indicates net selling pressure for that bar. Close Price Color: Green: Price increased from previous bar. Red: Price decreased. Black: No change. Practical Trading Insights Consistently Green Delta (Histogram & Table): Sustained buying pressure; may indicate bullish sentiment or accumulation. Consistently Red Delta: Sustained selling pressure; may indicate bearish sentiment or distribution. Large Up/Down Volume Spikes: Big green or red columns can signal strong market activity or potential reversals if they occur at trend extremes. Delta Flipping Colors: Rapid alternation between green and red deltas may indicate a choppy or indecisive market. Close Price Color in Table: Use as a quick confirmation of whether volume surges are pushing price in the expected direction. Troubleshooting & Notes No Volume Data Error: If your symbol doesn’t provide volume data (e.g., some indices or synthetic assets), the script will display an error. Custom Timeframe: If using a custom timeframe, ensure your chart supports it and that there is enough data for meaningful calculations. High-Contrast Table: Designed for clarity and accessibility, but you can adjust colors in the code if needed for your personal preferences. Summary Table Legend Bar Up Vol Down Vol Delta Close Now ... ... ... ... Bar-1 ... ... ... ... ... ... ... ... ... Colors reflect the meaning as described above. In Summary This indicator visually and numerically breaks down buying and selling volume, helping you spot shifts in market sentiment, volume surges, and price/volume divergences at a glance. Use the table for precise recent data, the histogram for overall flow, and the color cues for instant market context.
Indicatore Pine Script®
di ChalkBoardAnalytics
Cobra's CryptoMarket VisualizerCobra's Crypto Market Screener is designed to provide a comprehensive overview of the top 40 marketcap cryptocurrencies in a table\heatmap format. This indicator incorporates essential metrics such as Beta, Alpha, Sharpe Ratio, Sortino Ratio, Omega Ratio, Z-Score, and Average Daily Range (ADR). The table utilizes cell coloring resembling a heatmap, allowing for quick visual analysis and comparison of multiple cryptocurrencies. The indicator also includes a shortened explanation tooltip of each metric when hovering over it's respected cell. I shall elaborate on each here for anyone interested. Metric Descriptions: 1. Beta: measures the sensitivity of an asset's returns to the overall market returns. It indicates how much the asset's price is likely to move in relation to a benchmark index. A beta of 1 suggests the asset moves in line with the market, while a beta greater than 1 implies the asset is more volatile, and a beta less than 1 suggests lower volatility. 2. Alpha: is a measure of the excess return generated by an investment compared to its expected return, given its risk (as indicated by its beta). It assesses the performance of an investment after adjusting for market risk. Positive alpha indicates outperformance, while negative alpha suggests underperformance. 3. Sharpe Ratio: measures the risk-adjusted return of an investment or portfolio. It evaluates the excess return earned per unit of risk taken. A higher Sharpe ratio indicates better risk-adjusted performance, as it reflects a higher return for each unit of volatility or risk. 4. Sortino Ratio: is a risk-adjusted measure similar to the Sharpe ratio but focuses only on downside risk. It considers the excess return per unit of downside volatility. The Sortino ratio emphasizes the risk associated with below-target returns and is particularly useful for assessing investments with asymmetric risk profiles. 5. Omega Ratio: measures the ratio of the cumulative average positive returns to the cumulative average negative returns. It assesses the reward-to-risk ratio by considering both upside and downside performance. A higher Omega ratio indicates a higher reward relative to the risk taken. 6. Z-Score: is a statistical measure that represents the number of standard deviations a data point is from the mean of a dataset. In finance, the Z-score is commonly used to assess the financial health or risk of a company. It quantifies the distance of a company's financial ratios from the average and provides insight into its relative position. 7. Average Daily Range: ADR represents the average range of price movement of an asset during a trading day. It measures the average difference between the high and low prices over a specific period. Traders use ADR to gauge the potential price range within which an asset might fluctuate during a typical trading session. Utility: Comprehensive Overview: The indicator allows for monitoring up to 40 cryptocurrencies simultaneously, providing a consolidated view of essential metrics in a single table. Efficient Comparison: The heatmap-like coloring of the cells enables easy visual comparison of different cryptocurrencies, helping identify relative strengths and weaknesses. Risk Assessment: Metrics such as Beta, Alpha, Sharpe Ratio, Sortino Ratio, and Omega Ratio offer insights into the risk associated with each cryptocurrency, aiding risk assessment and portfolio management decisions. Performance Evaluation: The Alpha, Sharpe Ratio, and Sortino Ratio provide measures of a cryptocurrency's performance adjusted for risk. This helps assess investment performance over time and across different assets. Market Analysis: By considering the Z-Score and Average Daily Range (ADR), traders can evaluate the financial health and potential price volatility of cryptocurrencies, aiding in trade selection and risk management. Features: Reference period optimization, alpha and ADR in particular Source calculation Table sizing and positioning options to fit the user's screen size. Tooltips Important Notes - 1. The Sharpe, Sortino and Omega ratios cell coloring threshold might be subjective, I did the best I can to gauge the median value of each to provide more accurate coloring sentiment, it may change in the future. The median values are : Sharpe -1, Sortino - 1.5, Omega - 20. 2. Limitations - Some cryptos have a Z-Score value of NaN due to their short lifetime, I tried to overcome this issue as with the rest of the metrics as best I can. Moreover, it limits the time horizon for replay mode to somewhere around Q3 of 2021 and that's with using the split option of the top half, to remain with the older cryptos. 3. For the beginner Pine enthusiasts, I recommend scimming through the script as it serves as a prime example of using key features, to name a few : Arrays, User Defined Functions, User Defined Types, For loops, Switches and Tables. 4. Beta and Alpha's benchmark instrument is BTC, due to cryptos volatility I saw no reason to use SPY or any other asset for that matter.
Indicatore Pine Script®
di EliCobra
18
Notional Trade Table Notional Trade Table indicator displays notional trade values for given Buy and Sell of given input of Symbol, Quantity, Entry Price and Stop Loss . Sections of Input Menu Table are supported with Tool Tip icons. Input Symbols: (Refer Input Menu) User can choose maximum 20 Symbols. Input Side Choice (BUY/SELL): (Refer Input Menu) After choosing Symbol, User has to choose the BUY or SELL option for each Symbol against the corresponding Sybol number. If NIL is selected “Nil is selected ” message is displayed prompting the user to select BUY or SELL sides. For example in the above Input Menu: Sym1 is BATS:AAPL. Corresponding Side 1 is Sell1. Sym2 is BATS:NVDA Corresponding Side 2 Sell 2. Sym12 is BATS:NFLX. Corresponding Side 12 is Buy12 and so on. Input Quantity: (Refer Input Menu) Next enter Corresponding Quantity of BUY or SELL in relevant Quantity Input Box. Quantity cannot be Zero. Defval is 1. For Sym1 input in Qty 1 box,for Sym2 input in Qty 2 box and so on. Input Entry Price: (Refer Input Menu) After entering Quantity Input Entry Price for Corresponding Symbol. Input for Sym1 Entry Price in EP1 box Input for Sym2 Entry Price in EP2 box and so on. Input Stop Loss: (Refer Input Menu) Next Enter corresponding Stop Loss for each Symbol. SL1 input box denotes Sym1 Stop Loss. SL2 input box denotes Sym2 Stop Loss. SL3 input box denotes Sym3 Stop Loss and so on. Stop Loss for Chosen BUY side should be below corresponding Entry Price/Last Price. Otherwise a message is displayed “SL Hit”. User has to enter valid data. Stop Loss for Chosen SELL side should be above corresponding Entry Price/Last Price. Otherwise a message is displayed “SL Hit”. User has to enter valid data. Notional Trade Table: (Refer the Table on Chart) From the input menu filled by User script captures the Symbol, BUY/SELL options, Quantity, Entry Price and Stop Loss details under the corresponding heads in the Notional Trade Table. The script captures the live Last traded Price under the head LP and calculates and displays corresponding Profit or Loss under PR/LO column in the table. SL+- LP is the difference between Last traded Price (LP) and Stop Loss Price. Positive figure under this head reflects Stop Loss cushion available . Nil header column reflects message “NIL selected” prompting the User to select BUY or SELL sides. SLH header displays “SL Hit” on Stop Loss Hit or wrong input of Stop Loss inconsistent with BUY or SELL sides of Trade. On “SL Hit” message all values in corresponding Symbol becomes Zero. User has to re-enter the details fresh . On the top left side corner of the table there are 2 cells with Prono and Lono.They denote the number of trades which are in Profit (Prono) and which are in Loss(Lono). It is preferable to choose Symbols from a single country exchange commensurate with the Time zone. Otherwise if Exchange and Chart time Zone differs there is risk of data loss in the table. DISCLAIMER: For educational and entertainment purpose only .Nothing in this content should be interpreted as financial advice or a recommendation to buy or sell any sort of security/ies or investment/s.
Indicatore Pine Script®
di avsr90
Crypto Daily WatchList And Screener [M] Hi, this is a watchlist and screener indicator designed for traders in the field of cryptocurrencies who want to monitor developments in other currency pairs and indices. The indicator consists of two tables. One of them is the table containing indices such as BTC dominance, total, total2, which allows you to track market developments and changes. In this table, you will find price information, daily change, stochastic, and trend information. The other table includes cryptocurrencies like BTC/USDT, ETH/USDT, DOT/USDT, and more. In this table, you will see real-time prices, daily volume, daily change, stochastic, the correlation coefficient between the pair and Bitcoin, and the trend value calculated based on MACD. The "Customize" section in the settings enables you to personalize the appearance of the tables according to your preferences.
Indicatore Pine Script®
di Milvetti
3
1A Monthly P&L Table - Using Library1A Monthly P&L Table: Track Your Performance Month-by-Month Overview: The 1A Monthly P&L Table is a straightforward yet powerful indicator designed to give you an immediate overview of your asset's (or strategy's) percentage performance on a monthly basis. Displayed conveniently in the bottom-right corner of your chart, this tool helps you quickly assess historical gains and losses, making it easier to analyze trends in performance over time. Key Features: Monthly Performance at a Glance: Clearly see the percentage change for each past month. Cumulative P&L: A running total of the displayed monthly P&L is provided, giving you a quick sum of performance over the selected period. Customizable Display: Months to Display: Choose how many past months you want to see in the table (from 1 to 60 months). Text Size: Adjust the text size (Tiny, Small, Normal, Large, Huge) to fit your viewing preferences. Text Color: Customize the color of the text for better visibility against your chart background. Intraday & Daily Compatibility: The table is optimized to display on daily and intraday timeframes, ensuring it's relevant for various trading styles. (Note: For very long-term analysis on weekly/monthly charts, you might consider other tools, as this focuses on granular monthly P&L.) How It Works: The indicator calculates the percentage change from the close of the previous month to the close of the current month. For the very first month displayed, it calculates the P&L from the opening price of the chart's first bar to the close of that month. This data is then neatly organized into a table, updated on the last bar of the day or session. Ideal For: Traders and investors who want a quick, visual summary of monthly performance. Analyzing seasonal trends or consistent periods of profitability/drawdown. Supplementing backtesting results with a clear month-by-month breakdown. Settings: Text Color: Changes the color of all text within the table. Text Size: Controls the font size of the table content. Months to Display: Determines the number of recent months included in the table.
Indicatore Pine Script®
di forexfederation
FvgPanel█ OVERVIEW This library provides functionalities for creating and managing a display panel within a Pine Script™ indicator. Its primary purpose is to offer a structured way to present Fair Value Gap (FVG) information, specifically the nearest bullish and bearish FVG levels across different timeframes (Current, MTF, HTF), directly on the chart. The library handles the table's structure, header initialization, and dynamic cell content updates. █ CONCEPTS The core of this library revolves around presenting summarized FVG data in a clear, tabular format. Key concepts include: FVG Data Aggregation and Display The panel is designed to show at-a-glance information about the closest active FVG mitigation levels. It doesn't calculate these FVGs itself but relies on the main script to provide this data. The panel is structured with columns for timeframes (TF), Bullish FVGs, and Bearish FVGs, and rows for "Current" (LTF), "MTF" (Medium Timeframe), and "HTF" (High Timeframe). The `panelData` User-Defined Type (UDT) To facilitate the transfer of information to be displayed, the library defines a UDT named `panelData`. This structure is central to the library's operation and is designed to hold all necessary values for populating the panel's data cells for each relevant FVG. Its fields include: Price levels for the nearest bullish and bearish FVGs for LTF, MTF, and HTF (e.g., `nearestBullMitLvl`, `nearestMtfBearMitLvl`). Boolean flags to indicate if these FVGs are classified as "Large Volume" (LV) (e.g., `isNearestBullLV`, `isNearestMtfBearLV`). Color information for the background and text of each data cell, allowing for conditional styling based on the FVG's status or proximity (e.g., `ltfBullBgColor`, `mtfBearTextColor`). The design of `panelData` allows the main script to prepare all display-related data and styling cues in one object, which is then passed to the `updatePanel` function for rendering. This separation of data preparation and display logic keeps the library focused on its presentation task. Visual Cues and Formatting Price Formatting: Price levels are formatted to match the instrument's minimum tick size using an internal `formatPrice` helper function, ensuring consistent and accurate display. Large FVG Icon: If an FVG is marked as a "Large Volume" FVG in the `panelData` object, a user-specified icon (e.g., an emoji) is prepended to its price level in the panel, providing an immediate visual distinction. Conditional Styling: The background and text colors for each FVG level displayed in the panel can be individually controlled via the `panelData` object, enabling the main script to implement custom styling rules (e.g., highlighting the overall nearest FVG across all timeframes). Handling Missing Data: If no FVG data is available for a particular cell (i.e., the corresponding level in `panelData` is `na`), the panel displays "---" and uses a specified background color for "Not Available" cells. █ CALCULATIONS AND USE Using the `FvgPanel` typically involves a two-stage process: initialization and dynamic updates. Step 1: Panel Creation First, an instance of the panel table is created once, usually during the script's initial setup. This is done using the `createPanel` function. Call `createPanel()` with parameters defining its position on the chart, border color, border width, header background color, header text color, and header text size. This function initializes the table with three columns ("TF", "Bull FVG", "Bear FVG") and three data rows labeled "Current", "MTF", and "HTF", plus a header row. Store the returned `table` object in a `var` variable to persist it across bars. // Example: var table infoPanel = na if barstate.isfirst infoPanel := panel.createPanel( position.top_right, color.gray, 1, color.new(color.gray, 50), color.white, size.small ) Step 2: Panel Updates On each bar, or whenever the FVG data changes (typically on `barstate.islast` or `barstate.isrealtime` for efficiency), the panel's content needs to be refreshed. This is done using the `updatePanel` function. Populate an instance of the `panelData` UDT with the latest FVG information. This includes setting the nearest bullish/bearish mitigation levels for LTF, MTF, and HTF, their LV status, and their desired background and text colors. Call `updatePanel()`, passing the persistent `table` object (from Step 1), the populated `panelData` object, the icon string for LV FVGs, the default text color for FVG levels, the background color for "N/A" cells, and the general text size for the data cells. The `updatePanel` function will then clear previous data and fill the table cells with the new values and styles provided in the `panelData` object. // Example (inside a conditional block like 'if barstate.islast'): var panelData fvgDisplayData = panelData.new() // ... (logic to populate fvgDisplayData fields) ... // fvgDisplayData.nearestBullMitLvl = ... // fvgDisplayData.ltfBullBgColor = ... // ... etc. if not na(infoPanel) panel.updatePanel( infoPanel, fvgDisplayData, "🔥", // LV FVG Icon color.white, color.new(color.gray, 70), // NA Cell Color size.small ) This workflow ensures that the panel is drawn only once and its cells are efficiently updated as new data becomes available. █ NOTES Data Source: This library is solely responsible for the visual presentation of FVG data in a table. It does not perform any FVG detection or calculation. The calling script must compute or retrieve the FVG levels, LV status, and desired styling to populate the `panelData` object. Styling Responsibility: While `updatePanel` applies colors passed via the `panelData` object, the logic for *determining* those colors (e.g., highlighting the closest FVG to the current price) resides in the calling script. Performance: The library uses `table.cell()` to update individual cells, which is generally more efficient than deleting and recreating the table on each update. However, the frequency of `updatePanel` calls should be managed by the main script (e.g., using `barstate.islast` or `barstate.isrealtime`) to avoid excessive processing on historical bars. `series float` Handling: The price level fields within the `panelData` UDT (e.g., `nearestBullMitLvl`) can accept `series float` values, as these are typically derived from price data. The internal `formatPrice` function correctly handles `series float` for display. Dependencies: The `FvgPanel` itself is self-contained and does not import other user libraries. It uses standard Pine Script™ table and string functionalities. █ EXPORTED TYPES panelData   Represents the data structure for populating the FVG information panel.   Fields:      nearestBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point (bottom for bull) on the LTF.      isNearestBullLV (series bool) : True if the nearest bullish FVG on the LTF is a Large Volume FVG.      ltfBullBgColor (series color) : Background color for the LTF bullish FVG cell in the panel.      ltfBullTextColor (series color) : Text color for the LTF bullish FVG cell in the panel.      nearestBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point (top for bear) on the LTF.      isNearestBearLV (series bool) : True if the nearest bearish FVG on the LTF is a Large Volume FVG.      ltfBearBgColor (series color) : Background color for the LTF bearish FVG cell in the panel.      ltfBearTextColor (series color) : Text color for the LTF bearish FVG cell in the panel.      nearestMtfBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point on the MTF.      isNearestMtfBullLV (series bool) : True if the nearest bullish FVG on the MTF is a Large Volume FVG.      mtfBullBgColor (series color) : Background color for the MTF bullish FVG cell.      mtfBullTextColor (series color) : Text color for the MTF bullish FVG cell.      nearestMtfBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point on the MTF.      isNearestMtfBearLV (series bool) : True if the nearest bearish FVG on the MTF is a Large Volume FVG.      mtfBearBgColor (series color) : Background color for the MTF bearish FVG cell.      mtfBearTextColor (series color) : Text color for the MTF bearish FVG cell.      nearestHtfBullMitLvl (series float) : The price level of the nearest bullish FVG's mitigation point on the HTF.      isNearestHtfBullLV (series bool) : True if the nearest bullish FVG on the HTF is a Large Volume FVG.      htfBullBgColor (series color) : Background color for the HTF bullish FVG cell.      htfBullTextColor (series color) : Text color for the HTF bullish FVG cell.      nearestHtfBearMitLvl (series float) : The price level of the nearest bearish FVG's mitigation point on the HTF.      isNearestHtfBearLV (series bool) : True if the nearest bearish FVG on the HTF is a Large Volume FVG.      htfBearBgColor (series color) : Background color for the HTF bearish FVG cell.      htfBearTextColor (series color) : Text color for the HTF bearish FVG cell. █ EXPORTED FUNCTIONS createPanel(position, borderColor, borderWidth, headerBgColor, headerTextColor, headerTextSize)   Creates and initializes the FVG information panel (table). Sets up the header rows and timeframe labels.   Parameters:      position (simple string) : The position of the panel on the chart (e.g., position.top_right). Uses position.* constants.      borderColor (simple color) : The color of the panel's border.      borderWidth (simple int) : The width of the panel's border.      headerBgColor (simple color) : The background color for the header cells.      headerTextColor (simple color) : The text color for the header cells.      headerTextSize (simple string) : The text size for the header cells (e.g., size.small). Uses size.* constants.   Returns: The newly created table object representing the panel. updatePanel(panelTable, data, lvIcon, defaultTextColor, naCellColor, textSize)   Updates the content of the FVG information panel with the latest FVG data.   Parameters:      panelTable (table) : The table object representing the panel to be updated.      data (panelData) : An object containing the FVG data to display.      lvIcon (simple string) : The icon (e.g., emoji) to display next to Large Volume FVGs.      defaultTextColor (simple color) : The default text color for FVG levels if not highlighted.      naCellColor (simple color) : The background color for cells where no FVG data is available ("---").      textSize (simple string) : The text size for the FVG level data (e.g., size.small).   Returns: _void
Libreria Pine Script®
di no1x
matrixautotableLibrary "matrixautotable" Automatic Table from Matrixes with pseudo correction for na values and default color override for missing values. uses overloads in cases of cheap float only, with additional addon for strings next, then cell colors, then text colors, and tooltips last.. basic size and location are auto, include the template to speed this up... TODO : make bools version var string group_table = ' Table' var int _tblssizedemo = input.int ( 10 ) string tableYpos = input.string ( 'middle' , '↕' , inline = 'place' , group = group_table, options= ) string tableXpos = input.string ( 'center' , '↔' , inline = 'place' , group = group_table, options= , tooltip='Position on the chart.') int _textSize = input.int ( 1 , 'Table Text Size' , inline = 'place' , group = group_table) var matrix _floatmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 0 ) var matrix _stringmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 'test' ) var matrix _bgcolormatrix = matrix.new (_tblssizedemo, _tblssizedemo, color.white ) var matrix _textcolormatrix = matrix.new (_tblssizedemo, _tblssizedemo, color.black ) var matrix _tooltipmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 'tool' ) // basic table ready to go with the aboec matrixes (replace in your code) // for demo purpose, random colors, random nums, random na vals if barstate.islast varip _xsize = matrix.rows (_floatmatrix) -1 varip _ysize = matrix.columns (_floatmatrix) -1 for _xis = 0 to _xsize -1 by 1 for _yis = 0 to _ysize -1 by 1 _randomr = int(math.random(50,250)) _randomg = int(math.random(50,250)) _randomb = int(math.random(50,250)) _randomt = int(math.random(10,90 )) bgcolor = color.rgb(250 - _randomr, 250 - _randomg, 250 - _randomb, 100 - _randomt ) txtcolor = color.rgb(_randomr, _randomg, _randomb, _randomt ) matrix.set(_bgcolormatrix ,_yis,_xis, bgcolor ) matrix.set(_textcolormatrix ,_yis,_xis, txtcolor) matrix.set(_floatmatrix ,_yis,_xis, _randomr) // random na _ymiss = math.floor(math.random(0, _yis)) _xmiss = math.floor(math.random(0, _xis)) matrix.set( _floatmatrix ,_ymiss, _xis, na) matrix.set( _stringmatrix ,_ymiss, _xis, na) matrix.set( _bgcolormatrix ,_ymiss, _xis, na) matrix.set( _textcolormatrix ,_ymiss, _xis, na) matrix.set( _tooltipmatrix ,_ymiss, _xis, na) // import here import kaigouthro/matrixautotable/1 as mtxtbl // and render table.. mtxtbl.matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _tooltipmatrix, _textSize ,tableYpos ,tableXpos) matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _tooltipmatrix, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _textcolormatrix : color      _tooltipmatrix : string      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _textcolormatrix : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _txtdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _txtdefcol : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _txtdefcol, _bgdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _txtdefcol : color      _bgdefcol : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _txtdefcol, _bgdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _txtdefcol : color      _bgdefcol : color      _textSize : int      tableYpos : string      tableXpos : string
Libreria Pine Script®
di kaigouthro
Logger Library For Pinescript (Logging and Debugging)Library "LoggerLib" This is a logging library for Pinescript. It is aimed to help developers testing and debugging scripts with a simple to use logger function. Pinescript lacks a native logging implementation. This library would be helpful to mitigate this insufficiency. This library uses table to print outputs into its view. It is simple, customizable and robust. You can start using it's .log() method just like any other logging method in other languages. ////////////////// USAGE ////////////////// -- Recommended: Please Read The Documentation From Source Code Below. It Is Much More Readable There And Will Be Updated Along With Newer Versions. -- Importing the Library --------------------- import paragjyoti2012/LoggerLib/ as Logger .init() : Initializes the library and returns the logger pointer. (Later will be used as a function parameter) .initTable: Initializes the Table View for the Logger and returns the table id. (Later will be used as a function parameter) parameters: logger: The logger pointer got from .init() max_rows_count: Number of Rows to display in the Logger Table (default is 10) offset: The offset value for the rows (Used for scrolling the view) position: Position of the Table View Values could be: left right top-right (default is left) size: Font Size of content Values could be: small normal large (default is small) hide_date: Whether to hide the Date/Time column in the Logger (default is false) returns: Table example usage of .initTable() import paragjyoti2012/LoggerLib/1 as Logger var logger=Logger.init() var logTable=Logger.initTable(logger, max_rows_count=20, offset=0, position="top-right") ------------------- LOGGING ------------------- .log() : Logging Method params: (string message, |string| logger, table table_id, string type="message") logger: pass the logger pointer from .init() table_id: pass the table pointer from .initTable() message: The message to log type: Type of the log message Values could be: message warning error info success (default is message) returns: void /////////////////////////////////////// Full Boilerplate For Using In Indicator /////////////////////////////////////// P.S: Change the | (pipe) character into square brackets while using in script (or copy it from the source code instead) offset=input.int(0,"Offset",minval=0) size=input.string("small","Font Size",options=|"normal","small","large"|) rows=input.int(15,"No Of Rows") position=input.string("left","Position",options=|"left","right","top-right"|) hide_date=input.bool(false,"Hide Time") import paragjyoti2012/LoggerLib/1 as Logger var logger=Logger.init() var logTable=Logger.initTable(logger,rows,offset,position,size,hide_date) rsi=ta.rsi(close,14) |macd,signal,hist|=ta.macd(close,12,26,9) if(ta.crossunder(close,34000)) Logger.log("Dropped Below 34000",logger,logTable,"warning") if(ta.crossunder(close,35000)) Logger.log("Dropped Below 35000",logger,logTable) if(ta.crossover(close,38000)) Logger.log("Crossed 38000",logger,logTable,"info") if(ta.crossunder(rsi,20)) Logger.log("RSI Below 20",logger,logTable,"error") if(ta.crossover(macd,signal)) Logger.log("Macd Crossed Over Signal",logger,logTable) if(ta.crossover(rsi,80)) Logger.log("RSI Above 80",logger,logTable,"success") //////////////////////////// // For Scrolling the Table View //////////////////////////// There is a subtle way of achieving nice scrolling behaviour for the Table view. Open the input properties panel for the table/indicator. Focus on the input field for "Offset", once it's focused, you could use your mouse scroll wheel to increment/decrement the offset values; It will smoothly scroll the Logger Table Rows as well. ///////////////////// For any assistance using this library or reporting issues, please write in the comment section below. I will try my best to guide you and update the library. Thanks :) /////////////////////
Libreria Pine Script®
di CyberMensch
21
Chart-Only Scanner — Pro Table v2.5.1Chart-Only Scanner — Pro Table v2.5 User Manual (Pine Script v6) What this tool does (in one line) A compact, on-chart table that scores the current chart symbol (or an optional override) using momentum, volume, trend, volatility, and pattern checks—so you can quickly decide UP, DOWN, or WAIT. Quick Start (90 seconds) Add the indicator to any chart and timeframe (1m…1M). Leave “Override chart symbol” = OFF to auto-use the chart’s symbol. Choose your layout: Row (wide horizontal strip), or Grid (title + labeled cells). Pick a size preset (Micro, Small, Medium, Large, Mobile). Optional: turn on “Use Higher TF (EMA 20/50)” and set HTF Multiplier (e.g., 4 ⇒ if chart is 15m, HTF is 60m). Watch the table: DIR (↑/↓/→), ROC%, MOM, VOL, EMA stack, HTF, REV, SCORE, ACT. Add an alert if you want: the script fires when |SCORE| ≥ Action threshold. What to expect A small table appears on the chart corner you choose, updating each bar (or only at bar close if you keep default smart-update). The ACT cell shows 🔥 (strong), 👀 (medium), or ⏳ (weak). Panels & Settings (every option explained) Core Momentum Period: Lookback for rate-of-change (ROC%). Shorter = more reactive; longer = smoother. ROC% Threshold: Minimum absolute ROC% to call direction UP (↑) or DOWN (↓); otherwise →. Require Volume Confirmation: If ON and VOL ≤ 1.0, the SCORE is forced to 0 (prevents low-volume false positives). Override chart symbol + Custom symbol: By default, the indicator uses the chart’s symbol. Turn this ON to lock to a specific ticker (e.g., a perpetual). Higher TF Use Higher TF (EMA 20/50): Compares EMA20 vs EMA50 on a higher timeframe. HTF Multiplier: Higher TF = (chart TF × multiplier). Example: on 3H chart with multiplier 2 ⇒ HTF = 6H. Volatility & Oscillators ATR Length: Used to show ATR% (ATR relative to price). RSI Length: Standard RSI; colors: green ≤30 (oversold), red ≥70 (overbought). Stoch %K Length: With %D = SMA(%K, 3). MACD Fast/Slow/Signal: Standard MACD values; we display Line, Signal, Histogram (L/S/H). ADX Length (Wilder): Wilder’s smoothing (internal derivation); also shows +DI / −DI if you enable the ADX column. EMAs / Trend EMA Fast/Mid/Slow: We compute EMA(20/50/200) by default (editable). EMA Stack: Bull if Fast > Mid > Slow; Bear if Fast < Mid < Slow; Flat otherwise. Benchmark (optional, OFF by default) Show Relative Strength vs Benchmark: Displays RS% = ROC(symbol) − ROC(benchmark) over the Momentum Period. Benchmark Symbol: Ticker used for comparison (e.g., BTCUSDT as a market proxy). Columns (show/hide) Toggle which fields appear in the table. Hiding unused fields keeps the layout clean (especially on mobile). Display Layout Mode: Row = a single two-row strip; each column is a metric. Grid = a title row plus labeled pairs (label/value) arranged in rows. Size Preset: Micro, Small, Medium, Large, Mobile change text size and the grid density. Table Corner: Where the panel sits (e.g., Top Right). Opaque Table Background: ON = dark card; OFF = transparent(ish). Update Every Bar: ON = update intra-bar; OFF = smart update (last bar / real-time / confirmed history). Action threshold (|score|): The cutoff for 🔥 and alert firing (default 70). How to read each field CHART: The active symbol name (or your custom override). DIR: ↑ (ROC% > threshold), ↓ (ROC% < −threshold), → otherwise. ROC%: Rate of change over Momentum Period. Formula: (Close − Close ) / Close × 100. MOM: A scaled momentum score: min(100, |ROC%| × 10). VOL: Volume ratio vs 20-bar SMA: Volume / SMA(Volume,20). 1.5 highlights as yellow (significant participation). ATR%: (ATR / Close) × 100 (volatility relative to price). RSI: Colored for extremes: ≤30 green, ≥70 red. Stoch K/D: %K and %D numbers. MACD L/S/H: Line, Signal, Histogram. Histogram color reflects sign (green > 0, red < 0). ADX, +DI, −DI: Trend strength and directional components (Wilder). ADX ≥ 25 is highlighted. EMA 20/50/200: Current EMA values (editable lengths). STACK: Bull/Bear/Flat as defined above. VWAP%: (Close − VWAP) / Close × 100 (premium/discount to VWAP). HTF: ▲ if HTF EMA20 > EMA50; ▼ if <; · if flat/off. RS%: Symbol’s ROC% − Benchmark ROC% (positive = outperforming). REV (reversal): 🟢 Eng/Pin = bullish engulfing or bullish pin detected, 🔴 Eng/Pin = bearish engulfing or bearish pin, · = none. SCORE (absolute shown as a number; sign shown via DIR and ACT): Components: base = MOM × 0.4 volBonus = VOL > 1.5 ? 20 : VOL × 13.33 htfBonus = use_mtf ? (HTF == DIR ? 30 : HTF == 0 ? 15 : 0) : 0 trendBonus = (STACK == DIR) ? 10 : 0 macdBonus = 0 (placeholder for future versions) scoreRaw = base + volBonus + htfBonus + trendBonus + macdBonus SCORE = DIR ≥ 0 ? scoreRaw : −scoreRaw If Require Volume Confirmation and VOL ≤ 1.0 ⇒ SCORE = 0. ACT: 🔥 if |SCORE| ≥ threshold 👀 if 50 < |SCORE| < threshold ⏳ otherwise Practical examples Strong long (trend + participation) DIR = ↑, ROC% = +3.2, MOM ≈ 32, VOL = 1.9, STACK = Bull, HTF = ▲, REV = 🟢 SCORE: base(12.8) + volBonus(20) + htfBonus(30) + trend(10) ≈ 73 → ACT = 🔥 Action idea: look for longs on pullbacks; confirm risk with ATR%. Weak long (no volume) DIR = ↑, ROC% = +1.0, but VOL = 0.8 and Require Volume Confirmation = ON SCORE forced to 0 → ACT = ⏳ Action: wait for volume > 1.0 or turn off confirmation knowingly. Bearish reversal warning DIR = →, REV = 🔴 (bearish engulfing), RSI = 68, HTF = ▼ SCORE may be mid-range; ACT = 👀 Action: watch for breakdown and rising VOL. Alerts (how to use) The script calls alert() whenever |SCORE| ≥ Action threshold. To receive pop-ups, sounds, or emails: click “⏰ Alerts” in TradingView, choose this indicator, and pick “Any alert() function call.” The alert message includes: symbol, |SCORE|, DIR. Layout, Size, and Corner tips Row is best when you want a compact status ribbon across the top. Grid is clearer on big screens or when you enable many columns. Size: Mobile = one pair per row (tall, readable) Micro/Small = dense; good for many fields Large = presentation/screenshots Corner: If the table overlaps price, change the corner or set Opaque Background = OFF. Repaint & timeframe behavior Default smart update prefers stability (last bar / live / confirmed history). For a stricter, “close-only” behavior (less repaint): turn Update Every Bar = OFF and avoid Heikin Ashi when you want raw market OHLC (HA modifies price inputs). HTF logic is derived from a clean, integer multiple of your chart timeframe (via multiplier). It works with 3H/4H and any TF. Performance notes The script analyzes one symbol (chart or override) with multiple metrics using efficient tuple requests. If you later want a multi-symbol grid, do it with pages (10–15 per page + rotate) to stay within platform limits (recommended future add-on). Troubleshooting No table visible Ensure the indicator is added and not hidden. Try toggling Opaque Background or switch Corner (it might be behind other drawings). Keep Columns count reasonable for the chosen Size. If you turned ON Override, verify the Custom symbol exists on your data provider. Numbers look different on HA candles Heikin Ashi modifies OHLC; switch to regular candles if you need raw price metrics. 3H/4H issues Use integer HTF Multiplier (e.g., 2, 4). The tool builds the correct string internally; no manual timeframe strings needed. Power user tips Volume gating: keeping Require Volume Confirmation = ON filters most fake moves; if you’re a scalper, reduce strictness or turn it off. Action threshold: 60–80 is typical. Higher = fewer but stronger signals. Benchmark RS%: great for spotting leaders/laggards; positive RS% = outperformance vs benchmark. Change policy & safety This version doesn’t alter your historical logic you tested (no radical changes). Any future “radical” change (score weights, HTF logic, UI hiding data) will ship with a toggle and an Impact Statement so you can keep old behavior if you prefer. Glossary (quick) ROC%: Percent change over N bars. MOM: Scaled momentum (0–100). VOL ratio: Volume vs 20-bar average. ATR%: ATR as % of price. ADX/DI: Trend strength / direction components (Wilder). EMA stack: Relationship between EMAs (bullish/bearish/flat). VWAP%: Premium/discount to VWAP. RS%: Relative strength vs benchmark.
Indicatore Pine Script®
di humoudq8
cc AJGB Candle Range Finder with TableOverview: The "cc AJGB Candle Range Finder with Table" is a versatile Pine Script indicator designed to identify and visualize price ranges within the 1 minute charts based on UTC+2 Time Zone. Unlike traditional range indicators, it offers three unique calculation methods to define ranges based on minute and hour interactions, displays ranges as boxes with labeled point values, and summarizes average range sizes in a customizable table. This tool is ideal for analyzing price ranges of specific time based ranges. Features: Customizable Time Range: Users specify a start and end minute (0-59) to define the range period (e.g., 29th to 35th minute). Three Calculation Methods: Minute Only: Uses the minute of each bar to identify ranges (e.g., matches user-specified minutes). Minute - Hour: Adjusts the minute by subtracting the hour, allowing for dynamic range detection across hourly cycles. Minute + Hour: Combines minute and hour values for a unique range calculation, useful for specific intraday patterns. Visual Output: Draws boxes around detected ranges, with labels showing the start/end minutes and range size in points. Summary Table: Displays the average range size (in points) for each method, with customizable position, colors, and text size. How It Works: The indicator evaluates each bar’s timestamp in (UTC+2 ONLY) to match user-specified minutes using one or more selected methods. When a start minute is detected, it tracks the high and low prices until the end minute, drawing a box to highlight the range and labeling it with the range size in points. A table summarizes the average range size for each method, helping traders assess typical price movements during the specified period. Market Analysis: Compare range sizes across different methods to understand intraday volatility patterns. Settings Customization: Adjust colors, table position, and label sizes to suit your chart preferences. Settings: Range to Find: Set start and end minutes. Range Selection: Enable/disable each method and customize colors. Range Label Size: Choose label size (Tiny to Huge). Table Settings: Configure table position (Top, Bottom, Left, Right), sub-position, text size, and colors. Notes: Only works on 1 minute charts The indicator works best using Start Times that are lower than the End Times. Ensure the chart is set to UTC+2 Time Zone for accurate range detection. Why It’s Unique: Unlike standard range indicators that focus on sessions or fixed periods, this tool allows precise minute-based range detection with three distinct calculation methods, offering flexibility for data gathering. The interactive table provides quick insights into average range sizes.
Indicatore Pine Script®
di THE_REF
Investing - Correlation Table This correlation tables idea is nothing new, many sites provides it. However, I couldn't find any simple correlation indicator on TradingView despite how simple this indicator is. This indicator works as its called. Calculating the correlation between 2 projects (can be used in stocks as well) using the 'ta.correlation' feature built into pinescript. When it comes to investing, we do not want our stocks / crypto project to be heavily correlated to each other. If they are heavily correlated to each other, then there isn't much point in diversifying. That being said, it can be useful for traders who trade multiple pairs. ----------------------------------------------------------------------------------------------------------------------------------------------------------- In this indicator, consist of 5 primary input and 15 secondary input (Symbol List). Correlation Source: This input options allow you to change how the correlation is calculated. By default, it uses 'close'. Correlation Percentage(%): This input options allows you configure how many (%) of correlation is considered as 'decoupled'. This correlation will only move between -100% ~ 100%. 100% refers to it moving together. -100% refers to it moving the opposite direction. For example, Project A rises in Price, what is the possibility of Project B following: A 100% correlation between Project A and Project B, refers to Project B will follow Project A movement. A 50% correlation between Project A and Project B, refers to there is only 50% chance for Project B to follow Project A movement. A -20% correlation between Project A and Project B, refers to there is a 20% chance of Project B moving the opposite direction of Project A (Refers to the table on chart above to better understand what the numbers means. DOT/USD has a 100% correlation to DOT/USD. However. MXCUSDT has a -37.2% correlation to DOT/USD.) Amounts Bars To Check: This input options will check the amount of bars since the last bar in the chart. If you want to know the correlation of the past 100 days in a daily chart, you will enter '100' into this options and it will check only the past 100 days. Symbol List This will allow you to input all the project symbol ticker ID to add into the correlation table. ----------------------------------------------------------------------------------------------------------------------------------------------------------- Originally, I wish to use for loop to go through the symbol list to reduce the amount of code required. However, due to limitation of 'request.security' feature, I had to abandon that idea and use hard-coded for requesting security and use a while loop to identify the symbol correlation value in the array set then set the table value accordingly. If there is any script writer could improve this or any unclear explanation, feel free to drop a comment below.
Indicatore Pine Script®
di RrBc2
2
Stochastic RSI with MTF TableShort Description of the Script The provided Pine Script indicator, titled "Stochastic RSI with MTF Table," calculates and displays the Stochastic RSI for the current timeframe and multiple other timeframes (5m, 15m, 30m, 60m, 240m, and daily). The Stochastic RSI is a momentum indicator that blends the Relative Strength Index (RSI) and Stochastic Oscillator to identify overbought and oversold conditions, as well as potential trend reversals via K and D line crossovers. Key features of the script include: Inputs: Customizable parameters such as K smoothing (default 3), D smoothing (default 3), RSI length (default 14), Stochastic length (default 14), source price (default close), and overbought/oversold levels (default 80/20). MTF Table: A table displays the Stochastic RSI status for each timeframe: "OB" (overbought) if K > 80, "OS" (oversold) if K < 20, or "N" (neutral) otherwise. Crossovers: "K↑D" for bullish (K crosses above D) and "K↓D" for bearish (K crosses below D). Visualization: Plots the K and D lines for the current timeframe, with horizontal lines at 80 (overbought), 50 (middle), and 20 (oversold), plus a background fill for clarity. Table Position: Configurable to appear in one of four chart corners (default: top-right). This indicator helps traders assess momentum across multiple timeframes simultaneously, aiding in the identification of trend strength and potential entry/exit points. Trading Strategy with 50EMA and 200EMA for Highest Winning Rate To create a strategy with the best probability of a high winning rate using the Stochastic RSI MTF indicator alongside the 50-period Exponential Moving Average (50EMA) and 200-period Exponential Moving Average (200EMA), we can combine trend identification with momentum-based entry timing. The 50EMA and 200EMA are widely used to determine medium- and long-term trends, while the Stochastic RSI MTF table provides multi-timeframe momentum signals. Here’s the strategy: 1. Determine the Overall Trend Bullish Trend: The 50EMA is above the 200EMA on the current timeframe (e.g., daily or 60m chart). This suggests an uptrend, often associated with a "Golden Cross." Bearish Trend: The 50EMA is below the 200EMA on the current timeframe. This indicates a downtrend, often linked to a "Death Cross." Implementation: Plot the 50EMA and 200EMA on your chart and visually confirm their relative positions. 2. Identify Entry Signals Using the Stochastic RSI MTF Table In a Bullish Trend (50EMA > 200EMA): Look for timeframes in the MTF table showing: Oversold (OS): K < 20, indicating a potential pullback in the uptrend where price may rebound. Bullish Crossover (K↑D): K crosses above D, signaling rising momentum and a potential entry point. Example: If the 60m and 240m timeframes show "OS" or "K↑D," this could be a buy signal. In a Bearish Trend (50EMA < 200EMA): Look for timeframes in the MTF table showing: Overbought (OB): K > 80, suggesting a rally in the downtrend where price may reverse downward. Bearish Crossover (K↓D): K crosses below D, indicating declining momentum and a potential short entry. Example: If the 30m and daily timeframes show "OB" or "K↓D," this could be a sell/short signal. Current Timeframe Check: Use the plotted K and D lines on your trading timeframe for precise entry timing (e.g., confirm a K↑D crossover on a 60m chart for a long trade). 3. Confirm Signals Across Multiple Timeframes Strengthen the Signal: A higher winning rate is more likely when multiple timeframes align with the trend and signal. For instance: Bullish trend + "OS" or "K↑D" on 60m, 240m, and daily = strong buy signal. Bearish trend + "OB" or "K↓D" on 15m, 60m, and 240m = strong sell signal. Prioritize Higher Timeframes: Signals from the 240m or daily timeframe carry more weight due to their indication of broader trends, increasing reliability. 4. Set Stop-Loss and Take-Profit Levels Long Trades (Bullish): Stop-Loss: Place below the most recent swing low or below the 50EMA, whichever is closer, to protect against trend reversals. Take-Profit: Target a key resistance level or use a risk-reward ratio (e.g., 2:1 or 3:1) based on the stop-loss distance. Short Trades (Bearish): Stop-Loss: Place above the most recent swing high or above the 50EMA, whichever is closer. Take-Profit: Target a key support level or apply a similar risk-reward ratio. Trailing Stop Option: As the trend progresses, trail the stop below the 50EMA (for longs) or above it (for shorts) to lock in profits. 5. Risk Management Position Sizing: Risk no more than 1-2% of your trading capital per trade to minimize losses from false signals. Volatility Consideration: Adjust stop-loss distances and position sizes based on the asset’s volatility (e.g., wider stops for volatile stocks or crypto). Avoid Overtrading: Wait for clear alignment between the EMA trend and MTF signals to avoid low-probability setups. Example Scenario Chart: 60-minute timeframe. Trend: 50EMA > 200EMA (bullish). MTF Table: 60m shows "OS," 240m shows "K↑D," and daily is "N." Action: Enter a long position when the 60m K line crosses above D, confirming the table signal. Stop-Loss: Below the recent 60m swing low (e.g., 2% below entry). Take-Profit: At the next resistance level or a 3:1 reward-to-risk ratio. Outcome: High probability of success due to trend alignment and multi-timeframe confirmation. Why This Strategy Works Trend Following: Trading in the direction of the 50EMA/200EMA trend reduces the risk of fighting the market’s momentum. Momentum Timing: The Stochastic RSI MTF table pinpoints pullbacks or reversals within the trend, improving entry timing. Multi-Timeframe Confirmation: Alignment across timeframes filters out noise, increasing the win rate. Risk Control: Defined stop-loss and position sizing protect against inevitable losses. Caveats No strategy guarantees a 100% win rate; false signals can occur, especially in choppy markets. Test this strategy on historical data or a demo account to verify its effectiveness for your asset and timeframe. This approach leverages the strengths of both trend-following (EMA) and momentum (Stochastic RSI) tools, aiming for a high-probability, disciplined trading system.
Indicatore Pine Script®
di IP2290
Volume-Supported Linear Regression Trend TableThe "Volume-Supported Linear Regression Trend Table" (VSLRT Table) script helps traders identify buy and sell opportunities by analyzing price trends and volume dynamics across multiple timeframes. It uses linear regression to calculate the trend direction and volume strength, visually representing this data with color-coded signals on the chart and in a table. Green signals indicate buying opportunities, while red signals suggest selling, with volume acting as confirmation of trend strength. Traders can use these signals for both short and long positions, with additional risk management and multi-timeframe validation to enhance the strategy. ------------------------------------------------------------------------------ To use the "Volume-Supported Linear Regression Trend Table" (VSLRT Table) script in a trading strategy, you would incorporate it into your decision-making process to identify potential buy and sell opportunities based on the trend and volume dynamics. Here’s how you could apply it for trading: 1. Understanding the Key Elements: Trend Direction (Slope of Price): The script uses linear regression to assess the trend direction of the price. If the price slope is positive, the asset is likely in an uptrend; if it's negative, the asset is in a downtrend. Volume-Backed Signals: The buy or sell signal is not only based on the price trend but also on volume. Volume is crucial in validating the strength of a trend; large volume often indicates strong interest in a direction. 2. Interpreting the Table and Signals: The table displayed at the bottom-right of your TradingView chart gives you a clear overview of the trends across different timeframes: Trend Colors: Green hues (e.g., ccol11, ccol12, etc.): Indicate a buying trend supported by volume. Red hues (e.g., ccol21, ccol22, etc.): Indicate a selling trend supported by volume. Gray: Indicates weak or unclear trends where no decisive direction is present. Buy/Sell Signals: The script plots triangles on the chart: Upward triangle below the bar signals a potential buy. Downward triangle above the bar signals a potential sell. 3. Building a Trading Strategy: Here’s how you can incorporate the script’s information into a trading strategy: Buy Signal (Long Entry): Look for green triangles (indicating a buy signal) below a bar. Confirm that the trend color in the table for the relevant timeframe is green, which shows that the buy signal is supported by strong volume. Ensure that the price is in an uptrend (positive slope) and that volume is increasing on upward moves, as this indicates buying interest. Execute a long position when these conditions align. Sell Signal (Short Entry): Look for red triangles (indicating a sell signal) above a bar. Confirm that the trend color in the table for the relevant timeframe is red, which shows that the sell signal is supported by strong volume. Ensure that the price is in a downtrend (negative slope) and that volume is increasing on downward moves, indicating selling pressure. Execute a short position when these conditions align. Exiting the Trade: Exit a long position when a sell signal (red triangle) appears, or when the trend color in the table shifts to red. Exit a short position when a buy signal (green triangle) appears, or when the trend color in the table shifts to green. 4. Multi-Timeframe Confirmation: The script provides trends across multiple timeframes (tf1, tf2, tf3), which can help in validating your trade: Short-Term Trading: Use shorter timeframes (e.g., 3, 5 minutes) for intraday trades. If both short and medium timeframes align in trend direction (e.g., both showing green), it strengthens the signal. Longer-Term Trading: If you are trading on a higher timeframe (e.g., daily or weekly), confirm that the lower timeframes align with your intended trade direction. 5. Adding Risk Management: Stop-Loss: Place stop-losses below recent lows (for long trades) or above recent highs (for short trades) to minimize risk. Take Profit: Consider taking profit at key support/resistance levels or based on a fixed risk-to-reward ratio (e.g., 2:1). Example Strategy Flow: For Long (Buy) Trade: Signal: A green triangle appears below a candle (Buy signal). Trend Confirmation: Check that the color in the table for your selected timeframe is green, confirming the trend is supported by volume. Execute Long: Enter a long trade if the price is trending upward (positive price slope). Exit Long: Exit when a red triangle appears above a candle (Sell signal) or if the trend color shifts to red in the table. For Short (Sell) Trade: Signal: A red triangle appears above a candle (Sell signal). Trend Confirmation: Check that the color in the table for your selected timeframe is red, confirming the trend is supported by volume. Execute Short: Enter a short trade if the price is trending downward (negative price slope). Exit Short: Exit when a green triangle appears below a candle (Buy signal) or if the trend color shifts to green in the table. 6. Fine-Tuning: Backtesting: Before trading live, use TradingView’s backtesting features to test the strategy on historical data and optimize the settings (e.g., length of linear regression, timeframe). Combine with Other Indicators: Use this strategy alongside other technical indicators (e.g., RSI, MACD) for better confirmation. In summary, the script helps identify trends with volume support, giving more confidence in buy/sell decisions. Combining these signals with risk management and multi-timeframe analysis can create a solid trading strategy.
Indicatore Pine Script®
di Hampeh
1
VNIndex Over 6.5% Downside Drop Indicator with TableOverview: The VNIndex 6.5% Downside Drop Indicator is a powerful tool designed to help traders and investors identify significant market drops on the VNIndex (or any other asset) based on a 6.5% downside threshold. This Pine Script® indicator automatically detects when the price of an asset drops by more than 6.5% within a single day, and visually marks those events on the chart. Key Features: 6.5% Downside Drop Detection: Automatically calculates the daily percentage drop and identifies when the price falls by more than 6.5%. Table Display: Displays the dates and corresponding percentage drops of all identified instances in a convenient table at the bottom right of the chart. Markers: Red down-pointing markers are plotted above bars where the price drop exceeds the 6.5% threshold, making it easy to spot critical drop events at a glance. Easy-to-Read Table: The table lists the date and drop percentage, updating dynamically as new drops are detected. This allows for easy tracking of significant downside moves over time. How to Use: Install the Script: Add this indicator to your TradingView chart. Monitor Price Drops: The indicator will automatically detect when the price drops by over 6.5% from the previous close and display a marker on the chart and the table in the bottom right corner. View the Table: The table displays the date and the percentage drop of each detected event, making it easy to track past significant moves. Alerts: You can set an alert for 6.5% drops to receive notifications in real-time. Customization Options: The drop percentage threshold (6.5%) can be adjusted in the script to fit other market conditions or assets. The table can be resized or styled based on user preference for better visibility. Why Use This Indicator? This indicator is perfect for traders looking to spot large, significant price movements quickly. Large downside drops can signal potential market reversals or trading opportunities, and this tool helps you track such events effortlessly. Whether you're monitoring the VNIndex or any other asset, this indicator provides crucial insights into volatile price action, helping you make more informed decisions. Open Source License: This indicator is open source and free to use under the Mozilla Public License 2.0. You are welcome to modify, distribute, and contribute to the project. Contributions: Feel free to contribute improvements, fixes, or new features by creating a pull request. Let’s collaborate to make this indicator even better for the community!
Indicatore Pine Script®
di doqkhanh
Bollinger Levels Table - Horizontal Support ZonesBollinger Levels Table - Horizontal Support Zones Indicator (with Customizable Options) The "Bollinger Levels Table - Horizontal Support Zones" indicator is a comprehensive tool designed to help you identify potential support areas on your chart using moving averages and Bollinger Bands. The indicator displays an organized table of key price levels and draws horizontal lines on the chart, providing clear visibility of potential support zones. What Does This Indicator Do? This indicator aims to simplify support analysis by consolidating and displaying significant price levels derived from three different Bollinger Band settings: BB10, BB20, and BB50. It calculates both the Mid-line (Basis) and the Lower Band for each of these settings. Furthermore, the indicator automatically arranges these levels from highest to lowest in an easy-to-read table, assigning a "Payment" label to each level. These "Payments" are simply labels to help you track the levels in descending order. How Does This Indicator Work? Bollinger Band Calculations: The indicator uses the standard Bollinger Band formula: Mid-line (Basis): A Simple Moving Average (SMA) of the closing price over a specified period. Standard Deviation (Dev): The standard deviation of the closing price over the same period, multiplied by a Multiplier. Lower Band: The Mid-line minus the Standard Deviation. These calculations are applied to three different periods: 10, 20, and 50, providing a variety of potential support levels based on different timeframes. You can adjust the values for these lengths (10, 20, 50) and the Multiplier through the indicator's settings. Table Construction: A dynamic table is created on the chart (which can be positioned in the top or bottom right corner based on the current price's position). This table displays: Indicator: The name of the Bollinger Band level (e.g., BB10 Mid, BB20 Lower). Price: The exact price value of that level. Payments: A label indicating the level's order in the table. Level Ordering: All calculated levels are dynamically sorted from highest to lowest to present them in a logical order within the table. Horizontal Line Plotting: Horizontal lines are drawn on the chart for each selected level, providing a visual representation of the potential support areas. These lines are colored black and have a consistent width for easy identification. How to Use This Indicator: This indicator is intended to provide potential entry points or accumulation zones for trades, especially for traders employing Dollar-Cost Averaging (DCA) strategies or building positions in stages. The levels displayed in the table and on the chart can represent potential support levels where one might consider initiating or adding to a position. In the indicator's settings, you'll find important options: Multiplier: Controls the width of the Bollinger Bands (default 2.0). BB Lengths: Allows you to adjust the periods for the moving averages (default 20, 50, 10). Visible Levels: This is the new feature! Here, you can select which levels you wish to see in the table and on the chart. Simply check or uncheck the boxes next to each level (BB10 Mid, BB10 Lower, and so on) to customize the indicator's display according to your strategy and needs. Underlying Concepts: This indicator is based on the principle that Bollinger Bands can act as dynamic support and resistance zones. Mid-line (SMA): Often functions as a medium-term support or resistance. Lower Band: Typically indicates that the price is relatively low and may find support, making it a potential area for buying or starting to build a position. By combining different Bollinger Band timeframes (10, 20, 50), the indicator gives you a multi-timeframe perspective on support areas, helping you identify the most relevant levels for your strategy. Note: While the indicator provides "Payments" for the levels, this is purely a sequential labeling within the table to assist your position-building strategy. There is no actual payment functionality associated with this indicator.
Indicatore Pine Script®
di khalidaladdin1990
RISK MANAGEMENT TABLEThis updated Risk Management Indicator is a powerful and customizable tool designed to help traders effectively manage risk on every trade. By dynamically calculating position size, stop-loss, and take-profit levels, it enables traders to stay disciplined and follow predefined risk parameters directly on their charts. Features: Dynamic Stop-Loss and Take-Profit Levels: Stop-loss is based on the Average True Range (ATR), offering a flexible way to account for market volatility. Take-profit levels can be customized as a percentage of the entry price, providing a clear target for trade exits. Position Sizing Calculation: The indicator computes the maximum position size by considering: Trade amount (montant_ligne). Risk percentage per trade. Transaction fees. Visual Representation: Displays stop-loss and take-profit levels on the chart as customizable lines. Optional visibility of these lines through checkboxes in the settings panel. Comprehensive Risk Table: A table on the chart summarizes essential risk metrics: Stop-loss value. Distance from entry in percentage. Position size (maximum suggested). Take-profit price. Customizable: Adjust parameters like ATR length, smoothing type, risk percentage, transaction fees, and take-profit percentage. Modify the visual length of lines representing stop-loss and take-profit levels. How It Works: Stop-Loss Calculation: The stop-loss level is calculated using ATR and a volatility factor (default: 2). This ensures your stop-loss adapts to market conditions. Take-Profit Calculation: Take-profit is derived as a percentage increase from the entry price. Position Size: The optimal position size is computed as: Position Size = Risk per Trade /ATR-based Stop Distance The risk per trade deducts transaction fees to provide a more accurate calculation. Visual Lines: Risk Table: The table displays updated stop-loss, position size, and take-profit metrics at a glance. Settings Panel: Length: ATR length for calculating market volatility. Smoothing: Choose RMA, SMA, EMA, or WMA for ATR smoothing. Trade Amount: The capital allocated to a single trade. Risk by Trade (%): Define how much of your trade capital is at risk per trade. Transaction Fees: Input fees to ensure realistic calculations. Take Profit (%): Specify your desired take-profit percentage. Show Entry Stop Loss: Toggle visibility of the stop-loss line. Show Entry Take Profit: Toggle visibility of the take-profit line.
Indicatore Pine Script®
di DynamiqueTrader
Divergence for Many Indicators v4 Screener▋ INTRODUCTION: The “Divergence for Many Indicators v4 Screener” is developed to provide an advanced monitoring solution for up to 24 symbols simultaneously. It efficiently collects signals from multiple symbols based on the “ Divergence for Many Indicators v4 ” and presents the output in an organized table. The table includes essential details starting with the symbol name, signal price, corresponding divergence indicator, and signal time. _______________________ ▋ CREDIT: The divergence formula adapted from the “ Divergence for Many Indicators v4 ” script, originally created by @LonesomeTheBlue . Full credit to his work. _______________________ ▋ OVERVIEW: The chart image can be considered an example of a recorded divergence signal that occurred in $BTCUSDT. _______________________ ▋ APPEARANCE: The table can be displayed in three formats: 1. Full indicator name. 2. First letter of the indicator name. 3. Total number of divergences. _______________________ ▋ SIGNAL CONFIRMATION: The table distinguishes signal confirmation by using three different colors: 1. Not-Confirmed (Orange): The signal is not confirmed yet, as the bar is still open. 2. Freshly Confirmed (Green): The signal was confirmed 1 or 2 bars ago. 3. Confirmed (Gray): The signal was confirmed 3 or more bars ago. _______________________ ▋ INDICATOR SETTINGS: Section(1): Table Settings (1) Table location on the chart. (2) Table’s cells size. (3) Chart’s timezone. (4) Sorting table.            - Signal: Sorts the table by the latest signals.            - None: Sorts the table based on the input order. (5) Table’s colors. (6) Signal Confirmation type color. Explained above in the SIGNAL CONFIRMATION section Section(2): Divergence for Many Indicators v4 Settings As seen on the Divergence for Many Indicators v4 * Explained above in the APPEARANCE section Section(3): Symbols (1) Enable/disable symbol in the screener. (2) Entering a symbol. _______________________ ▋ FINAL COMMENTS: For best performance, add the Screener indicator to an active symbol chart, such as QQQ, SPY, AAPL, BTCUSDT, ES, EURUSD, etc., and avoid mixing symbols from different market allocations. The Divergence for Many Indicators v4 Screener indicator is not a primary tool for making trading decisions.
Indicatore Pine Script®
di MUQWISHI
15
MACD Histogram Color Tabledisplaying the MACD Histogram color and divergences across multiple timeframes. Here's how it works step by step: 1. Setting the Table Position The script allows the user to choose where the table will be placed using the positionOption input. The three options are: Top Right Top Left Top Center Depending on the selected option, the table is created at the corresponding position. 2. Creating the Table A table (macdTable) is created with 8 columns (for different timeframes) and 3 rows (for different data points). 3. MACD Histogram Color Function (f_get_macd_color) This function calculates the MACD line, signal line, and histogram for a given timeframe. The histogram (histLine) is used to determine the cell background color: Green if the histogram is positive. Red if the histogram is negative. 4. Divergence Detection Function (f_detect_divergence) This function looks for bullish and bearish divergences using the MACD histogram: Bullish Divergence (🟢) The price makes a lower low. The MACD histogram makes a higher low. Bearish Divergence (🔴) The price makes a higher high. The MACD histogram makes a lower high. The function returns: 🟢 (green circle) for bullish divergence. 🔴 (red circle) for bearish divergence. "" (empty string) if no divergence is detected. 5. Populating the Table The table has three rows for each timeframe: First row: Displays the timeframe labels (5m, 15m, 30m, etc.). Second row: Shows MACD Histogram color (red/green). Third row: Displays divergences (🟢/🔴). This is done using table.cell() for each timeframe. 6. Final Result A table is displayed on the chart. Each column represents a different timeframe. The color-coded row shows the MACD histogram status. The bottom row shows detected divergences.
Indicatore Pine Script®
di vs_n
Stock Table aiTrendviewProfessional Stock Market Monitoring Table (Pine Script v5) This indicator is a real-time multi-asset monitoring table designed for professional traders, analysts, and portfolio managers using TradingView. Built with Pine Script v5, it enables users to track up to 10 instruments (stocks, indices, forex pairs, cryptocurrencies, or commodities) in a unified table embedded directly into the chart. It is intended to streamline portfolio monitoring, cross-market analysis, and rapid visual comparison of asset performance. The core logic of this script involves retrieving live price data through TradingView’s request.security() function for each of the selected symbols. It calculates both absolute price change and percentage price change relative to the previous bar close. This ensures users can see real-time movements in each asset’s price. These calculations are updated at the close of every bar to optimize performance and reduce processing load using the barstate.islast condition. The display structure is dynamically generated using table.new() and related functions. Internally, the script stores symbol and price data in arrays for efficient processing. Symbols are cleaned to remove exchange prefixes (e.g., "NASDAQ:", "BINANCE:") so only the ticker name is displayed. Based on the selected layout (1 to 5 columns), the table auto-adjusts its row structure to maintain clarity and symmetry. Each cell reflects the ticker symbol, current price, and changes, with conditional formatting applied to indicate price movement direction using green (positive), red (negative), or neutral colors. Users can customize many visual elements including text size, color themes, transparency, table position, and whether headers are shown. The script includes built-in fallbacks for invalid symbols or empty data, ensuring robustness and uninterrupted performance during live market hours. Use cases include: Intraday traders monitoring multiple instruments simultaneously. Swing traders assessing relative strength and correlation. Portfolio managers scanning asset performance without switching charts. Analysts preparing multi-asset presentations or watchlists. To use the tool: Paste the Pine Script into the Pine Editor. Add the script to the chart. Enter your desired symbols via the input fields. Customize table position, layout, size, and color to suit your workspace. This script does not provide trade signals or financial advice. It is purely a market visualization and data presentation tool. All calculations are based on live chart data and are synchronized with the chart’s timeframe. Disclaimer from aiTrendview: This script is a visual tool developed for market awareness and comparative observation. It does not constitute financial advice or guarantee trading results. aiTrendview and its affiliates are not responsible for any losses arising from decisions made based on this tool. All trading involves risk, and past performance is not indicative of future results. Always consult with a qualified financial advisor before making trading decisions.
Indicatore Pine Script®
di aiTrendview-Charting-System
Multi TF Oscillators Screener [TradingFinder] RSI / ATR / Stoch🔵 Introduction The oscillator screener is designed to simplify multi-timeframe analysis by allowing traders and analysts to monitor one or multiple symbols across their preferred timeframes—all at the same time. Users can track a single symbol through various timeframes simultaneously or follow multiple symbols in selected intervals. This flexibility makes the tool highly effective for analyzing diverse markets concurrently. At the core of this screener lie two essential oscillators: RSI (Relative Strength Index) and the Stochastic Oscillator. The RSI measures the speed and magnitude of recent price movements and helps identify overbought or oversold conditions. It's one of the most reliable indicators for spotting potential reversals. The Stochastic Oscillator, on the other hand, compares the current price to recent highs and lows to detect momentum strength and potential trend shifts. It’s especially effective in identifying divergences and short-term reversal signals. In addition to these two primary indicators, the screener also displays helpful supplementary data such as the dominant candlestick type (Bullish, Bearish, or Doji), market volatility indicators like ATR and TR, and the four key OHLC prices (Open, High, Low, Close) for each symbol and timeframe. This combination of data gives users a comprehensive technical view and allows for quick, side-by-side comparison of symbols and timeframes. 🔵 How to Use This tool is built for users who want to view the behavior of a single symbol across several timeframes simultaneously. Instead of jumping between charts, users can quickly grasp the state of a symbol like gold or Bitcoin across the 15-minute, 1-hour, and daily timeframes at a glance. This is particularly useful for traders who rely on multi-timeframe confirmation to strengthen their analysis and decision-making. The tool also supports simultaneous monitoring of multiple symbols. Users can select and track various assets based on the timeframes that matter most to them. For example, if you’re looking for entry opportunities, the screener allows you to compare setups across several markets side by side—making it easier to choose the most favorable trade. Whether you’re a scalper focused on low timeframes or a swing trader using higher ones, the tool adapts to your workflow. The screener utilizes the widely-used RSI indicator, which ranges from 0 to 100 and highlights market exhaustion levels. Readings above 70 typically indicate potential pullbacks, while values below 30 may suggest bullish reversals. Viewing RSI across timeframes can reveal meaningful divergences or alignments that improve signal quality. Another key indicator in the screener is the Stochastic Oscillator, which analyzes the closing price relative to its recent high-low range. When the %K and %D lines converge and cross within the overbought or oversold zones, it often signals a momentum reversal. This oscillator is especially responsive in lower timeframes, making it ideal for spotting quick entries or exits. Beyond these oscillators, the table includes other valuable data such as candlestick type (bullish, bearish, or doji), volatility measures like ATR and TR, and complete OHLC pricing. This layered approach helps users understand both market momentum and structure at a glance. Ultimately, this screener allows analysts and traders to gain a full market overview with just one look—empowering faster, more informed, and lower-risk decision-making. It not only saves time but also enhances the precision and clarity of technical analysis. 🔵 Settings 🟣 Display Settings Table Size : Lets you adjust the table’s visual size with options such as: auto, tiny, small, normal, large, huge. Table Position : Sets the screen location of the table. Choose from 9 possible positions, combining vertical (top, middle, bottom) and horizontal (left, center, right) alignments. 🟣 Symbol Settings Each of the 10 symbol slots comes with a full set of customizable parameters : Enable Symbol : A checkbox to activate or hide each symbol from the table. Symbol : Define or select the asset (e.g., XAUUSD, BTCUSD, EURUSD, etc.). Timeframe : Set your desired timeframe for each symbol (e.g., 15, 60, 240, 1D). RSI Length : Defines the period used in RSI calculation (default is 14). Stochastic Length : Sets the period for the Stochastic Oscillator. ATR Length : Sets the length used to calculate the Average True Range, a key volatility metric. 🔵 Conclusion By combining powerful oscillators like RSI and Stochastic with full customization over symbols and timeframes, this tool provides a fast, flexible solution for technical analysts. Users can instantly monitor one or several assets across multiple timeframes without opening separate charts. Individual configuration for each symbol, along with the inclusion of key metrics like candlestick type, ATR/TR, and OHLC prices, makes the tool suitable for a wide range of trading styles—from scalping to swing and position trading. In summary, this screener enables traders to gain a clear, high-level view of various markets in seconds and make quicker, smarter, and lower-risk decisions. It saves time, streamlines analysis, and boosts overall efficiency and confidence in trading strategies.
Indicatore Pine Script®
di TFlab
6
Custom Moving Average Ribbon with EMA Table & Text ColorComprehensive Description of the Custom Moving Average Ribbon with EMA Table & Text Color The Custom Moving Average Ribbon with EMA Table & Text Color is a highly flexible and customizable indicator designed for traders who use multiple moving averages to assess trends, strength, and potential market reversals. It plots up to 8 moving averages (either SMA, EMA, WMA, or VWMA) on the price chart and displays a table summarizing the moving averages’ values, periods, and colors. The table also allows for the customization of the text color, making it easier to align with your chart’s theme or preference. Key Features: Multiple Moving Averages: You can display up to 8 moving averages (MA), each of which can be customized in terms of: Type: SMA (Simple Moving Average), EMA (Exponential Moving Average), WMA (Weighted Moving Average), or VWMA (Volume-Weighted Moving Average). Period: Each moving average has a user-defined period, which allows for flexibility depending on your trading style (short-term, medium-term, or long-term). Enable/Disable: Each moving average can be independently enabled or disabled based on your preference. Moving Average Ribbon: The indicator visualizes multiple moving averages as a ribbon, giving traders insight into the market's underlying trend. The interaction between these moving averages provides essential signals: Uptrend: Shorter-term MAs above longer-term MAs, all sloping upward. Downtrend: Shorter-term MAs below longer-term MAs, sloping downward. Consolidation: MAs tightly packed, indicating low volatility or a sideways market. Customizable Table: The indicator includes a table that displays: The Name of each moving average (e.g., MA 1, MA 2, etc.). The Period used for each moving average. The Current Value of each moving average. Color Coding for easier visual identification on the chart. Text Color Customization: You can change the text color in the table to match your chart style or to ensure high visibility. Responsive Design: This indicator works on any time frame, whether you're a day trader, swing trader, or long-term investor, and the table adjusts dynamically as new data comes in. How to Use the Indicator a) Trend Identification The Custom Moving Average Ribbon helps in identifying trends and their strength. Here’s how you can interpret the plotted moving averages: Uptrend (Bullish): If the shorter-term moving averages (e.g., 5-period, 10-period) are above the longer-term moving averages (e.g., 50-period, 200-period), and all the MAs are sloping upward, it suggests a strong bullish trend. The greater the separation between the moving averages, the stronger the uptrend. Use the table to quickly verify the current value of each MA and confirm that the price is staying above most or all of the MAs. Downtrend (Bearish): When shorter-term moving averages are below the longer-term moving averages and all MAs are sloping downward, this indicates a bearish trend. Greater separation between MAs indicates a stronger downtrend. Neutral/Consolidating Market: If the MAs are tightly packed and frequently crossing each other, the market is likely consolidating, and a strong trend is not in play. In these situations, it’s better to wait for a clearer signal before taking any positions. b) Reversal Signals Golden Cross: When a short-term moving average (e.g., 50-period) crosses above a long-term moving average (e.g., 200-period), this is considered a bullish signal, suggesting a possible upward trend. Death Cross: When a short-term moving average crosses below a long-term moving average, it’s considered a bearish signal, indicating a potential downward trend. c) Using the Table for Quick Reference The table allows you to monitor: The current price value relative to each moving average. If the price is above most MAs, the market is likely in an uptrend, and if below, in a downtrend. Changes in MA values: If you see values of shorter-term MAs moving closer to or crossing longer-term MAs, this could indicate a weakening trend or a potential reversal. How to Combine this Indicator with Other Indicators for a Solid Strategy The Custom Moving Average Ribbon is powerful on its own but can be enhanced when combined with other technical indicators to form a comprehensive trading strategy. 1. Combining with RSI (Relative Strength Index) How It Works: RSI is a momentum oscillator that measures the speed and change of price movements, typically over 14 periods. It ranges from 0 to 100, with readings above 70 considered overbought and below 30 considered oversold. Strategy: Overbought in an Uptrend: If the moving average ribbon indicates an uptrend but the RSI shows the market is overbought (RSI > 70), it could signal a pullback or correction is imminent. Oversold in a Downtrend: If the moving average ribbon indicates a downtrend but the RSI shows oversold conditions (RSI < 30), a bounce or reversal may be on the horizon. 2. Combining with MACD (Moving Average Convergence Divergence) How It Works: MACD tracks the difference between two exponential moving averages, typically the 12-period and 26-period EMAs. It generates buy and sell signals based on crossovers and divergences. Strategy: Trend Confirmation: Use the MACD to confirm the direction and momentum of the trend indicated by the moving average ribbon. For example, if the MACD line crosses above the signal line while the shorter-term MAs are above the longer-term MAs, it confirms strong bullish momentum. Divergences: Watch for divergences between price action and MACD. If price is making higher highs but MACD is making lower highs, it could signal a weakening trend, which you can verify using the moving averages. 3. Combining with Bollinger Bands How It Works: Bollinger Bands plot two standard deviations above and below a moving average, typically the 20-period SMA. The bands widen during periods of high volatility and contract during periods of low volatility. Strategy: Breakout or Reversal: If price action moves above the upper Bollinger Band while the shorter-term MAs are crossing above the longer-term MAs, it confirms a strong breakout. Conversely, if price touches or falls below the lower Bollinger Band and the shorter MAs start crossing below the longer-term MAs, it indicates a potential breakdown. Mean Reversion: In sideways markets, when the moving averages are tightly packed, Bollinger Bands can help spot mean reversion opportunities (buy near the lower band, sell near the upper band). 4. Combining with Volume Indicators How It Works: Volume is a crucial confirmation indicator for any trend or breakout. Combining volume with the moving average ribbon can enhance your strategy. Strategy: Trend Confirmation: If the price breaks above the moving averages and is accompanied by high volume, it confirms a strong breakout. Similarly, if price breaks below the moving averages on high volume, it signals a strong downtrend. Divergence: If price continues to trend in one direction but volume decreases, it could indicate a weakening trend, helping you prepare for a reversal. Example Strategies Using the Indicator Trend-Following Strategy: Use the moving average ribbon to identify the main trend. Combine with MACD or RSI for confirmation of momentum. Enter trades when the shorter-term MAs confirm the trend and the confirmation indicator (MACD or RSI) aligns with the trend. Exit trades when the moving averages start converging or when your confirmation indicator shows signs of reversal. Reversal Strategy: Wait for significant crossovers in the moving averages (Golden Cross or Death Cross). Confirm the reversal with divergence in MACD or RSI. Use Bollinger Bands to fine-tune your entry and exit points based on overbought/oversold conditions. Conclusion The Custom Moving Average Ribbon with EMA Table & Text Color indicator provides a robust framework for traders looking to use multiple moving averages to gauge trend direction, strength, and potential reversals. By combining it with other technical indicators like RSI, MACD, Bollinger Bands, and volume, you can develop a solid trading strategy that enhances accuracy, reduces false signals, and maximizes profit potential in various market conditions. This indicator offers high flexibility with customization options, making it suitable for traders of all levels and strategies. Whether you're trend-following, scalping, or swing trading, this tool provides invaluable insights into market movements.
Indicatore Pine Script®
di paulaustin3977
ADR/ATR Session No Probability Table by LKHere you go—clear, English docs you can drop into your script’s description or share with teammates. ADR/ATR Session by LK — Overview This indicator summarizes Average Daily Range (ADR) and Average True Range (ATR) for two horizons: • Session H4 (e.g., 06:00–13:00 on a 4‑hour chart) • Daily (D) It shows: • Current ADR/ATR values (using your chosen smoothing method) • How much of ADR/ATR today/this bar has already been consumed (% of ADR/ATR) • ADR/ATR as a percent of price • Optional probability blocks: likelihood that %ADR will exceed user‑defined thresholds over a lookback window • Optional on‑chart lines for the current H4 and Daily candles: Open, ADR High, ADR Low ⸻ What the metrics mean • ADR (H4 / D): Moving average of the bar range (high - low). • ATR (H4 / D): Moving average of True Range (max(hi-lo, |hi-close |, |lo-close |)). • % of ADR (curr H4): (H4 range of the current H4 bar) / ADR(H4) × 100. Updates live even if the current time is outside the session. • % of ADR (Daily): (today’s intra‑day range) / ADR(D) × 100. • % of ATR (curr H4 / Daily): TR / ATR × 100 for that horizon. • ADR % of Price / ATR % of Price: ADR or ATR divided by current price × 100 (a quick “volatility vs. price” gauge). Session logic (H4): ADR/ATR(H4) only update on bars that fall inside the configured session window; outside the window the values hold steady (no recalculation “bleed”). Daily range tracking: The indicator tracks today’s high/low in real‑time and resets at the day change. ⸻ Inputs (quick reference) Core • Length (ADR/ATR): smoothing length for ADR/ATR (default 21). • Wait for Higher TF Bar Close: if true, updates ADR/ATR only after the higher‑TF bar closes when using request.security. Timeframes • Session Timeframe (H4): default 240. • Daily Timeframe: default D. Session time • Session Timezone: “Chart” (default) or a fixed timezone. • Session Start Hour, End Hour (minutes are fixed to 0 in this version). Smoothing methods • H4 ADR Method / H4 ATR Method: SMA/EMA/RMA/WMA. • Daily ADR Method / Daily ATR Method: SMA/EMA/RMA/WMA. Table appearance • Table BG, Table Text, Table Font Size. Lines (optional) • Show current H4 segments, Show current Daily segments • Line colors for Open / ADR High / ADR Low • Line width Probability • H4 Probability Lookback (bars): number of H4 bars to examine (e.g., 300). • Daily Probability Lookback (days): number of D bars (e.g., 180). • ADR thresholds (%): CSV list of thresholds (e.g., 25,50,55,60,65,70,75,80,85,90,95,100,125,150). The table will show the % of lookback bars where %ADR ≥ threshold. Tip: If you want probabilities only for session H4 bars (not every H4 bar), ask and I can add a toggle to filter by inSess. ⸻ How to read the table H4 block • ADR (method) / ATR (method): the session‑aware averages. • % of ADR (curr H4): live progress of this H4 bar toward the session ADR. • ADR % of Price: ADR(H4) relative to price. • % of ATR (curr H4) and ATR % of Price: same idea for ATR. H4 Probability (lookback N bars) • Rows like “≥ 80% ADR” show the fraction (in %) of the last N H4 bars that reached at least 80% of ADR(H4). Daily block • Mirrors the H4 block, but for Daily. Daily Probability (lookback M days) • Rows like “≥ 100% ADR” show the fraction of the last M daily bars whose daily range reached at least 100% of ADR(D). ⸻ Practical usage • Use % of ADR (curr H4 / Daily) to judge exhaustion or room left in the day/session. E.g., if Daily %ADR is already 95%, be cautious with momentum continuation trades. • The probability tables give a quick historical context: If “≥ 125% ADR” is ~18%, the market rarely stretches that far; your trade sizing/targets can reflect that. • ADR/ATR % of Price helps normalize volatility between instruments. ⸻ Troubleshooting • If probability rows are blank: ensure lookback windows are large enough (and that the chart has enough history). • If ADR/ATR show … (NA): usually you don’t have enough bars for the chosen length/TF yet. • If line segments are missing: verify you’re on a chart with visible current H4/D bars and the toggles are enabled. ⸻ Notes & customization ideas • Add a toggle to count only session bars in H4 probability. • Add separate thresholds for H4 vs Daily. • Let users pick minutes for session start/end if needed. • Add alerts when %ADR crosses specified thresholds. If you want me to bundle any of the “ideas” above into the code, say the word and I’ll ship a clean patch.
Indicatore Pine Script®
di kimngan894923