Mulai

Matrix

Market Correlation Matrix [NikaQuant]Market Correlation Matrix A real-time correlation dashboard that displays Pearson correlation coefficients between the current chart symbol and up to 6 user-defined comparison symbols. ═══ FEATURES ═══ • Track correlations for up to 6 symbols simultaneously (default: BTCUSDT, GOLD, SPX, DXY, US10Y, QQQ) • Heatmap-colored table with intuitive color coding from strong positive (green) to strong negative (red) • Correlation change tracking — see how correlations are shifting over a configurable lookback period • Visual strength bars showing absolute correlation magnitude at a glance • Signal classification labels: STRONG+/-, MOD+/-, WEAK+/-, NEUTRAL • Built-in alerts for strong positive/negative crosses (±0.7) and zero-line crosses • Fully customizable: table position, text size, all colors, border styling ═══ HOW IT WORKS ═══ The indicator calculates Pearson correlation over a user-defined period (default: 50 bars) between the chart’s close price and each comparison symbol’s close price. It then renders a compact table showing: 1. Symbol — Ticker of the comparison asset 2. Corr — Current correlation value (-1 to +1) 3. Change — How much the correlation shifted vs N bars ago (with directional arrows) 4. Strength — Block-style visual bar representing absolute correlation 5. Signal — Classification from NEUTRAL to STRONG+/- ═══ SETTINGS ═══ Symbols: Configure up to 6 comparison symbols (leave blank to skip) Correlation Period: Lookback length for Pearson calculation (default: 50) Change Lookback: Compare current vs past correlation (default: 10 bars) Display: Table position, show/hide title Style: Full color customization for heatmap, headers, borders, and change indicators ═══ ALERTS ═══ • Strong positive correlation cross (above +0.7) per symbol • Strong negative correlation cross (below -0.7) per symbol • Any symbol crossing the zero line ═══ USE CASES ═══ • Monitor intermarket relationships in real time • Identify regime changes when correlations break down or strengthen • Confirm or filter trade setups using cross-asset correlation context • Track USD, bonds, equities, and crypto correlations from a single chart
Indikator Pine Script®
oleh NikaQuant
Market State Matrix [LuxAlgo]The Market State Matrix indicator is a high-density radial dashboard designed to visualize the entire market condition as a layered, 360-degree "radar." Unlike linear indicators, the Matrix organizes data into 5 concentric rings and 12 multi-scale slices , providing an instant snapshot of market confluence, conflict, and cyclical phases. 🔶 USAGE The indicator operates in a dedicated pane, providing a centralized view of market health across five dimensions and twelve lookback periods. 🔹 The 5 Radial Dimensions (Inside to Outside) Ring 1: Trend Regime (Teal/Red) - Visualizes the primary EMA-based direction. Ring 2: Momentum Intensity (Cyan/Purple) - A heatmap based on RSI distance from the 50-level. Ring 3: Volatility Glow (Gold) - Brightens as ATR expands relative to its historical average. Ring 4: Volume Pressure (White) - Highlights areas of high relative participation and interest. Ring 5: Price Structure (Lime/Orange) - Tracks Higher Highs/Lows vs. Lower Highs/Lows across various scales. 🔹 Interpretation Full Alignment: Look for solid "columns" of color from the core to the outer ring. This represents maximum conviction across all market dimensions. Internal Conflict: Mixed colors within a slice indicate internal disagreement—for example, a bullish trend (Ring 1) with bearish momentum (Ring 2) suggests potential exhaustion or a mean-reversion setup. Volatility Breaks: Watch the Gold ring (Ring 3) for expansion. High volatility paired with high volume (Ring 4) often precedes a significant trend shift. Regime Core: The center circle acts as your primary anchor, glowing solid Bullish or Bearish based on the fastest timeframe's regime. 🔶 DETAILS The Matrix utilizes a Multi-Scale Engine divided into 12 radial slices, each representing a progressively longer lookback period (ranging from 8 to 220 bars). This allows users to see how different time-clusters are reacting simultaneously. "Sensitive Slices" respond to micro-shifts and short-term volatility, while "Stable Slices" reflect the long-term macro regime. The tool also features a **Dominant Phase Highlighter**: A glowing radial arc and focus overlay highlight the current active slice of price action. This identifies where the market is positioned in its current cycle (Expansion, Exhaustion, Contraction, or Accumulation). 🔶 SETTINGS 🔹 Visual Settings Horizontal Offset: Adjusts the X-axis position of the wheel on the chart. Core Radius: Sets the size of the inner-most circle. Ring Width: Determines the thickness of each of the 5 concentric rings. Ring Gap: Sets the thin separation distance between segments for visual clarity. Show Dashboard Legend: Toggles the visibility of the "Matrix Layers" table in the top-right corner.
Indikator Pine Script®
oleh LuxAlgo
7
Harmonic Periodicity Matrix [Pineify]Harmonic Periodicity Matrix — Multi-Cycle Stochastic Oscillator with Momentum Ribbon & Adaptive Signals The Harmonic Periodicity Matrix is an advanced cycle-detection oscillator that identifies market rhythm, momentum shifts, and high-probability reversal zones by harmonically combining three stochastic waves at different periodicities. Rather than relying on a single fixed lookback window — which inevitably misses cycles of differing durations — this indicator synthesizes a short-cycle , a primary-cycle , and a long-cycle stochastic into a single composite wave. The result is a smoother, more robust picture of where the market currently sits within its natural oscillation pattern. Key Features Three harmonically spaced stochastic cycles fused into one composite wave Weighted Moving Average (WMA) smoothing to reduce noise without excessive lag EMA-based signal line that generates precise momentum-crossover triggers Dynamic gradient coloring that visually encodes cycle strength and direction Momentum Ribbon fill between the cycle wave and signal line for at-a-glance bias confirmation Overbought / Oversold reference zones with subtle background shading Filtered Buy and Sell signals that fire only when reversals originate from extreme cycle territory How It Works At its core, the indicator computes three stochastic oscillators (%K) across three harmonically related lengths derived from a user-defined Primary Cycle Length : Short cycle — half the primary length ( cycleLen / 2 ), capturing fast intraday or shorter-term oscillations. Primary cycle — the user-defined length ( cycleLen ), representing the dominant market rhythm. Long cycle — 1.5× the primary length ( cycleLen × 1.5 ), anchoring the broader trend context. These three stochastic readings are averaged into a single composite cycle and then smoothed with a Weighted Moving Average (WMA) over the user-defined Smoothing Factor . Subtracting 50 centers the result around zero (range: −50 to +50), making overbought and oversold conditions immediately intuitive. A Signal Line — an EMA calculated over twice the smoothing period — acts as a lagging reference. Crossovers between the composite wave and the signal line mark momentum inflection points. Trading Ideas and Insights Zero-line crosses — When the composite wave crosses above 0, market momentum is transitioning bullish; below 0 signals bearish transition. Overbought / Oversold extremes — Readings above +25 indicate potential exhaustion; readings below −25 indicate potential recovery opportunity. Signal crossovers from extremes — The highest-conviction signals occur when the wave crosses the signal line while already in oversold (< −15, Buy) or overbought (> +15, Sell) territory. Momentum Ribbon color — A green ribbon confirms bullish momentum continuation; a red ribbon warns of bearish pressure even if price is still rising. How Multiple Indicators Work Together The power of the Harmonic Periodicity Matrix comes from the deliberate combination of three stochastic oscillators and two moving average types: The three stochastics represent different frequency bands of market activity — fast, medium, and slow. Averaging them suppresses random noise that would appear in any single stochastic while preserving genuine cyclical structure that repeats across all three timeframes simultaneously. The WMA smoothing is applied to the averaged cycle rather than to each individual stochastic. WMA front-weights recent data, keeping the smoothed line more responsive than a Simple Moving Average while avoiding the excessive lag of longer EMAs — the ideal balance for a cycle oscillator. The EMA signal line is computed over a longer period (2× the smoothing factor), intentionally lagging behind the main wave. This lag creates meaningful crossover events: when the faster composite wave crosses the slower signal line, it indicates a genuine shift in momentum rather than a transient fluctuation. The gradient coloring system encodes amplitude into color, providing an instant visual read of cycle intensity that raw numbers cannot convey. The background zone shading reinforces awareness of extreme readings without cluttering the visual space. Together, these components form a self-contained cycle analysis system: the three stochastics define the oscillation, the WMA refines it, the EMA signal line contextualizes momentum, and the visual layer communicates everything instantly. Unique Aspects Harmonic period spacing — Using 0.5×, 1×, and 1.5× ratios is inspired by harmonic analysis principles, where related frequencies reinforce true cyclical signals and cancel spurious noise. Amplitude-coded gradient — Color intensity scales with distance from zero (0→40 bullish, −40→0 bearish), making it easy to distinguish a mild rebound from a powerful trend. Filtered signals — Buy signals require the crossover to occur below −15; Sell signals require it above +15. This prevents signal generation in neutral mid-range territory where momentum reversals are statistically less reliable. Zero-centered display — Centering around 0 (rather than displaying 0–100) aligns naturally with how traders think about bullish vs. bearish bias. How to Use Add the indicator to any chart and timeframe. It plots in a separate panel below the price chart. Watch for green circles (Buy signals) — these appear when the cycle wave crosses up through the signal line from oversold territory (below −15). Watch for red circles (Sell signals) — these appear when the cycle wave crosses down through the signal line from overbought territory (above +15). Use the Momentum Ribbon fill color to confirm trend direction before entering trades. Pay attention to the overbought (+25) and oversold (−25) zones — readings beyond these thresholds suggest cycle exhaustion and potential reversal. Combine with price action or volume analysis for additional confirmation before executing trades. Customization Primary Cycle Length (default: 20) — Increase for longer-term swing cycle detection; decrease for faster, shorter-term cycle tracking. Smoothing Factor (default: 6) — Higher values produce a smoother wave with more lag; lower values are more reactive but noisier. Bullish Wave color — Default green (#089981); customizable. Bearish Wave color — Default red (#F23645); customizable. Equilibrium color — Default gray (#787b86); customizable. Conclusion The Harmonic Periodicity Matrix offers a methodologically grounded approach to market cycle analysis by combining multi-frequency stochastic decomposition, adaptive smoothing, and momentum-crossover detection into a single, visually intuitive oscillator. It is designed for traders who want more than a standard stochastic — those who seek to understand the rhythm of the market across multiple cycle lengths simultaneously. Whether you are swing trading, trend following, or timing entries within a larger move, this indicator provides a structured, repeatable framework for identifying when momentum is genuinely shifting versus when the market is simply oscillating in neutral territory.
Indikator Pine Script®
oleh Pineify
Arbitrage Matrix [LuxAlgo]The Arbitrage Matrix is a follow-up to our Arbitrage Detector that compares the spreads in price and volume between all the major crypto exchanges and forex brokers for any given asset. It provides traders with a comprehensive view of the entire marketplace, revealing hidden relationships among different exchanges for the same asset and offering easy, visual comparisons. 🔶 USAGE Arbitrage is the practice of taking advantage of price differences for the same asset across different markets. Arbitrage traders look for these discrepancies to profit from buying where it’s cheaper and selling where it’s more expensive to capture the spread. For begginers this tool is a clear snapshot of how different markets value the same asset, making global price dynamics easy to grasp. For advanced traders it is a powerful scanner for arbitrage setups, helping you identify where the biggest opportunities lie in real time. Arbitrage opportunities are often short‑lived, but they can be highly profitable. By showing you where spreads exist, this tool helps traders: Understand market inefficiencies Avoid trading at unfavorable prices Identify potential profit opportunities across exchanges By default, the tool searches all the enabled sources for the asset in the chart. It uses crypto exchanges as sources for crypto assets and forex brokers for all other assets. The data is displayed on a dashboard, which is the tool's only visual element. Traders can enable or disable any exchange or broker from the settings panel. All are enabled by default. 🔹 Displayable Data Traders can choose from four types of data to display: last price, last volume, average price, and average volume. Note that price and volume data may not be available for all assets at all sources, and sources without data will not be displayed. As the image shows, each chart displays a different type of data for the same asset. In this case, the asset is ETHUSDT. 🔹 Reading the Matrix Traders must read the data in a row-by-column format, as shown in the following example. Assume that we are charting BTCUSDT Daily. In the row, we have Exchange A; in the column, we have Exchange B. The data is the average price, and the value is 100. The default length for the average is 20. It reads like this: The average BTCUSDT price over the last 20 days is $100 higher on Exchange A than on Exchange B. If the value were -100, it would mean that the average price is $100 lower in Exchange A than in Exchange B. 🔹 Matrix Style Traders can change the colors and disable the background gradient, which is enabled by default. They can also fine-tune the location and dashboard size from the settings panel. 🔶 SETTINGS Sources: Choose between crypto exchanges, forex brokers, or automatic selection based on the asset in the chart. Average Length: Select the length for the price and volume averages. Crypto Exchanges: Enable or disable any available exchange. Forex Brokers: Enable or disable any available broker. 🔹 Dashboard Data: Select the data to display. Position: Select the dashboard location. Size: Select the dashboard size. 🔹 Style Bullish: Select bullish color. Bearish: Select bearish color. Background Gradient: Enable background gradient color.
Indikator Pine Script®
oleh LuxAlgo
4
Wolfe Wave PatternHello All! For a while now, some of my followers have been asking me to develop Wolfe Wave Pattern . Here it's at your service as open-source and public indicator. How it works? - On each bar/tick it checks zigzag waves by using base period and updates the array that is used to keep zigzag levels and locations. Base period in the settings is the minimum zigzag period - Then it searches if there is new bullish/bearish Wolfe Wave pattern according to last wave direction - Before searching the pattern it calculates all possible 1234 waves. So any wave in 12345 uses base period or higher. it means that it search all possible candidates. This algorithm is much better than using a few zigzag periods. - After getting all possible candidates, it checks if any of the found candidates is suitable for Wolfe Wave pattern and keeps them in a matrix - if there are suitable candidate(s) it shows the latest one and triggers the alert - it also follows the targets and if the price hits any of the target it extends the line and trigger the alert - it doesn't check if any of the patterns hits stop-loss. Options: Base Period: minimum period to create the zigzag Error Rate: there are usually so few perfect patterns, so we better consider deviation. if error rate is low than it finds less pattern with more accuracy, if error rate is high than it finds more pattern with less accuracy - The other options are used for coloring the patterns and lines Some examples: P.S. I didn't have enough time to test the indicator, so please drop a comment if you see any issue while using it Enjoy!
Indikator Pine Script®
oleh LonesomeTheBlue
8
Count█  OVERVIEW A library of functions for counting the number of times (frequency) that elements occur in an array or matrix. █ USAGE Import the Count library. import joebaus/count/1 as c Create an array or matrix that is a `float`, `int`, `string`, or `bool` type to count elements from, then call the count function on the array or matrix. id = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25) countMap = id.count() // Alternatively: countMap = c.count(id) The "count map" will return a map with keys for each unique element in the array or matrix, and with respective values representing the number of times the unique element was counted. The keys will be the same type as the array or matrix counted. The values will always be an `int` type. array mapKeys = countMap.keys() // Returns unique keys array mapValues = countMap.values() // Returns counts If an array is in ascending or descending order, then the keys of the map will also generate in the same order. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) // Ascending order map countMap = intArray.count() // Creates a "count map" of all unique elements array mapKeys = countMap.keys() // Returns // Ascending order array mapValues = countMap.values() // Returns count Include a value to get the count of only that value in an array or matrix. floatMatrix = matrix.new(3, 3, 0.0) floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0) floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5) floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5) int countFloatMatrix = floatMatrix.count(1.0) // Counts all 1.0 elements, returns 5 // Alternatively: int countFloatMatrix = c.count(floatMatrix, 1.0) The string method of count() can use strings or regular expressions like "bull*" to count all matching occurrences in a string array. stringArray = array.from('bullish', 'bull', 'bullish', 'bear', 'bull', 'bearish', 'bearish') int countString = stringArray.count('bullish') // Returns 2 int countStringRegex = stringArray.count('bull*') // Returns 4 To count multiple values, use an array of values instead of a single value. Returning a count map only of elements in the array. countArray = array.from(1.0, 2.5) map countMap = floatMatrix.count(countArray) array mapKeys = countMap.keys() // Returns keys array mapValues = countMap.values() // Returns counts Multiple regex patterns or strings can be counted as well. stringMatrix = matrix.new(3, 3, '') stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a') stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd') stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b') // Count the number of times the regex patterns `'^(a|c)$'` and `'^(b|d)$'` occur array regexes = array.from('^(a|c)$', '^(b|d)$') map countMap = stringMatrix.count(regexes) array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns An optional comparison operator can be specified to count the number of times an equality was satisfied for `float`, `int`, and `bool` methods of `count()`. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) // Count the number of times an element is greater than 4 countInt = intArray.count(4, '>') // Returns 2 When passing an array of values to count and a comparison operator, the operator will apply to each value. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) values = array.from(3, 4) // Count the number of times and element is greater than 3 and 4 map countMap = intArray.count(values, '>') array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns Multiple comparison operators can be applied when counting multiple values. intMatrix = matrix.new(3, 3, 0) intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5) intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2) intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3) values = array.from(3, 4) comparisons = array.from('<', '>') // Count the number of times an element is less than 3 and greater than 4 map countMap = intMatrix.count(values, comparisons) array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns
Perpustakaan Pine Script®
oleh joebaus
4
FiniteStateMachine🟩 OVERVIEW A flexible framework for creating, testing and implementing a Finite State Machine (FSM) in your script. FSMs use rules to control how states change in response to events. This is the first Finite State Machine library on TradingView and it's quite a different way to think about your script's logic. Advantages of using this vs hardcoding all your logic include: • Explicit logic : You can see all rules easily side-by-side. • Validation : Tables show your rules and validation results right on the chart. • Dual approach : Simple matrix for straightforward transitions; map implementation for concurrent scenarios. You can combine them for complex needs. • Type safety : Shows how to use enums for robustness while maintaining string compatibility. • Real-world examples : Includes both conceptual (traffic lights) and practical (trading strategy) demonstrations. • Priority control : Explicit control over which rules take precedence when multiple conditions are met. • Wildcard system : Flexible pattern matching for states and events. The library seems complex, but it's not really. Your conditions, events, and their potential interactions are complex. The FSM makes them all explicit, which is some work. However, like all "good" pain in life, this is front-loaded, and *saves* pain later, in the form of unintended interactions and bugs that are very hard to find and fix. 🟩 SIMPLE FSM (MATRIX-BASED) The simple FSM uses a matrix to define transition rules with the structure: state > event > state. We look up the current state, check if the event in that row matches, and if it does, output the resulting state. Each row in the matrix defines one rule, and the first matching row, counting from the top down, is applied. A limitation of this method is that you can supply only ONE event. You can design layered rules using widlcards. Use an empty string "" or the special string "ANY" for any state or event wildcard. The matrix FSM is foruse where you have clear, sequential state transitions triggered by single events. Think traffic lights, or any logic where only one thing can happen at a time. The demo for this FSM is of traffic lights. 🟩 CONCURRENT FSM (MAP-BASED) The map FSM uses a more complex structure where each state is a key in the map, and its value is an array of event rules. Each rule maps a named condition to an output (event or next state). This FSM can handle multiple conditions simultaneously. Rules added first have higher priority. Adding more rules to existing states combines the entries in the map (if you use the supplied helper function) rather than overwriting them. This FSM is for more complex scenarios where multiple conditions can be true simultaneously, and you need to control which takes precedence. Like trading strategies, or any system with concurrent conditions. The demo for this FSM is a trading strategy. 🟩 HOW TO USE Pine Script libraries contain reusable code for importing into indicators. You do not need to copy any code out of here. Just import the library and call the function you want. For example, for version 1 of this library, import it like this: import SimpleCryptoLife/FiniteStateMachine/1 See the EXAMPLE USAGE sections within the library for examples of calling the functions. For more information on libraries and incorporating them into your scripts, see the Libraries section of the Pine Script User Manual. 🟩 TECHNICAL IMPLEMENTATION Both FSM implementations support wildcards using blank strings "" or the special string "ANY". Wildcards match in this priority order: • Exact state + exact event match • Exact state + empty event (event wildcard) • Empty state + exact event (state wildcard) • Empty state + empty event (full wildcard) When multiple rules match the same state + event combination, the FIRST rule encountered takes priority. In the matrix FSM, this means row order determines priority. In the map FSM, it's the order you add rules to each state. The library uses user-defined types for the map FSM: • o_eventRule : Maps a condition name to an output • o_eventRuleWrapper : Wraps an array of rules (since maps can't contain arrays directly) Everything uses strings for maximum library compatibility, though the examples show how to use enums for type safety by converting them to strings. Unlike normal maps where adding a duplicate key overwrites the value, this library's `m_addRuleToEventMap()` method *combines* rules, making it intuitive to build rule sets without breaking them. 🟩 VALIDATION & ERROR HANDLING The library includes comprehensive validation functions that catch common FSM design errors: Error detection: • Empty next states • Invalid states not in the states array • Duplicate rules • Conflicting transitions • Unreachable states (no entry/exit rules) Warning detection: • Redundant wildcards • Empty states/events (potential unintended wildcards) • Duplicate conditions within states You can display validation results in tables on the chart, with tooltips providing detailed explanations. The helper functions to display the tables are exported so you can call them from your own script. 🟩 PRACTICAL EXAMPLES The library includes four comprehensive demos: Traffic Light Demo (Simple FSM) : Uses the matrix FSM to cycle through traffic light states (red → red+amber → green → amber → red) with timer events. Includes pseudo-random "break" events and repair logic to demonstrate wildcards and priority handling. Trading Strategy Demo (Concurrent FSM) : Implements a realistic long-only trading strategy using BOTH FSM types: • Map FSM converts multiple technical conditions (EMA crosses, gaps, fractals, RSI) into prioritised events • Matrix FSM handles state transitions (idle → setup → entry → position → exit → re-entry) • Includes position management, stop losses, and re-entry logic Error Demonstrations : Both FSM types include error demos with intentionally malformed rules to showcase the validation system's capabilities. 🟩 BRING ON THE FUNCTIONS f_printFSMMatrix(_mat_rules, _a_states, _tablePosition)   Prints a table of states and rules to the specified position on the chart. Works only with the matrix-based FSM.   Parameters:      _mat_rules (matrix)      _a_states (array)      _tablePosition (simple string)   Returns: The table of states and rules. method m_loadMatrixRulesFromText(_mat_rules, _rulesText)   Loads rules into a rules matrix from a multiline string where each line is of the form "current state | event | next state" (ignores empty lines and trims whitespace). This is the most human-readable way to define rules because it's a visually aligned, table-like format.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _rulesText (string)   Returns: No explicit return. The matrix is modified as a side-effect. method m_addRuleToMatrix(_mat_rules, _currentState, _event, _nextState)   Adds a single rule to the rules matrix. This can also be quite readble if you use short variable names and careful spacing.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _currentState (string)      _event (string)      _nextState (string)   Returns: No explicit return. The matrix is modified as a side-effect. method m_validateRulesMatrix(_mat_rules, _a_states, _showTable, _tablePosition)   Validates a rules matrix and a states array to check that they are well formed. Works only with the matrix-based FSM. Checks: matrix has exactly 3 columns; no empty next states; all states defined in array; no duplicate states; no duplicate rules; all states have entry/exit rules; no conflicting transitions; no redundant wildcards. To avoid slowing down the script unnecessarily, call this method once (perhaps using `barstate.isfirst`), when the rules and states are ready.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _a_states (array)      _showTable (bool)      _tablePosition (simple string)   Returns: `true` if the rules and states are valid; `false` if errors or warnings exist. method m_getStateFromMatrix(_mat_rules, _currentState, _event, _strictInput, _strictTransitions)   Returns the next state based on the current state and event, or `na` if no matching transition is found. Empty (not na) entries are treated as wildcards if `strictInput` is false. Priority: exact match > event wildcard > state wildcard > full wildcard.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _currentState (string)      _event (string)      _strictInput (bool)      _strictTransitions (bool)   Returns: The next state or `na`. method m_addRuleToEventMap(_map_eventRules, _state, _condName, _output)   Adds a single event rule to the event rules map. If the state key already exists, appends the new rule to the existing array (if different). If the state key doesn't exist, creates a new entry.   Namespace types: map   Parameters:      _map_eventRules (map)      _state (string)      _condName (string)      _output (string)   Returns: No explicit return. The map is modified as a side-effect. method m_addEventRulesToMapFromText(_map_eventRules, _configText)   Loads event rules from a multiline text string into a map structure. Format: "state | condName > output | condName > output | ..." . Pairs are ordered by priority. You can have multiple rules on the same line for one state. Supports wildcards: Use an empty string ("") or the special string "ANY" for state or condName to create wildcard rules. Examples: " | condName > output" (state wildcard), "state | > output" (condition wildcard), " | > output" (full wildcard). Splits lines by , extracts state as key, creates/appends to array with new o_eventRule(condName, output). Call once, e.g., on barstate.isfirst for best performance.   Namespace types: map   Parameters:      _map_eventRules (map)      _configText (string)   Returns: No explicit return. The map is modified as a side-effect. f_printFSMMap(_map_eventRules, _a_states, _tablePosition)   Prints a table of map-based event rules to the specified position on the chart.   Parameters:      _map_eventRules (map)      _a_states (array)      _tablePosition (simple string)   Returns: The table of map-based event rules. method m_validateEventRulesMap(_map_eventRules, _a_states, _a_validEvents, _showTable, _tablePosition)   Validates an event rules map to check that it's well formed. Checks: map is not empty; wrappers contain non-empty arrays; no duplicate condition names per state; no empty fields in o_eventRule objects; optionally validates outputs against matrix events. NOTE: Both "" and "ANY" are treated identically as wildcards for both states and conditions. To avoid slowing down the script unnecessarily, call this method once (perhaps using `barstate.isfirst`), when the map is ready.   Namespace types: map   Parameters:      _map_eventRules (map)      _a_states (array)      _a_validEvents (array)      _showTable (bool)      _tablePosition (simple string)   Returns: `true` if the event rules map is valid; `false` if errors or warnings exist. method m_getEventFromConditionsMap(_currentState, _a_activeConditions, _map_eventRules)   Returns a single event or state string based on the current state and active conditions. Uses a map of event rules where rules are pre-sorted by implicit priority via load order. Supports wildcards using empty string ("") or "ANY" for flexible rule matching. Priority: exact match > condition wildcard > state wildcard > full wildcard.   Namespace types: series string, simple string, input string, const string   Parameters:      _currentState (string)      _a_activeConditions (array)      _map_eventRules (map)   Returns: The output string (event or state) for the first matching condition, or na if no match found. o_eventRule   o_eventRule defines a condition-to-output mapping for the concurrent FSM.   Fields:      condName (series string) : The name of the condition to check.      output (series string) : The output (event or state) when the condition is true. o_eventRuleWrapper   o_eventRuleWrapper wraps an array of o_eventRule for use as map values (maps cannot contain collections directly).   Fields:      a_rules (array) : Array of o_eventRule objects for a specific state.
Perpustakaan Pine Script®
oleh SimpleCryptoLife
4
Autotable█  OVERVIEW The library allows to automatically draw a table based on a string or float matrix (or both) controlling all of the parameters of the table (including merging cells) with parameter matrices (like, e.g. matrix of cell colors). All things you would normally do with table.new() and table.cell() are now possible using respective parameters of library's main function, autotable() (as explained further below). Headers can be supplied as arrays. Merging of the cells is controlled with a special matrix of "L" and "U" values which instruct a cell to merged with the cell to the left or upwards (please see examples in the script and in this description). █  USAGE EXAMPLES The simplest and most straightforward: mxF = matrix.new(3,3, 3.14) mxF.autotable(bgcolor = color.rgb(249, 209, 29)) // displays float matrix as a table in the top right corner with defalult settings mxS = matrix.new(3,3,"PI") // displays string matrix as a table in the top right corner with defalult settings mxS.autotable(Ypos = "bottom", Xpos = "right", bgcolor = #b4d400) // displays matrix displaying a string value over a float value in each cell mxS.autotable(mxF, Ypos = "middle", Xpos = "center", bgcolor = color.gray, text_color = #86f62a) Draws this: Tables with headers: if barstate.islast mxF = matrix.new(3,3, 3.14) mxS = matrix.new(3,3,"PI") arColHeaders = array.from("Col1", "Col2", "Col3") arRowHeaders = array.from("Row1", "Row2", "Row3") // float matrix with col headers mxF.autotable( bgcolor = #fdfd6b , arColHeaders = arColHeaders ) // string matrix with row headers mxS.autotable(arRowHeaders = arRowHeaders, Ypos = "bottom", Xpos = "right", bgcolor = #b4d400) // string/float matrix with both row and column headers mxS.autotable(mxF , Ypos = "middle", Xpos = "center" , arRowHeaders = arRowHeaders , arColHeaders = arColHeaders , cornerBgClr = #707070, cornerTitle = "Corner cell", cornerTxtClr = #ffdc13 , bgcolor = color.gray, text_color = #86f62a ) Draws this: █  FUNCTIONS One main function is autotable() which has only one required argument mxValS, a string matrix. Please see below the description of all of the function parameters: The table:    tbl (table) (Optional) If supplied, this table will be deleted. The data:    mxValS (matrix ) (Required) Cell text values    mxValF (matrix) (Optional) Numerical part of cell text values. Is concatenated to the mxValS values via `string_float_separator` string (default " ") Table properties, have same effect as in table.new() :    defaultBgColor (color) (Optional) bgcolor to be used if mxBgColor is not supplied    Ypos (string) (Optional) "top", "bottom" or "center"    Xpos (string) (Optional) "left", "right", or "center"    frame_color (color) (Optional) frame_color like in table.new()    frame_width (int) (Optional) frame_width like in table.new()    border_color (color) (Optional) border_color like in table.new()    border_width (int) (Optional) border_width like in table.new()    force_overlay (simple bool) (Optional) If true draws table on main pane. Cell parameters, have same effect as in table.cell() ):    mxBgColor (matrix) (Optional) like bgcolor argument in table.cell()    mxTextColor (matrix) (Optional) like text_color argument in table.cell()    mxTt (matrix) (Optional) like tooltip argument in table.cell()    mxWidth (matrix) (Optional) like width argument in table.cell()    mxHeight (matrix) (Optional) like height argument in table.cell()    mxHalign (matrix) (Optional) like text_halign argument in table.cell()    mxValign (matrix) (Optional) like text_valign argument in table.cell()    mxTextSize (matrix) (Optional) like text_size argument in table.cell()    mxFontFamily (matrix) (Optional) like text_font_family argument in table.cell() Other table properties:    tableWidth (float) (Optional) Overrides table width if cell widths are non zero. E.g. if there are four columns and cell widths are 20 (either as set via cellW or via mxWidth) then if tableWidth is set to e.g. 50 then cell widths will be 50 * (20 / 80), where 80 is 20*4 = total width of all cells. Works simialar for widths set via mxWidth - determines max sum of widths across all cloumns of mxWidth and adjusts cell widths proportionally to it. If cell widths are 0 (i.e. auto-adjust) tableWidth has no effect.    tableHeight (float) (Optional) Overrides table height if cell heights are non zero. E.g. if there are four rows and cell heights are 20 (either as set via cellH or via mxHeight) then if tableHeigh is set to e.g. 50 then cell heights will be 50 * (20 / 80), where 80 is 20*4 = total height of all cells. Works simialar for heights set via mxHeight - determines max sum of heights across all cloumns of mxHeight and adjusts cell heights proportionally to it. If cell heights are 0 (i.e. auto-adjust) tableHeight has no effect.    defaultTxtColor (color) (Optional) text_color to be used if mxTextColor is not supplied    text_size (string) (Optional) text_size to be used if mxTextSize is not supplied    font_family (string) (Optional) cell text_font_family value to be used if a value in mxFontFamily is no supplied    cellW (float) (Optional) cell width to be used if a value in mxWidth is no supplied    cellH (float) (Optional) cell height to be used if a value in mxHeight is no supplied    halign (string) (Optional) cell text_halign value to be used if a value in mxHalign is no supplied    valign (string) (Optional) cell text_valign value to be used if a value in mxValign is no supplied Headers parameters:    arColTitles (array) (Optional) Array of column titles. If not na a header row is added.    arRowTitles (array) (Optional) Array of row titles. If not na a header column is added.    cornerTitle (string) (Optional) If both row and column titles are supplied allows to set the value of the corner cell.    colTitlesBgColor (color) (Optional) bgcolor for header row    colTitlesTxtColor (color) (Optional) text_color for header row    rowTitlesBgColor (color) (Optional) bgcolor for header column    rowTitlesTxtColor (color) (Optional) text_color for header column    cornerBgClr (color) (Optional) bgcolor for the corner cell    cornerTxtClr (color) (Optional) text_color for the corner cell Cell merge parameters:    mxMerge (matrix) (Optional) A matrix determining how cells will be merged. "L" - cell merges to the left, "U" - upwards.    mergeAllColTitles (bool) (Optional) Allows to print a table title instead of column headers, merging all header row cells and leaving just the value of the first cell. For more flexible options use matrix arguments leaving header/row arguments na.    mergeAllRowTitles (bool) (Optional) Allows to print one text value merging all header row cells and leaving just the value of the first cell. For more flexible options use matrix arguments leaving header/row arguments na. Format:    string_float_separator (string) (Optional) A string used to separate string and float parts of cell values (mxValS and mxValF). Default is " "    format (string) (Optional) format string like in str.format() used to format numerical values    nz (string) (Optional) Determines how na numerical values are displayed. The only other available function is autotable(string,... ) with a string parameter instead of string and float matrices which draws a one cell table. █  SAMPLE USE E.g., CSVParser library demo uses Autotable's for generating complex tables with merged cells. █  CREDITS The library was inspired by @kaigouthro's matrixautotable . A true master. Many thanks to him for his creative, beautiful and very helpful libraries.
Perpustakaan Pine Script®
oleh moebius1977
1
ToStringMx█ OVERVIEW Contains methods for conversion of matrices to string. Supports matrices of int/float/bool/string/color/line/label/box/. - toStringMx(matrix) - converts matrix to a string matrix converting each of its elements to string - toS(matrix) - converts matrix to a string matrix (using toStringMx()) and outputs as string using str.tostring(matrix) Conversion of each item to string is made using toS() function from moebius1977/ToS/1 library. █ GENERAL DESCRIPTION OF FUNCTIONS All toStringMx(matrix) and toS(matrix) methods have same parameters. The only difference will be in format parameter as explained below. Parameters:      this (matrix) Matrix to be converted to a string matrix.      format (string) Format string.      nz (string) Placeholder for na items. format parameter depends on the type:   For matrix format parameter works in the same way as `str.format()` (i.e. you can use same format strings as with `str.format()` with `{0}` as a placeholder for the value) with some shorthand "format" options available: --- number --- - "" => "{0}" - "number" => "{0}" - "0" => "{0, number, 0 }" - "0.0" => "{0, number, 0.0 }" - "0.00" => "{0, number, 0.00 }" - "0.000" => "{0, number, 0.000 }" - "0.0000" => "{0, number, 0.0000 }" - "0.00000" => "{0, number, 0.00000 }" - "0.000000" => "{0, number, 0.000000 }" - "0.0000000" => "{0, number, 0.0000000}" --- date --- - "date" => "{0, date, dd.MM.YY}" - "date : time" => "{0, date, dd.MM.YY} : {0, time, HH.mm.ss}" - "dd.MM" => "{0, date, dd:MM}" - "dd" => "{0, date, dd}" - "... ... " in any place is substituted with "{0, date, dd.MM.YY}" --- time --- - "time" => "{0, time, HH:mm:ss}" - "HH:mm" => "{0, time, HH:mm}" - "mm:ss" => "{0, time, mm:ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "date, time" => "{0, date, dd.MM.YY\}, {0, time, HH.mm.ss}" - "date,time" => "{0, date, dd.MM.YY\},{0, time, HH.mm.ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "... ... " in any place is substituted with "{0, time, HH.mm.ss}" For matrix :      format (string) : (string) (Optional) Use `x1` as placeholder for `x1` and so on. E.g. default format is `"(x1, y1) - (x2, y2)"`. For matrix :      format (string) : (string) (Optional) Use `x1` as placeholder for `x`, `y1 - for `y` and `txt` for label's text. E.g. default format is `(x1, y1): "txt"` if ptint_text is true and `(x1, y1)` if false. For matrix :      format (string) : (string) (Optional) Use `x1` as placeholder for `x`, `y1 - for `y` etc. E.g. default format is "(x1, y1) - (x2, y2)". For matrix :      format (string) : (string) (Optional) Options are "HEX" (e.g. "#FFFFFF33") or "RGB" (e.g. "rgb(122,122,122,23)"). Default is "HEX". █ FULL LIST OF FUNCTIONS AND PARAMETERS method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) Like in str.format()      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) Like in str.format() with some shorthand options: ``` --- number --- - "" => "{0}" - "number" => "{0}" - "0" => "{0, number, 0 }" - "0.0" => "{0, number, 0.0 }" - "0.00" => "{0, number, 0.00 }" - "0.000" => "{0, number, 0.000 }" - "0.0000" => "{0, number, 0.0000 }" - "0.00000" => "{0, number, 0.00000 }" - "0.000000" => "{0, number, 0.000000 }" - "0.0000000" => "{0, number, 0.0000000}" --- date --- - "date" => "{0, date, dd.MM.YY}" - "date : time" => "{0, date, dd.MM.YY} : {0, time, HH.mm.ss}" - "dd.MM" => "{0, date, dd:MM}" - "dd" => "{0, date, dd}" - "... ... " in any place is substituted with "{0, date, dd.MM.YY}" --- time --- - "time" => "{0, time, HH:mm:ss}" - "HH:mm" => "{0, time, HH:mm}" - "mm:ss" => "{0, time, mm:ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "date, time" => "{0, date, dd.MM.YY\}, {0, time, HH.mm.ss}" - "date,time" => "{0, date, dd.MM.YY\},{0, time, HH.mm.ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "... ... " in any place is substituted with "{0, time, HH.mm.ss}"      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) Like in str.format() with some shorthand options: ``` --- number --- - "" => "{0}" - "number" => "{0}" - "0" => "{0, number, 0 }" - "0.0" => "{0, number, 0.0 }" - "0.00" => "{0, number, 0.00 }" - "0.000" => "{0, number, 0.000 }" - "0.0000" => "{0, number, 0.0000 }" - "0.00000" => "{0, number, 0.00000 }" - "0.000000" => "{0, number, 0.000000 }" - "0.0000000" => "{0, number, 0.0000000}" --- date --- - "date" => "{0, date, dd.MM.YY}" - "date : time" => "{0, date, dd.MM.YY} : {0, time, HH.mm.ss}" - "dd.MM" => "{0, date, dd:MM}" - "dd" => "{0, date, dd}" - "... ... " in any place is substituted with "{0, date, dd.MM.YY}" --- time --- - "time" => "{0, time, HH:mm:ss}" - "HH:mm" => "{0, time, HH:mm}" - "mm:ss" => "{0, time, mm:ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "date, time" => "{0, date, dd.MM.YY\}, {0, time, HH.mm.ss}" - "date,time" => "{0, date, dd.MM.YY\},{0, time, HH.mm.ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "... ... " in any place is substituted with "{0, time, HH.mm.ss}"      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) Like in str.format()      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) "HEX" (default) or "RGB"      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toStringMx(mx, format, nz)   Returns a string matrix made of original matrix items converted to string with toS().   Namespace types: matrix   Parameters:      mx (matrix)      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead. method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) Format string as in str.format()      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) Like in str.format() with some shorthand options: ``` --- number --- - "" => "{0}" - "number" => "{0}" - "0" => "{0, number, 0 }" - "0.0" => "{0, number, 0.0 }" - "0.00" => "{0, number, 0.00 }" - "0.000" => "{0, number, 0.000 }" - "0.0000" => "{0, number, 0.0000 }" - "0.00000" => "{0, number, 0.00000 }" - "0.000000" => "{0, number, 0.000000 }" - "0.0000000" => "{0, number, 0.0000000}" --- date --- - "date" => "{0, date, dd.MM.YY}" - "date : time" => "{0, date, dd.MM.YY} : {0, time, HH.mm.ss}" - "dd.MM" => "{0, date, dd:MM}" - "dd" => "{0, date, dd}" - "... ... " in any place is substituted with "{0, date, dd.MM.YY}" --- time --- - "time" => "{0, time, HH:mm:ss}" - "HH:mm" => "{0, time, HH:mm}" - "mm:ss" => "{0, time, mm:ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "date, time" => "{0, date, dd.MM.YY\}, {0, time, HH.mm.ss}" - "date,time" => "{0, date, dd.MM.YY\},{0, time, HH.mm.ss}" - "date time" => "{0, date, dd.MM.YY\} {0, time, HH.mm.ss}" - "... ... " in any place is substituted with "{0, time, HH.mm.ss}"      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) Format string as in str.format()      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) "HEX" (default) or "RGB"      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz)) method toS(this, format, nz)   Converts each element of the matrix to string outputs using str.tostring(matrix)   Namespace types: matrix   Parameters:      this (matrix) : (matrix) Matrix to be converted to string      format (string) : (string) (Optional) Format string. By default "{0}: {1}" if showIDs = true or "{1}" otherwise. (use "{0}" as a placeholder for id and "{1}" for item value)      nz (string) : (string) If val is na and nz is not na the value of nz param is returned instead.export method toS(matrix this, string format = "", string nz = na) => str.tostring(this.toStringMx(format, nz))
Perpustakaan Pine Script®
oleh moebius1977
ICT IPDA Liquidity Matrix By AlgoCadosThe ICT IPDA Liquidity Matrix by AlgoCados is a sophisticated trading tool that integrates the principles of the Interbank Price Delivery Algorithm (IPDA), as taught by The Inner Circle Trader (ICT). This indicator is meticulously designed to support traders in identifying key institutional levels and liquidity zones, enhancing their trading strategies with data-driven insights. Suitable for both day traders and swing traders, the tool is optimized for high-frequency and positional trading, providing a robust framework for analyzing market dynamics across multiple time horizons. # Key Features Multi-Time Frame Analysis High Time Frame (HTF) Levels : The indicator tracks critical trading levels over multiple days, specifically at 20, 40, and 60-day intervals. This functionality is essential for identifying long-term trends and significant support and resistance levels that aid in strategic decision-making for swing traders and positional traders. Low Time Frame (LTF) Levels : It monitors price movements within 20, 40, and 60-hour intervals on lower time frames. This granularity provides a detailed view of intraday price actions, which is crucial for scalping and short-term trading strategies favored by day traders. Daily Open Integration : The indicator includes the daily opening price, providing a crucial reference point that reflects the market's initial sentiment. This feature helps traders assess the market's direction and volatility, enabling them to make informed decisions based on the day's early movements, which is particularly useful for day trading strategies. IPDA Reference Points : By leveraging IPDA's 20, 40, and 60-period lookbacks, the tool identifies Key Highs and Lows, which are used by IPDA as Draw On Liquidity. IPDA is an electronic and algorithmic system engineered for achieving price delivery efficiency, as taught by ICT. These reference points serve as benchmarks for understanding institutional trading behavior, allowing traders to align their strategies with the dominant market forces and recognize institutional key levels. Dynamic Updates and Overlap Management : The indicator is updated daily at the beginning of a new daily candle with the latest market data, ensuring that traders operate with the most current information. It also features intelligent overlap management that prioritizes the most relevant levels based on the timeframe hierarchy, reducing visual clutter and enhancing chart readability. Comprehensive Customization Options : Traders can tailor the indicator to their specific needs through an extensive input menu. This includes toggles for visibility, line styles, color selections, and label display preferences. These customization options ensure that the tool can adapt to various trading styles and preferences, enhancing user experience and analytical capabilities. User-Friendly Interface : The tool is designed with a user-friendly interface that includes clear, concise labels for all significant levels. It supports various font families and sizes, making it easier to interpret and act upon the displayed data, ensuring that traders can focus on making informed trading decisions without being overwhelmed by unnecessary information. # Usage Note The indicator is segmented into two key functionalities: LTF Displays : The Low Time Frame (LTF) settings are exclusive to timeframes up to 1 hour, providing detailed analysis for intraday traders. This is crucial for traders who need precise and timely data to make quick decisions within the trading day. HTF Displays : The High Time Frame (HTF) settings apply to the daily timeframe and any shorter intervals, allowing for comprehensive analysis over extended periods. This is beneficial for swing traders looking to identify broader trends and market directions. # Inputs and Configurations BINANCE:BTCUSDT Offset: Adjustable setting to shift displayed data horizontally for better visibility, allowing traders to view past levels and make informed decisions based on historical data. Label Styles: Choose between compact or verbose label formats for different levels, offering flexibility in how much detail is displayed on the chart. Daily Open Line: Customizable line style and color for the daily opening price, providing a clear visual reference for the start of the trading day. HTF Levels: Configurable high and low lines for HTF with options for style and color customization, allowing traders to highlight significant levels in a way that suits their trading style. LTF Levels: Similar customization options for LTF levels, ensuring flexibility in how data is presented, making it easier for traders to focus on the most relevant intraday levels. Text Utils: Settings for font family, size, and text color, allowing for personalized display preferences and ensuring that the chart is both informative and aesthetically pleasing. # Advanced Features Overlap Management : The script intelligently handles overlapping levels, particularly where multiple timeframes intersect, by prioritizing the more significant levels and removing redundant ones. This ensures that the charts remain clear and focused on the most critical data points, allowing traders to concentrate on the most relevant market information. Real-Time Updates : The indicator updates its calculations at the start of each new daily bar, incorporating the latest market data to provide timely and accurate trading signals. This real-time updating is crucial for traders who rely on up-to-date information to execute their strategies effectively and make informed trading decisions. # Example Use Cases Scalpers/Day traders: Can utilize the LTF features to make rapid decisions based on hourly market movements, identifying short-term trading opportunities with precision. Swing Traders: Will benefit from the HTF analysis to identify broader trends and key levels that influence longer-term market movements, enabling them to capture significant market swings. By providing a clear, detailed view of key market dynamics, the ICT IPDA Liquidity Matrix by AlgoCados empowers traders to make more informed and effective trading decisions, aligning with institutional trading methodologies and enhancing their market understanding. # Usage Disclaimer This tool is designed to assist in trading decisions, but it should be used in conjunction with other analysis methods and risk management strategies. Trading involves significant risk, and it is essential to understand the market conditions thoroughly before making trading decisions.
Indikator Pine Script®
oleh AlgoCados
19
TimeSeriesRecurrencePlotLibrary "TimeSeriesRecurrencePlot" In descriptive statistics and chaos theory, a recurrence plot (RP) is a plot showing, for each moment i i in time, the times at which the state of a dynamical system returns to the previous state at `i`, i.e., when the phase space trajectory visits roughly the same area in the phase space as at time `j`. ``` A recurrence plot (RP) is a graphical representation used in the analysis of time series data and dynamical systems. It visualizes recurring states or events over time by transforming the original time series into a binary matrix, where each element represents whether two consecutive points are above or below a specified threshold. The resulting Recurrence Plot Matrix reveals patterns, structures, and correlations within the data while providing insights into underlying mechanisms of complex systems. ``` ~starling7b ___ Reference: en.wikipedia.org github.com github.com github.com github.com juliadynamics.github.io distance_matrix(series1, series2, max_freq, norm)   Generate distance matrix between two series.   Parameters:      series1 (float) : Source series 1.      series2 (float) : Source series 2.      max_freq (int) : Maximum frequency to inpect or the size of the generated matrix.      norm (string) : Norm of the distance metric, default=`euclidean`, options=`euclidean`, `manhattan`, `max`.   Returns: Matrix with distance values. method normalize_distance(M)   Normalizes a matrix within its Min-Max range.   Namespace types: matrix   Parameters:      M (matrix) : Source matrix.   Returns: Normalized matrix. method threshold(M, threshold)   Updates the matrix with the condition `M(i,j) > threshold ? 1 : 0`.   Namespace types: matrix   Parameters:      M (matrix) : Source matrix.      threshold (float)   Returns: Cross matrix. rolling_window(a, b, sample_size)   An experimental alternative method to plot a recurrence_plot.   Parameters:      a (array) : Array with data.      b (array) : Array with data.      sample_size (int)   Returns: Recurrence_plot matrix.
Perpustakaan Pine Script®
oleh RicardoSantos
5
TimeSeriesGrammianAngularFieldLibrary "TimeSeriesGrammianAngularField" provides Grammian angular field and associated utility functions. ___ Reference: *Time Series Classification: A review of Algorithms and Implementations*. www.researchgate.net method normalize(data, a, b)   Normalize the series to a optional range, usualy within `(-1, 1)` or `(0, 1)`.   Namespace types: array   Parameters:      data (array) : Sample data to normalize.      a (float) : Minimum target range value, `default=-1.0`.      b (float) : Minimum target range value, `default= 1.0`.   Returns: Normalized array within new range. ___ Reference: *Time Series Classification: A review of Algorithms and Implementations*. normalize_series(source, length, a, b)   Normalize the series to a optional range, usualy within `(-1, 1)` or `(0, 1)`.\ *Note that this may provide a different result than the array version due to rolling range*.   Parameters:      source (float) : Series to normalize.      length (int) : Number of bars to sample the range.      a (float) : Minimum target range value, `default=-1.0`.      b (float) : Minimum target range value, `default= 1.0`.   Returns: Normalized series within new range. method polar(data)   Turns a normalized sample array into polar coordinates.   Namespace types: array   Parameters:      data (array) : Sampled data values.   Returns: Converted array into polar coordinates. polar_series(source)   Turns a normalized series into polar coordinates.   Parameters:      source (float) : Source series.   Returns: Converted series into polar coordinates. method gasf(data)   Gramian Angular Summation Field *`GASF`*.   Namespace types: array   Parameters:      data (array) : Sampled data values.   Returns: Matrix with *`GASF`* values. method gasf_id(data)   Trig. identity of Gramian Angular Summation Field *`GASF`*.   Namespace types: array   Parameters:      data (array) : Sampled data values.   Returns: Matrix with *`GASF`* values. Reference: *Time Series Classification: A review of Algorithms and Implementations*. method gadf(data)   Gramian Angular Difference Field *`GADF`*.   Namespace types: array   Parameters:      data (array) : Sampled data values.   Returns: Matrix with *`GADF`* values. method gadf_id(data)   Trig. identity of Gramian Angular Difference Field *`GADF`*.   Namespace types: array   Parameters:      data (array) : Sampled data values.   Returns: Matrix with *`GADF`* values. Reference: *Time Series Classification: A review of Algorithms and Implementations*.
Perpustakaan Pine Script®
oleh RicardoSantos
1
MatrixScaleDownLibrary "MatrixScaleDown" Provides a function to scale down a matrix into a smaller square format were its values are averaged to mantain matrix topology. method scale_down(mat, size)   scale a matrix to a new smaller square size.   Namespace types: matrix   Parameters:      mat (matrix) : Source matrix.      size (int) : New matrix size.   Returns: New matrix with scaled down size. Source values will be averaged together.
Perpustakaan Pine Script®
oleh RicardoSantos
2
RSI Radar Multi Time FrameHello All! First of all many Thanks to Tradingview and Pine Team for developing Pine Language all the time! Now we have a new feature and it's called Polylines and I developed RSI Radar Multi Time Frame . This script is an example and experimental work, you can use it as you wish. The scripts gets RSI values from 6 different time frames, it doesn't matter the time frame you choose is higher/lower or chart time frame. it means that the script can get RSI values from higher or lower time frames than chart time frame. It's designed to show RSI Radar all the time on the chart even if you zoom in/out or scroll left/right. You can set OB/OS or RSI line colors. Also RSI polyline is shown as Curved/Hexagon optionally. Some screenshots here: Doesn't matter if you zoom out, it can show RSI radar in the visible area: Another example: You can change the colors, or see the RSI as Hexagon: Time frames from seconds to 1Day in this example while chart time frame is any ( 30mins here ) Enjoy!
Indikator Pine Script®
oleh LonesomeTheBlue
28
FunctionMatrixCovarianceLibrary "FunctionMatrixCovariance" In probability theory and statistics, a covariance matrix (also known as auto-covariance matrix, dispersion matrix, variance matrix, or variance–covariance matrix) is a square matrix giving the covariance between each pair of elements of a given random vector. Intuitively, the covariance matrix generalizes the notion of variance to multiple dimensions. As an example, the variation in a collection of random points in two-dimensional space cannot be characterized fully by a single number, nor would the variances in the `x` and `y` directions contain all of the necessary information; a `2 × 2` matrix would be necessary to fully characterize the two-dimensional variation. Any covariance matrix is symmetric and positive semi-definite and its main diagonal contains variances (i.e., the covariance of each element with itself). The covariance matrix of a random vector `X` is typically denoted by `Kxx`, `Σ` or `S`. ~wikipedia. method cov(M, bias)   Estimate Covariance matrix with provided data.   Namespace types: matrix   Parameters:      M (matrix) : `matrix` Matrix with vectors in column order.      bias (bool)   Returns: Covariance matrix of provided vectors. --- en.wikipedia.org numpy.org
Perpustakaan Pine Script®
oleh RicardoSantos
debugLibrary "debug" Show Array or Matrix Elements In Table Use anytime you want to see the elements in an array or a matrix displayed. Effective debugger, particularly for strategies and complex logic structures. Look in code to find instructions. Reach out if you need assistance. Functionality includes: Viewing the contents of an array or matrix on screen. Track variables and variable updates using debug() Track if and when local scopes fire using debugs() Types Allowed: string float int string debug(_col, _row, _name, _value, _msg, _ip)   Debug Variables in Matrix   Parameters:      _col (int) : (int) Assign Column      _row (int) : (int) Assign Row      _name (matrix) : (simple matrix) Matrix Name      _value (string) : (string) Assign variable as a string (str.tostring())      _msg (string)      _ip (int) : (int) (default 1) 1 for continuous updates. 2 for barstate.isnew updates. 3 for barstate.isconfirmed updates. -1 to only add once   Returns: Returns Variable _value output and _msg formatted as '_msg: variableOutput' in designated column and row debug(_col, _row, _name, _value, _msg, _ip)   Parameters:      _col (int)      _row (int)      _name (matrix)      _value (float)      _msg (string)      _ip (int) debug(_col, _row, _name, _value, _msg, _ip)   Parameters:      _col (int)      _row (int)      _name (matrix)      _value (int)      _msg (string)      _ip (int) debug(_col, _row, _name, _value, _msg, _ip)   Parameters:      _col (int)      _row (int)      _name (matrix)      _value (bool)      _msg (string)      _ip (int) debugs(_col, _row, _name, _msg)   Debug Scope in Matrix - Identify When Scope Is Accessed   Parameters:      _col (int) : (int) Column Number      _row (int) : (int) Row Number      _name (matrix) : (simple matrix) Matrix Name      _msg (string) : (string) Message   Returns: Message appears in debug panel using _col/_row as the identifier viewArray(_arrayName, _pos, _txtSize, _tRows, s_index, s_border, _rowCol, bCol, _fillCond, _offset)   Array Element Display (Supports float , int , string , and bool )   Parameters:      _arrayName (float ) : ID of Array to be Displayed      _pos (string) : Position for Table      _txtSize (string) : Size of Table Cell Text      _tRows (int) : Number of Rows to Display Data In (columns will be calculated accordingly)      s_index (bool) : (Optional. Default True.) Show/Hide Index Numbers      s_border (bool) : (Optional. Default False.) Show/Hide Border      _rowCol (string)      bCol (color) : = (Optional. Default Black.) Frame/Border Color.      _fillCond (bool) : (Optional) Conditional statement. Function displays array only when true. For instances where size is not immediately known or indices are na. Default = true, indicating array size is set at bar_index 0.      _offset (int) : (Optional) Use to view historical array states. Default = 0, displaying realtime bar.   Returns: A Display of Array Values in a Table viewArray(_arrayName, _pos, _txtSize, _tRows, s_index, s_border, _rowCol, bCol, _fillCond, _offset)   Parameters:      _arrayName (int )      _pos (string)      _txtSize (string)      _tRows (int)      s_index (bool)      s_border (bool)      _rowCol (string)      bCol (color)      _fillCond (bool)      _offset (int) viewArray(_arrayName, _pos, _txtSize, _tRows, s_index, s_border, _rowCol, bCol, _fillCond, _offset)   Parameters:      _arrayName (string )      _pos (string)      _txtSize (string)      _tRows (int)      s_index (bool)      s_border (bool)      _rowCol (string)      bCol (color)      _fillCond (bool)      _offset (int) viewArray(_arrayName, _pos, _txtSize, _tRows, s_index, s_border, _rowCol, bCol, _fillCond, _offset)   Parameters:      _arrayName (bool )      _pos (string)      _txtSize (string)      _tRows (int)      s_index (bool)      s_border (bool)      _rowCol (string)      bCol (color)      _fillCond (bool)      _offset (int) viewMatrix(_matrixName, _pos, _txtSize, s_index, _resetIdx, s_border, bCol, _fillCond, _offset)   Matrix Element Display (Supports , , , and )   Parameters:      _matrixName (matrix) : ID of Matrix to be Displayed      _pos (string) : Position for Table      _txtSize (string) : Size of Table Cell Text      s_index (bool) : (Optional. Default True.) Show/Hide Index Numbers      _resetIdx (bool)      s_border (bool) : (Optional. Default False.) Show/Hide Border      bCol (color) : = (Optional. Default Black.) Frame/Border Color.      _fillCond (bool) : (Optional) Conditional statement. Function displays matrix only when true. For instances where size is not immediately known or indices are na. Default = true, indicating matrix size is set at bar_index 0.      _offset (int) : (Optional) Use to view historical matrix states. Default = 0, displaying realtime bar.   Returns: A Display of Matrix Values in a Table viewMatrix(_matrixName, _pos, _txtSize, s_index, _resetIdx, s_border, bCol, _fillCond, _offset)   Parameters:      _matrixName (matrix)      _pos (string)      _txtSize (string)      s_index (bool)      _resetIdx (bool)      s_border (bool)      bCol (color)      _fillCond (bool)      _offset (int) viewMatrix(_matrixName, _pos, _txtSize, s_index, _resetIdx, s_border, bCol, _fillCond, _offset)   Parameters:      _matrixName (matrix)      _pos (string)      _txtSize (string)      s_index (bool)      _resetIdx (bool)      s_border (bool)      bCol (color)      _fillCond (bool)      _offset (int) viewMatrix(_matrixName, _pos, _txtSize, s_index, _resetIdx, s_border, bCol, _fillCond, _offset)   Parameters:      _matrixName (matrix)      _pos (string)      _txtSize (string)      s_index (bool)      _resetIdx (bool)      s_border (bool)      bCol (color)      _fillCond (bool)      _offset (int)
Perpustakaan Pine Script®
oleh kurtsmock
3
.print() You don't need to initialize anything.. After you import the library you can use .print() as easy as that..! Hope this helps * use a unique ID for each .print() call let me know if you run into any bugs by trying to make it as user friendly as possible i had to do some not ideal things so there's a chance it could present some bugs with a lot of labels present on the chart and if you use label.all to parse and manipulate the labels on the chart.. most likely it will cause an issue but not a lot of people use this so I don't think that will be a problem. thanks, FFriZz | frizlabz Library "print" Single function to print any type to console method str(inp)   `method` convert all types to string ``` (overload) *.str(any inp) => string ```   Namespace types: series string, simple string, input string, const string   Parameters:      inp (string) : `any` - desc | Required   Returns: `string` formatted string method str(inp)   Namespace types: series int, simple int, input int, const int   Parameters:      inp (int) method str(inp)   Namespace types: series float, simple float, input float, const float   Parameters:      inp (float) method str(inp)   Namespace types: series bool, simple bool, input bool, const bool   Parameters:      inp (bool) method str(inp)   Namespace types: series linefill   Parameters:      inp (linefill) method str(inp)   Namespace types: series line   Parameters:      inp (line) method str(inp)   Namespace types: series box   Parameters:      inp (box) method str(inp)   Namespace types: series label   Parameters:      inp (label) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: matrix   Parameters:      inp (matrix) method str(inp)   Namespace types: linefill   Parameters:      inp (linefill ) method str(inp)   Namespace types: line   Parameters:      inp (line ) method str(inp)   Namespace types: box   Parameters:      inp (box ) method str(inp)   Namespace types: label   Parameters:      inp (label ) method str(inp)   Namespace types: string   Parameters:      inp (string ) method str(inp)   Namespace types: int   Parameters:      inp (int ) method str(inp)   Namespace types: float   Parameters:      inp (float ) method str(inp)   Namespace types: bool   Parameters:      inp (bool ) method arrayShorten(str)   arrayShorten   Namespace types: series string, simple string, input string, const string   Parameters:      str (string) : `string` - the string to shorten | Required   Returns: `string` - a shortened version of the input string if it is an array with more than 7 elements, otherwise the original string method matrixShorten(str)   matrixShorten   Namespace types: series string, simple string, input string, const string   Parameters:      str (string) : `string` - the string to shorten | Required   Returns: `string` - the shortened matrix string if the input is a matrix, otherwise returns the input string as is method print(x, ID)   print all types to theh same console with just this `method/function` ``` (overload) *.print(any x, string ID, bool shorten=true?) => console "param 'shorten' - only for arrays and matrixs" | true ```   Namespace types: series string, simple string, input string, const string   Parameters:      x (string) : - `any` input to convert      ID (string) : - `string` unique id for label on console `MUST BE UNIQUE`   Returns: adds the `ID` and the `inp` to the console on the chart method print(x, ID)   Namespace types: series float, simple float, input float, const float   Parameters:      x (float)      ID (string) method print(x, ID)   Namespace types: series int, simple int, input int, const int   Parameters:      x (int)      ID (string) method print(x, ID)   Namespace types: series box   Parameters:      x (box)      ID (string) method print(x, ID)   Namespace types: series bool, simple bool, input bool, const bool   Parameters:      x (bool)      ID (string) method print(x, ID)   Namespace types: series label   Parameters:      x (label)      ID (string) method print(x, ID)   Namespace types: series line   Parameters:      x (line)      ID (string) method print(x, ID)   Namespace types: series linefill   Parameters:      x (linefill)      ID (string) method print(x, ID, shorten)   Namespace types: string   Parameters:      x (string )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: float   Parameters:      x (float )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: int   Parameters:      x (int )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: box   Parameters:      x (box )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: bool   Parameters:      x (bool )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: label   Parameters:      x (label )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: line   Parameters:      x (line )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: linefill   Parameters:      x (linefill )      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool) method print(x, ID, shorten)   Namespace types: matrix   Parameters:      x (matrix)      ID (string)      shorten (bool)
Perpustakaan Pine Script®
oleh FFriZz
2
Crypto Correlation MatrixA crypto correlation matrix or table is a tool that displays the correlation between different cryptocurrencies and other financial assets. The matrix provides an overview of the degree to which various cryptocurrencies move in tandem or independently of each other. Each cell represents the correlation between the row and column assets respectively. The correlation matrix can be useful for traders and investors in several ways: First, it allows them to identify trends and patterns in the behavior of different cryptocurrencies. By looking at the correlations between different assets, traders can gain insight into the intra-relationships of the crypto market and make more informed trading decisions. For example, if two cryptocurrencies have a high positive correlation, meaning that they tend to move in the same direction, a trader may want to diversify their portfolio by choosing to invest in only one of the two assets. Additionally, the correlation matrix can help traders and investors to manage risk. By analyzing the correlations between different assets, traders can identify opportunities to hedge their positions or limit their exposure to particular risks. For example, if a trader holds a portfolio of cryptocurrencies that are highly correlated with each other, they may be at greater risk of losses if the market moves against them. By diversifying their portfolio with assets that are less correlated with each other, they can reduce their overall risk. Some of the unique properties for this specific script are the correlation strength levels in conjunction with the color gradient of cells, intended for clearer readability. Features: Supports up to 64 different crypto assets. Dark/Light mode. Correlation strength levels and cell coloring. Adjustable positioning on the chart. Alerts at the close of a bar. (Daily timeframe or higher recommended)
Indikator Pine Script®
oleh EliCobra
3
Volume Profile Matrix [LuxAlgo]The Volume Profile Matrix indicator extends from regular volume profiles by also considering calculation intervals within the calculation window rather than only dividing the calculation window in rows. Note that this indicator is subject to repainting & back-painting, however, treating the indicator as a tool for identifying frequent points of interest can still be very useful. 🔶 SETTINGS Lookback: Number of most recent bars used to calculate the indicator. Columns: Number of columns (intervals) used to calculate the volume profile matrix. Rows: Number of rows (intervals) used to calculate the volume profile matrix. 🔶 USAGE The Volume Profile Matrix indicator can be used to obtain more information regarding liquidity on specific time intervals. Instead of simply dividing the calculation window into equidistant rows, the calculation is done through a grid. Grid cells with trading activity occurring inside them are colored. More activity is highlighted through a gradient and by default, cells with a color that are closer to red indicate that more trading activity took place within that cell. The cell with the highest amount of trading activity is always highlighted in yellow. Each interval (column) includes a point of control which highlights an estimate of the price level with the highest traded volume on that interval. The level with the highest traded volume of the overall grid is extended to the most recent bar.
Indikator Pine Script®
oleh LuxAlgo
11
PSv5 3D Array/Matrix Super Hack"In a world of ever pervasive and universal deceit, telling a simple truth is considered a revolutionary act." INTRO: First, how about a little bit of philosophic poetry with another dimension applied to it? The "matrix of control" is everywhere... It is all around us, even now in the very place you reside. You can see it when you look at your digitized window outwards into the world, or when you turn on regularly scheduled television "programs" to watch news narratives and movies that subliminally influence your thoughts, feelings, and emotions. You have felt it every time you have clocked into dead end job workplaces... when you unknowingly worshiped on the conformancy alter to cultish ideologies... and when you pay your taxes to a godvernment that is poisoning you softly and quietly by injecting your mind and body with (psyOps + toxicCompounds). It is a fictitiously generated world view that has been pulled over your eyes to blindfold, censor, and mentally prostrate you from spiritually hearing the real truth. What TRUTH you must wonder? That you are cognitively enslaved, like everyone else. You were born into mental bondage, born into an illusory societal prison complex that you are entirely incapable of smelling, tasting, or touching. Its a contrived monetary prison enterprise for your mind and eternal soul, built by pretending politicians, corporate CONartists, and NonGoverning parasitic Organizations deploying any means of infiltration and deception by using every tactic unimaginable. You are slowly being convinced into becoming a genetically altered cyborg by acclimation, socially engineered and chipped to eventually no longer be 100% human. Unfortunately no one can be told eloquently enough in words what the matrix of control truly is. You have to experience it and witness it for yourself. This is your chance to program a future paradigm that doesn't yet exist. After visiting here, there is absolutely no turning back. You can continually take the blue pill BIGpharmacide wants you to repeatedly intake. The story ends if you continually sleep walk through a 2D hologram life, believing whatever you wish to believe until you cease to exist. OR, you can take the red pill challenge, explore "question every single thing" wonderland, program your arse off with 3D capabilities, ultimately ascertaining a new mathematical empyrean. Only then can you fully awaken to discover how deep the rabbit hole state of affairs transpire worldwide with a genuine open mind. Remember, all I'm offering is a mathematical truth, nothing more... PURPOSE: With that being said above, it is now time for advanced developers to start creating their own matrix constructs in 3D, in Pine, just as the universe is created spatially. For those of you who instantly know what this script's potential is easily capable of, you already know what you have to do with it. While this is simplistically just a 3D array for either integers or floats, additional companion functions can in the future be constructed by other members to provide a more complete matrix/array library for millions of folks on TV. I do encourage the most courageous of mathemagicians on TV to do so. I have been employing very large 2D/3D array structures for quite some time, and their utility seems to be of great benefit. Discovering that for myself, I fully realized that Pine is incomplete and must be provided with this agility to process complex datasets that traders WILL use in the future. Mark my words! CONCEPTION: While I have long realized and theorized this code for a great duration of time, I was finally able to turn it into a Pine reality with the assistance and training of an "artificially intuitive" program while probing its aptitude. Even though it knows virtually nothing about Pine Script 4.0 or 5.0 syntax, functions, and behavior, I was able to conjure code into an identity similar to what you see now within a few minutes. Close enough for me! Many manual edits later for pine compliance, and I had it in chart, presto! While most people consider the service to be an "AI", it didn't pass my Pine Turing test. I did have to repeatedly correct it, suffered through numerous apologies from it, was forced to use specifically tailored words, and also rationally debate AND argued with it. It is a handy helper but beware of generating Pine code from it, trust me on this one. However... this artificially intuitive service is currently available in its infancy as version 3. Version 4 most likely will have more diversity to enhance my algorithmic expertise of Pine wizardry. I do have to thank E.M. and his developers for an eye opening experience, or NONE of this code below would be available as you now witness it today. LIMITATIONS: As of this initial release, Pine only supports 100,000 array elements maximum. For example, when using this code, a 50x50x40 element configuration will exceed this limit, but 50x50x39 will work. You will always have to keep that in mind during development. Running that size of an array structure on every single bar will most likely time out within 20-40 seconds. This is not the most efficient method compared to a real native 3D array in action. Ehlers adepts, this might not be 100% of what you require to "move forward". You can try, but head room with a low ceiling currently will be challenging to walk in for now, even with extremely optimized Pine code. A few common functions are provided, but this can be extended extensively later if you choose to undertake that endeavor. Use the code as is and/or however you deem necessary. Any TV member is granted absolute freedom to do what they wish as they please. I ultimately wish to eventually see a fully equipped library version for both matrix3D AND array3D created by collaborative efforts that will probably require many Pine poets testing collectively. This is just a bare bones prototype until that day arrives. Considerably more computational server power will be required also. Anyways, I hope you shall find this code somewhat useful. Notice: Unfortunately, I will not provide any integration support into members projects at all. I have my own projects that require too much of my time already. POTENTIAL APPLICATIONS: The creation of very large coefficient 3D caches/buffers specifically at bar_index==0 can dramatically increase runtime agility for thousands of bars onwards. Generating 1000s of values once and just accessing those generated values is much faster. Also, when running dozens of algorithms simultaneously, a record of performance statistics can be kept, self-analyzed, and visually presented to the developer/user. And, everything else under the sun can be created beyond a developers wildest dreams... EPILOGUE: Free your mind!!! And unleash weapons of mass financial creation upon the earth for all to utilize via the "Power of Pine". Flying monkeys and minions are waging economic sabotage upon humanity, decimating markets and exchanges. You can always see it your market charts when things go horribly wrong. This is going to be an astronomical technical challenge to continually navigate very choppy financial markets that are increasingly becoming more and more unstable and volatile. Ordinary one plot algorithms simply are not enough anymore. Statistics and analysis sits above everything imagined. This includes banking, godvernment, corporations, REAL science, technology, health, medicine, transportation, energy, food, etc... We have a unique perspective of the world that most people will never get to see, depending on where you look. With an ever increasingly complex world in constant dynamic flux, novel ways to process data intricately MUST emerge into existence in order to tackle phenomenal tasks required in the future. Achieving data analysis in 3D forms is just one lonely step of many more to come. At this time the WesternEconomicFraudsters and the WorldHealthOrders are attempting to destroy/reset the world's financial status in order to rain in chaos upon most nations, causing asset devaluation and hyper-inflation. Every form of deception, infiltration, and theft is occurring with a result of destroyed wealth in preparation to consolidate it. Open discussions, available to the public, by world leaders/moguls are fantasizing about new dystopian system as a one size fits all nations solution of digitalID combined with programmableDemonicCurrencies to usher in a new form of obedient servitude to a unipolar digitized hegemony of monetary vampires. If they do succeed with economic conquest, as they have publicly stated, people will be converted into human cattle, herded within smart cities, you will own nothing, eat bugs for breakfast/lunch/dinner, live without heat during severe winter conditions, and be happy. They clearly haven't done the math, as they are far outnumbered by a ratio of 1 to millions. Sith Lords do not own planet Earth! The new world disorder of human exploitation will FAIL. History, my "greatest teacher" for decades reminds us over, and over, and over again, and what are time series for anyways? They are for an intense mathematical analysis of prior historical values/conditions in relation to today's values/conditions... I imagine one day we will be able to ask an all-seeing AI, "WHO IS TO BLAME AND WHY AND WHEN?" comprised of 300 pages in great detail with images, charts, and statistics. What are the true costs of malignant lies? I will tell you... 64bit numbers are NOT even capable of calculating the extreme cost of pernicious lies and deceit. That's how gigantic this monstrous globalization problem has become and how awful the "matrix of control" truly is now. ALL nations need a monumental revision of its CODE OF ETHICS, and that's definitely a multi-dimensional problem that needs solved sooner than later. If it was up to me, economies and technology would be developed so extensively to eliminate scarcity and increase the standard of living so high, that the notion of war and conflict would be considered irrelevant and extremely appalling to the future generations of humanity, our grandchildren born and unborn. The future will not be owned and operated by geriatric robber barons destined to expire quickly. The future will most likely be intensely "guided" by intelligent open source algorithms that youthful generations will inherit as their birth right. P.S. Don't give me that politco-my-diction crap speech below in comments. If they weren't meddling with economics mucking up 100% of our chart results in 100% of tickers, I wouldn't have any cause to analyze any effects generated by them, nor provide this script's code. I am performing my analytical homework, but have you? Do you you know WHY international affairs are in dire jeopardy? Without why, the "Power of Pine" would have never existed as it specifically does today. I'm giving away much of my mental power generously to TV members so you are specifically empowered beyond most mathematical agilities commonly existing. I'm just a messenger of profound ideas. Loving and loathing of words is ALWAYS in the eye of beholders, and that's why the freedom of speech is enshrined as #1 in the constitutional code of the USA. Without it, this entire site might not have been allowed to exist from its founder's inceptions.
Indikator Pine Script®
oleh ImmortalFreedom
12
columnsLibrary "columns" Error Tolerant Matrix Setter/Getter Operations. Easy ways to add/remove items into start and end of Columns as well as arrays to grow and shrink matrix. if mismatched sizes occur the typified NA value will be there to prevent catastrophic crashing. Rows and Columns are split into 2 libraries due to limitations on number of exports as well as ease of style (columns.shift(), rows.pop() ) pop(_matrix)   do pop last Column off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of Last Column, removing it from matrix shift(_matrix)   do shift the first Column off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of First Column, removing it from matrix get(_matrix, _clmnNum)   retrieve specific Column of matrix   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted   Returns: Array of selected Column number, leaving in place push(_matrix, _clmnNum, _item)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _item : Item to Push on Column   Returns: shifted item from Column start push(_matrix, _array)   add single item onto end of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to Push on Matrix   Returns: Void unshift(_matrix, _clmnNum, _item)   slide single item into start of Column remove last   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _item : Item to Unshift on Column   Returns: popped item from Column end unshift(_matrix, _array)   add single item into first Column of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift into Matrix   Returns: Void set(_matrix, _clmnNum, _array)   replace an array to an existing Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _array : Array to place in Matrix   Returns: Column that was replaced insert(_matrix, _clmnNum, _array)   insert an array to a new Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _array : Array to place in Matrix   Returns: void slideDown(_matrix, _array)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _array : Array to push to Matrix   Returns: shifted first Column slideUp(_matrix, _array)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift to Matrix   Returns: poppeed last Column pullOut(_matrix, _clmnNum)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted   Returns: removed selected Column
Perpustakaan Pine Script®
oleh kaigouthro
1
rowsLibrary "rows" Error Tolerant Matrix Setter/Getter Operations. Easy ways to add/remove items into start and end of rows as well as arrays to grow and shrink matrix. if mismatched sizes occur the typified NA value will be there to prevent catastrophic crashing. columns and rows are split into 2 libraries due to limitations on number of exports as well as ease of style (columns.shift(), rows.pop() ) pop(_matrix)   do pop last row off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of Last row, removing it from matrix shift(_matrix)   do shift the first row off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of First row, removing it from matrix get(_matrix, _rowNum)   retrieve specific row of matrix   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted   Returns: Array of selected row number, leaving in place push(_matrix, _rowNum, _item)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _item : Item to Push on Row   Returns: shifted item from row start push(_matrix, _array)   add single item onto end of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to Push on Matrix   Returns: Void unshift(_matrix, _rowNum, _item)   slide single item into start of row remove last   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _item : Item to Unshift on Row   Returns: popped item from row end unshift(_matrix, _array)   add single item into first row of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift into Matrix   Returns: Void set(_matrix, _rowNum, _array)   replace an array to an existing row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _array : Array to place in Matrix   Returns: row that was replaced insert(_matrix, _rowNum, _array)   insert an array to a new row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _array : Array to place in Matrix   Returns: void slideDown(_matrix, _array)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _array : Array to push to Matrix   Returns: shifted first row slideUp(_matrix, _array)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift to Matrix   Returns: popped last row pullOut(_matrix, _rowNum)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted   Returns: removed selected row
Perpustakaan Pine Script®
oleh kaigouthro
3