Inizia

Cerca negli script per "entry"

RSI-MTF-Histo-EntryThis indicator gives a histogram of RSI in relation to an ema of the RSI. The histogram is then smoothed to reduce false signals. The actualiteit RSI line with overbought/overvols signals can be added or omitted as preferred. The background can be color coded if the RSI is above or below 50. Version 2. Added support for MTF. Longer timesframes (1h-3h) tend to give better entry results. As an example the indicator was added two times, one for the current timeframe and one for a longer timeframe.
Indicatore Pine Script®
di Duyck
6
MULTIPLE TIME-FRAME STRATEGY(TREND, MOMENTUM, ENTRY) Hey everyone, this is one strategy that I have found profitable over time. It is a multiple time frame strategy that utilizes 3 time-frames. Highest time-frame is the trend, medium time-frame is the momentum and short time-frame is the entry point. Long Term: - If closed candle is above entry then we are looking for longs, otherwise we are looking for shorts Medium Term: - If Stoch SmoothK is above or below SmoothK and the momentum matches long term trend then we look for entries. Short Term: - If a moving average crossover(long)/crossunder(short) occurs then place a trade in the direction of the trend. Close Trade: - Trade is closed when the Medium term SmoothK Crosses under/above SmoothD. You can mess with the settings to get the best Profit Factor / Percent Profit that matches your plan. Best of luck!
Strategia Pine Script®
di tux
4
T3 Entry and ExitI made this indicator to give clear entry and exit signals plus give signals when I should add onto my trades with no repainting!! The bottom indicator is set to 34 (the default settings). This gives me my entries and exits as shown by the green and red arrow. I use a 14 period setting for my signals to add onto my trade. If I am in a long trade as shown in the chart above and the 14 period T3EE has a fast line cross under the slow line and then a cross back over and I have not had my signal to close trade yet on the 34 period T3EE I will add to my long position. I cut the size of they order in half with each addition to my position. So if I entered with 2 lots I would add 1 lot with my first signal to add (shown by orange arrow) and then .5 lots with the second signal to add to my position and so on until it is time to close the position. If you day trade avoid entering positions between 4pm est and 9pm est. and the larger the ranges and the more trendy the market the better. Good Luck!!! If you have any questions let me know :)
Indicatore Pine Script®
di stocktrader15
6
Price Action + Support/Resistance with LabelsEntry Conditions: Long Entry (BUY): Based on the bullish engulfing pattern and price being above the resistance level. Short Entry (SELL): For demonstration, the short entry condition is set as price being below the support level and a bullish candle in the previous bar. You can modify this logic for your own use case. Stop Loss and Take Profit: Stoploss is plotted at the calculated stop loss level. Target is plotted at the calculated take profit level. Labels: For long trades, labels are added with "BUY", "STOPLOSS", and "TARGET". For short trades (if enabled), labels are added with "SELL", "STOPLOSS", and "TARGET". Labels are placed using label.new at specific locations on the chart (above or below bars). Alert Conditions: Alerts are created for both long and short entry signals so you can get notified when the entry conditions are met. How it works: BUY label will appear below the bar when a long entry condition is met. SELL label will appear above the bar when a short entry condition is met. STOPLOSS and TARGET labels will appear at their respective levels when an entry signal is triggered. The labels will appear on the chart to give you a clear visual cue of the entry, stop loss, and take profit levels. How to Use: Copy the script into your Pine Editor on TradingView and apply it to your chart. Observe the labels that show up on the chart: "BUY" will appear below the bar when long conditions are met. "SELL" will appear above the bar when short conditions are met (if using short logic). "STOPLOSS" will be plotted at the stop loss level. "TARGET" will be plotted at the take profit level. Optional Customization: You can modify the short entry condition based on your preferred method. You can adjust the length for the support/resistance calculation, the stopLossRR, and other parameters to fine-tune the strategy for Nifty 50 or any other asset. Let me know if you have any further questions or need additional modifications!
Indicatore Pine Script®
di subairmkd97
MACD + RSI + EMA + BB + ATR Day Trading StrategyEntry Conditions and Signals The strategy implements a multi-layered filtering approach to entry conditions, requiring alignment across technical indicators, timeframes, and market conditions . Long Entry Requirements Trend Filter: Fast EMA (9) must be above Slow EMA (21), price must be above Fast EMA, and higher timeframe must confirm uptrend MACD Signal: MACD line crosses above signal line, indicating increasing bullish momentum RSI Condition: RSI below 70 (not overbought) but above 40 (showing momentum) Volume & Volatility: Current volume exceeds 1.2x 20-period average and ATR shows sufficient market movement Time Filter: Trading occurs during optimal hours (9:30-11:30 AM ET) when market volatility is typically highest Exit Strategies The strategy employs multiple exit mechanisms to adapt to changing market conditions and protect profits : Stop Loss Management Initial Stop: Placed at 2.0x ATR from entry price, adapting to current market volatility Trailing Stop: 1.5x ATR trailing stop that moves up (for longs) or down (for shorts) as price moves favorably Time-Based Exits: All positions closed by end of trading day (4:00 PM ET) to avoid overnight risk Best Practices for Implementation Settings Chart Setup: 5-minute timeframe for execution with 15-minute chart for trend confirmation Session Times: Focus on 9:30-11:30 AM ET trading for highest volatility and opportunity
Strategia Pine Script®
di shui2967
Amazing Crossover SystemEntry Rules BUY when the 5 EMA crosses above the 10 EMA from underneath and the RSI crosses above the 50.0 mark from the bottom. SELL when the 5 EMA crosses below the 10 EMA from the top and the RSI crosses below the 50.0 mark from the top. Make sure that the RSI did cross 50.0 from the top or bottom and not just ranging tightly around the level. How to setup Alert: 1) Add the Amazing Crossover System to your chart via Indicators 2) Find your currency pair 3) Set the timeframe on the chart to 1 hour 4) Press 'Alt + A' (create alert shortcut) 5) Set the following criteria for the alert: Condition = 'Amazing Crossover System', Plot, ' BUY Signal' The rest of the alert can be customized to your preferences 5) Repeat steps 1 - 4, but set the Condition = 'Amazing Crossover System', Plot, ' SELL Signal'
Indicatore Pine Script®
di rmunoz
4
Gabriel's Weibull Stdv. SuperTrend📈 Gabriel's Weibull Stdv. SuperTrend Description: Gabriel’s Weibull Stdv. SuperTrend is a custom trend-following indicator that blends the statistical rigor of the Weibull Moving Average with the adaptive nature of the Standard Deviation-based SuperTrend. This hybrid system dynamically adjusts its trend bands using a Weibull-weighted average, emphasizing more recent price action while allowing the curve to flexibly adapt based on two key Weibull parameters: Shape (k) and Scale (λ). The bands themselves are shifted by a multiple of standard deviation, offering a volatility-sensitive approach to trend detection. 🔧 Key Components: Weibull Moving Average (WMA): A smoothing function that assigns weights to historical prices using the Weibull distribution, controlled via Shape and Scale parameters. SuperTrend Logic with Adaptive Bands: Standard deviation is calculated over a user-defined length and scaled with a factor to set upper and lower thresholds around the WMA. Trend Direction Detection: The algorithm identifies bullish or bearish states based on crossover logic relative to the dynamic bands. Visual Enhancements: Bright green/red lines for SuperTrend direction. Midpoint overlay and color-coded candles for clarity. Filled zones between price and trend for visual emphasis. ⚙️ User Inputs: Source: Price data to analyze (default: close). Stdv. Length: Period for calculating standard deviation. Factor: Multiplier to widen or narrow the SuperTrend bands. Window Length: Lookback period for the Weibull MA. Shape (k): Controls the skewness of the Weibull distribution. Scale (λ): Stretches or compresses the weighting curve. Location (θ) : Shift influence of historical data forward/backward. 🔔 Alerts: Long Entry Alert: Triggered when the trend flips bullish. Short Entry Alert: Triggered when the trend flips bearish. 🧠 Use Cases: Catch early reversals using custom-tailored smoothing. Identify high-confidence trend shifts with dynamic volatility. Combine with other confirmation indicators for enhanced entries.
Indicatore Pine Script®
di GabrielAmadeusLau
TRI - Smart Zones============================================================================ # TRI - SMART ZONES v2.0 ## Professional Smart Money Concepts Indicator for Pine Script v6 ============================================================================ ## 📊 OVERVIEW **TRI - Smart Zones** is a comprehensive Smart Money Concepts indicator that combines multiple institutional trading concepts into a single, powerful tool. Built with Pine Script v6 for optimal performance and reliability. ## 🎯 CORE FEATURES ### **Fair Value Gaps (FVG)** - **Detection**: Automatic identification of price imbalances - **Types**: Bullish and Bearish Fair Value Gaps - **Threshold**: Customizable gap size requirements (0.1% default) - **Extension**: Configurable zone projection length - **Mitigation**: Real-time tracking of gap fills ### **Order Blocks (OB)** - **Detection**: Volume-based institutional footprint identification - **Types**: Bullish and Bearish Order Blocks - **Method**: Pivot-based volume analysis with configurable lookback - **Validation**: Market structure confirmation required - **Extension**: Adjustable zone projection ### **BSL/SSL Liquidity Levels** - **Multi-Timeframe**: Automatic higher timeframe reference - **Dynamic**: Real-time level updates and extensions - **Visual**: Clear line markings with timeframe labels - **Smart**: Adaptive timeframe selection based on current chart ### **Fibonacci Extensions** - **ZigZag Integration**: Advanced pivot point detection - **Levels**: Customizable Fibonacci ratios (38.2%, 61.8%, 100%, 161.8%) - **Projection**: Dynamic extension from swing points - **Visual**: Subtle dashed lines with level/price labels ### **Smart Dashboard** - **Zone Statistics**: Real-time FVG and OB counts - **Success Rates**: Mitigation percentages for each zone type - **Market Bias**: Intelligent bullish/bearish/neutral assessment - **Positioning**: Customizable location and size ### **Zone Analysis Engine** - **Technical Confluence**: RSI, ADX, ATR, Volume analysis - **VWAP Integration**: Institutional price reference - **Confidence Scoring**: High/Mid/Low signal classification - **Signal Arrows**: Visual trade direction indicators ## 🔔 ALERT SYSTEM ### **Market Structure Alerts** - `Market Bias Changed` - Shift in overall market sentiment - `BSL Touched` - Buy Side Liquidity level reached - `SSL Touched` - Sell Side Liquidity level reached ### **Zone Touch Alerts** - `OB Touched` - Any Order Block interaction - `Bullish OB Touched` - Bullish Order Block touch - `Bearish OB Touched` - Bearish Order Block touch - `FVG Touched` - Any Fair Value Gap interaction - `Bullish FVG Touched` - Bullish FVG touch - `Bearish FVG Touched` - Bearish FVG touch - `Zone Touched` - Any Smart Zone interaction - `Bullish Zone Touched` - Any bullish zone touch - `Bearish Zone Touched` - Any bearish zone touch ## ⚙️ CONFIGURATION ### **Zone Detection** - Enable/disable FVG and OB detection independently - Maximum zones per type (3-15, default: 8) - Zone-specific threshold and extension settings ### **Visual Customization** - Individual color schemes for each zone type - Adjustable transparency levels - Configurable line styles and widths - Dashboard positioning and sizing options ### **Technical Analysis** - RSI, ADX, ATR period customization - Volume threshold multipliers - Confidence level color coding - Signal display toggle ## 🚀 PINE SCRIPT v6 OPTIMIZATIONS - **User-Defined Types**: Structured data for zones and statistics - **Methods**: Type-specific operations for better code organization - **Enhanced Arrays**: Optimized memory management - **Switch Statements**: Improved performance for zone classification - **Error Handling**: Robust input validation and edge case management - **Performance**: Efficient algorithms for real-time analysis ## 📈 TRADING APPLICATIONS ### **Entry Strategies** - Zone confluence for high-probability setups - Multi-timeframe confirmation via BSL/SSL - Fibonacci extension targets - Signal arrows for directional bias ### **Risk Management** - Zone mitigation for stop-loss placement - Market bias for position sizing - Dashboard statistics for strategy validation ### **Market Analysis** - Institutional footprint identification - Liquidity level mapping - Market structure assessment - Trend continuation vs reversal analysis ## 🔧 TECHNICAL SPECIFICATIONS - **Version**: Pine Script v6 - **Overlay**: True (draws on price chart) - **Max Objects**: 100 boxes, 100 lines, 50 labels - **Performance**: Optimized for real-time analysis - **Compatibility**: All TradingView chart types and timeframes
Indicatore Pine Script®
di riccardo_tempesta
Big Candle Identifier with RSI Divergence and Advanced Stops1. Strategy Objective The main goal of this strategy is to: Identify significant price momentum (big candles). Enter trades at opportune moments based on market signals (candlestick patterns and RSI divergence). Limit initial risk through a fixed stop loss. Maximize profits by using a trailing stop that activates only after the trade moves a specified distance in the profitable direction. 2. Components of the Strategy A. Big Candle Identification The strategy identifies big candles as indicators of strong momentum. A big candle is defined as: The body (absolute difference between close and open) of the current candle (body0) is larger than the bodies of the last five candles. The candle is: Bullish Big Candle: If close > open. Bearish Big Candle: If open > close. Purpose: Big candles signal potential continuation or reversal of trends, serving as the primary entry trigger. B. RSI Divergence Relative Strength Index (RSI): A momentum oscillator used to detect overbought/oversold conditions and divergence. Fast RSI: A 5-period RSI, which is more sensitive to short-term price movements. Slow RSI: A 14-period RSI, which smoothens fluctuations over a longer timeframe. Divergence: The difference between the fast and slow RSIs. Positive divergence (divergence > 0): Bullish momentum. Negative divergence (divergence < 0): Bearish momentum. Visualization: The divergence is plotted on the chart, helping traders confirm momentum shifts. C. Stop Loss Initial Stop Loss: When entering a trade, an immediate stop loss of 200 points is applied. This stop loss ensures the maximum risk is capped at a predefined level. Implementation: Long Trades: Stop loss is set below the entry price at low - 200 points. Short Trades: Stop loss is set above the entry price at high + 200 points. Purpose: Prevents significant losses if the price moves against the trade immediately after entry. D. Trailing Stop The trailing stop is a dynamic risk management tool that adjusts with price movements to lock in profits. Here’s how it works: Activation Condition: The trailing stop only starts trailing when the trade moves 200 ticks (profit) in the right direction: Long Position: close - entry_price >= 200 ticks. Short Position: entry_price - close >= 200 ticks. Trailing Logic: Once activated, the trailing stop: For Long Positions: Trails behind the price by 150 ticks (trail_stop = close - 150 ticks). For Short Positions: Trails above the price by 150 ticks (trail_stop = close + 150 ticks). Exit Condition: The trade exits automatically if the price touches the trailing stop level. Purpose: Ensures profits are locked in as the trade progresses while still allowing room for price fluctuations. E. Trade Entry Logic Long Entry: Triggered when a bullish big candle is identified. Stop loss is set at low - 200 points. Short Entry: Triggered when a bearish big candle is identified. Stop loss is set at high + 200 points. F. Trade Exit Logic Trailing Stop: Automatically exits the trade if the price touches the trailing stop level. Fixed Stop Loss: Exits the trade if the price hits the predefined stop loss level. G. 21 EMA The strategy includes a 21-period Exponential Moving Average (EMA), which acts as a trend filter. EMA helps visualize the overall market direction: Price above EMA: Indicates an uptrend. Price below EMA: Indicates a downtrend. H. Visualization Big Candle Identification: The open and close prices of big candles are plotted for easy reference. Trailing Stop: Plotted on the chart to visualize its progression during the trade. Green Line: Indicates the trailing stop for long positions. Red Line: Indicates the trailing stop for short positions. RSI Divergence: Positive divergence is shown in green. Negative divergence is shown in red. 3. Key Parameters trail_start_ticks: The number of ticks required before the trailing stop activates (default: 200 ticks). trail_distance_ticks: The distance between the trailing stop and price once the trailing stop starts (default: 150 ticks). initial_stop_loss_points: The fixed stop loss in points applied at entry (default: 200 points). tick_size: Automatically calculates the minimum tick size for the trading instrument. 4. Workflow of the Strategy Step 1: Entry Signal The strategy identifies a big candle (bullish or bearish). If conditions are met, a trade is entered with a fixed stop loss. Step 2: Initial Risk Management The trade starts with an initial stop loss of 200 points. Step 3: Trailing Stop Activation If the trade moves 200 ticks in the profitable direction: The trailing stop is activated and follows the price at a distance of 150 ticks. Step 4: Exit the Trade The trade is exited if: The price hits the trailing stop. The price hits the initial stop loss. 5. Advantages of the Strategy Risk Management: The fixed stop loss ensures that losses are capped. The trailing stop locks in profits after the trade becomes profitable. Momentum-Based Entries: The strategy uses big candles as entry triggers, which often indicate strong price momentum. Divergence Confirmation: RSI divergence helps validate momentum and avoid false signals. Dynamic Profit Protection: The trailing stop adjusts dynamically, allowing the trade to capture larger moves while protecting gains. 6. Ideal Market Conditions This strategy performs best in: Trending Markets: Big candles and momentum signals are more effective in capturing directional moves. High Volatility: Larger price swings improve the probability of reaching the trailing stop activation level (200 ticks).
Strategia Pine Script®
di NomaAlgo
2
Nef33 Forex & Crypto Trading Signals PRO 1. Understanding the Indicator's Context The indicator generates signals based on confluence (trend, volume, key zones, etc.), but it does not include predefined SL or TP levels. To establish them, we must: Use dynamic or static support/resistance levels already present in the script. Incorporate volatility (such as ATR) to adjust the levels based on market conditions. Define a risk/reward ratio (e.g., 1:2). 2. Options for Determining SL and TP Below, I provide several ideas based on the tools available in the script: Stop Loss (SL) The SL should protect you from adverse movements. You can base it on: ATR (Volatility): Use the smoothed ATR (atr_smooth) multiplied by a factor (e.g., 1.5 or 2) to set a dynamic SL. Buy: SL = Entry Price - (atr_smooth * atr_mult). Sell: SL = Entry Price + (atr_smooth * atr_mult). Key Zones: Place the SL below a support (for buys) or above a resistance (for sells), using Order Blocks, Fair Value Gaps, or Liquidity Zones. Buy: SL below the nearest ob_lows or fvg_lows. Sell: SL above the nearest ob_highs or fvg_highs. VWAP: Use the daily VWAP (vwap_day) as a critical level. Buy: SL below vwap_day. Sell: SL above vwap_day. Take Profit (TP) The TP should maximize profits. You can base it on: Risk/Reward Ratio: Multiply the SL distance by a factor (e.g., 2 or 3). Buy: TP = Entry Price + (SL Distance * 2). Sell: TP = Entry Price - (SL Distance * 2). Key Zones: Target the next resistance (for buys) or support (for sells). Buy: TP at the next ob_highs, fvg_highs, or liq_zone_high. Sell: TP at the next ob_lows, fvg_lows, or liq_zone_low. Ichimoku: Use the cloud levels (Senkou Span A/B) as targets. Buy: TP at senkou_span_a or senkou_span_b (whichever is higher). Sell: TP at senkou_span_a or senkou_span_b (whichever is lower). 3. Practical Implementation Since the script does not automatically draw SL/TP, you can: Calculate them manually: Observe the chart and use the levels mentioned. Modify the code: Add SL/TP as labels (label.new) at the moment of the signal. Here’s an example of how to modify the code to display SL and TP based on ATR with a 1:2 risk/reward ratio: Modified Code (Signals Section) Find the lines where the signals (trade_buy and trade_sell) are generated and add the following: pinescript // Calculate SL and TP based on ATR atr_sl_mult = 1.5 // Multiplier for SL atr_tp_mult = 3.0 // Multiplier for TP (1:2 ratio) sl_distance = atr_smooth * atr_sl_mult tp_distance = atr_smooth * atr_tp_mult if trade_buy entry_price = close sl_price = entry_price - sl_distance tp_price = entry_price + tp_distance label.new(bar_index, low, "Buy: " + str.tostring(math.round(bull_conditions, 1)), color=color.green, textcolor=color.white, style=label.style_label_up, size=size.tiny) label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny) label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_up, size=size.tiny) if trade_sell entry_price = close sl_price = entry_price + sl_distance tp_price = entry_price - tp_distance label.new(bar_index, high, "Sell: " + str.tostring(math.round(bear_conditions, 1)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny) label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_up, size=size.tiny) label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_down, size=size.tiny) Code Explanation SL: Calculated by subtracting/adding sl_distance to the entry price (close) depending on whether it’s a buy or sell. TP: Calculated with a double distance (tp_distance) for a 1:2 risk/reward ratio. Visualization: Labels are added to the chart to display SL (red) and TP (blue). 4. Practical Strategy Without Modifying the Code If you don’t want to modify the script, follow these steps manually: Entry: Take the trade_buy or trade_sell signal. SL: Check the smoothed ATR (atr_smooth) on the chart or calculate a fixed level (e.g., 1.5 times the ATR). Also, review nearby key zones (OB, FVG, VWAP). TP: Define a target based on the next key zone or multiply the SL distance by 2 or 3. Example: Buy at 100, ATR = 2. SL = 100 - (2 * 1.5) = 97. TP = 100 + (2 * 3) = 106. 5. Recommendations Test in Demo: Apply this logic in a demo account to adjust the multipliers (atr_sl_mult, atr_tp_mult) based on the market (forex or crypto). Combine with Zones: If the ATR-based SL is too wide, use the nearest OB or FVG as a reference. Risk/Reward Ratio: Adjust the TP based on your tolerance (1:1, 1:2, 1:3)
Indicatore Pine Script®
di neftali1327
1
CalculatePercentageSlTpLibrary "CalculatePercentageSlTp" This Library calculate the sl and tp amount in percentage sl_percentage(entry_price, sl_price)   this function calculates the sl value in percentage   Parameters:      entry_price : indicates the entry level      sl_price : indicates the stop loss level   Returns: stop loss in percentage tp_percentage(entry_price, tp_price)   this function calculates the tp value in percentage   Parameters:      entry_price : indicates the entry level      tp_price : indicates the take profit level   Returns: take profit in percentage sl_level(entry_price, sl_percentage)   this function calculates the sl level price   Parameters:      entry_price : indicates the entry level      sl_percentage : indicates the stop loss percentage   Returns: stop loss price in $ tp_level(entry_price, tp_percentage)   this function calculates the tp level price   Parameters:      entry_price : indicates the entry level      tp_percentage : indicates the take profit percentage   Returns: take profit price in $
Libreria Pine Script®
di massiveMoth88776
BackTestLibLibrary "BackTestLib" Allows backtesting indicator performance. Tracks typical metrics such as won/loss, profit factor, draw down, etc. Trading View strategy library provides similar (and more comprehensive) functionality but only works with strategies. This libary was created to address performance tracking within indicators. Two primary outputs are generated: 1. Summary Table: Displays overall performance metrics for the indicator over the chart's loaded timeframe and history 2. Details Table: Displays a table of individual trade entries and exits. This table can grow larger than the available chart space. It does have a max number of rows supported. I haven't found a way to add scroll bars or scroll bar equivalents yet. f_init(data, _defaultStopLoss, _defaultTakeProfit, _useTrailingStop, _useTraingStopToBreakEven, _trailingStopActivation, _trailingStopOffset)   f_init Initialize the backtest data type. Called prior to using the backtester functions   Parameters:      data (backtesterData) : backtesterData to initialize      _defaultStopLoss (float) : Default trade stop loss to apply      _defaultTakeProfit (float) : Default trade take profit to apply      _useTrailingStop (bool) : Trailing stop enabled      _useTraingStopToBreakEven (bool) : When trailing stop active, trailing stop will increase no further than the entry price      _trailingStopActivation (int) : When trailing stop active, trailing will begin once price exceeds base stop loss by this number of points      _trailingStopOffset (int) : When trailing stop active, it will trail the max price achieved by this number of points   Returns: Initialized data set f_buildResultStr(_resultType, _price, _resultPoints, _numWins, _pointsWon, _numLoss, _pointsLost)   f_buildResultStr Helper function to construct a string of resutling data for exit tooltip labels   Parameters:      _resultType (string)      _price (float)      _resultPoints (float)      _numWins (int)      _pointsWon (float)      _numLoss (int)      _pointsLost (float) f_buildResultLabel(data, labelVertical, labelOffset, long)   f_buildResultLabel Helper function to construct an Exit label for display on the chart   Parameters:      data (backtesterData)      labelVertical (bool)      labelOffset (int)      long (bool) f_updateTrailingStop(_entryPrice, _curPrice, _sl, _tp, trailingStopActivationInput, trailingStopOffsetInput, useTrailingStopToBreakEven)   f_updateTrailingStop Helper function to advance the trailing stop as price action dictates   Parameters:      _entryPrice (float)      _curPrice (float)      _sl (float)      _tp (float)      trailingStopActivationInput (float)      trailingStopOffsetInput (float)      useTrailingStopToBreakEven (bool)   Returns: Updated stop loss for current price action f_enterShort(data, entryPrice, fixedStopLoss)   f_enterShort Helper function to enter a short and collect data necessary for tracking the trade entry   Parameters:      data (backtesterData)      entryPrice (float)      fixedStopLoss (float)   Returns: Updated backtest data f_enterLong(data, entryPrice, fixedStopLoss)   f_enterLong Helper function to enter a long and collect data necessary for tracking the trade entry   Parameters:      data (backtesterData)      entryPrice (float)      fixedStopLoss (float)   Returns: Updated backtest data f_exitTrade(data)   f_enterLong Helper function to exit a trade and update/reset tracking data   Parameters:      data (backtesterData)   Returns: Updated backtest data f_checkTradeConditionForExit(data, condition, curPrice, enableRealTime)   f_checkTradeConditionForExit Helper function to determine if provided condition indicates an exit   Parameters:      data (backtesterData)      condition (bool) : When true trade will exit      curPrice (float)      enableRealTime (bool) : When true trade will evaluate if barstate is relatime or barstate is confirmed; otherwise just checks on is confirmed   Returns: Updated backtest data f_checkTrade(data, curPrice, curLow, curHigh, enableRealTime)   f_checkTrade Helper function to determine if current price action dictates stop loss or take profit exit   Parameters:      data (backtesterData)      curPrice (float)      curLow (float)      curHigh (float)      enableRealTime (bool) : When true trade will evaluate if barstate is relatime or barstate is confirmed; otherwise just checks on is confirmed   Returns: Updated backtest data f_fillCell(_table, _column, _row, _title, _value, _bgcolor, _txtcolor, _text_size)   f_fillCell Helper function to construct result table cells   Parameters:      _table (table)      _column (int)      _row (int)      _title (string)      _value (string)      _bgcolor (color)      _txtcolor (color)      _text_size (string)   Returns: Table cell f_prepareStatsTable(data, drawTesterSummary, drawTesterDetails, summaryTableTextSize, detailsTableTextSize, displayRowZero, summaryTableLocation, detailsTableLocation)   f_fillCell Helper function to populate result table   Parameters:      data (backtesterData)      drawTesterSummary (bool)      drawTesterDetails (bool)      summaryTableTextSize (string)      detailsTableTextSize (string)      displayRowZero (bool)      summaryTableLocation (string)      detailsTableLocation (string)   Returns: Updated backtest data backtesterData   backtesterData - container for backtest performance metrics   Fields:      tradesArray (array) : Array of strings with entries for each individual trade and its results      pointsBalance (series float) : Running sum of backtest points won/loss results      drawDown (series float) : Running sum of backtest total draw down points      maxDrawDown (series float) : Running sum of backtest total draw down points      maxRunup (series float) : Running sum of max points won over the backtest      numWins (series int) : Number of wins of current backtes set      numLoss (series int) : Number of losses of current backtes set      pointsWon (series float) : Running sum of points won to date      pointsLost (series float) : Running sum of points lost to date      entrySide (series string) : Current entry long/short      tradeActive (series bool) : Indicates if a trade is currently active      tradeComplete (series bool) : Indicates if a trade just exited (due to stop loss or take profit)      entryPrice (series float) : Current trade entry price      entryTime (series int) : Current trade entry time      sl (series float) : Current trade stop loss      tp (series float) : Current trade take profit      defaultStopLoss (series float) : Default trade stop loss to apply      defaultTakeProfit (series float) : Default trade take profit to apply      useTrailingStop (series bool) : Trailing stop enabled      useTrailingStopToBreakEven (series bool) : When trailing stop active, trailing stop will increase no further than the entry price      trailingStopActivation (series int) : When trailing stop active, trailing will begin once price exceeds base stop loss by this number of points      trailingStopOffset (series int) : When trailing stop active, it will trail the max price achieved by this number of points      resultType (series string) : Current trade won/lost      exitPrice (series float) : Current trade exit price      resultPoints (series float) : Current trade points won/lost      summaryTable (series table) : Table to deisplay summary info      tradesTable (series table) : Table to display per trade info
Libreria Pine Script®
di BlueMagicTrading
position_toolLibrary "position_tool" Trying to turn TradingView's position tool into a library from which you can draw position tools for your strategies on the chart. Not sure if this is going to work calcBaseUnit()   Calculates the chart symbol's base unit of change in asset prices.   Returns: (float) A ticks or pips value of base units of change. calcOrderPipsOrTicks(orderSize, unit)   Converts the `orderSize` to ticks.   Parameters:      orderSize (float) : (series float) The order size to convert to ticks.      unit (simple float) : (simple float) The basic units of change in asset prices.   Returns: (int) A tick value based on a given order size. calcProfitLossSize(price, entryPrice, isLongPosition)   Calculates a difference between a `price` and the `entryPrice` in absolute terms.   Parameters:      price (float) : (series float) The price to calculate the difference from.      entryPrice (float) : (series float) The price of entry for the position.      isLongPosition (bool)   Returns: (float) The absolute price displacement of a price from an entry price. calcRiskRewardRatio(profitSize, lossSize)   Calculates a risk to reward ratio given the size of profit and loss.   Parameters:      profitSize (float) : (series float) The size of the profit in absolute terms.      lossSize (float) : (series float) The size of the loss in absolute terms.   Returns: (float) The ratio between the `profitSize` to the `lossSize` createPosition(entryPrice, entryTime, tpPrice, slPrice, entryColor, tpColor, slColor, textColor, showExtendRight)   Main function to create a position visualization with entry, TP, and SL   Parameters:      entryPrice (float) : (float) The entry price of the position      entryTime (int) : (int) The entry time of the position in bar_time format      tpPrice (float) : (float) The take profit price      slPrice (float) : (float) The stop loss price      entryColor (color) : (color) Color for entry line      tpColor (color) : (color) Color for take profit zone      slColor (color) : (color) Color for stop loss zone      textColor (color) : (color) Color for text labels      showExtendRight (bool) : (bool) Whether to extend lines to the right   Returns: (bool) Returns true when position is closed
Libreria Pine Script®
di k4sual
Commission-aware Trade LabelsCommission-aware Trade Labels Description: This library provides an easy way to visualize take-profit and stop-loss levels on your chart, taking into account trading commissions. The library calculates and displays the net profit or loss, along with other useful information such as risk/reward ratio, shares, and position size. Features: Configurable take-profit and stop-loss prices or percentages. Set entry amount or shares. Calculates and displays the risk/reward ratio. Shows net profit or loss, considering trading commissions. Customizable label appearance. Usage: Add the script to your chart. Create an Order object for take-profit and stop-loss with desired configurations. Call target_label() and stop_label() methods for each order object. Example: target_order = Order.new(take_profit_price=27483, stop_loss_price=28000, shares=0.2) stop_order = Order.new(stop_loss_price=29000, shares=1) target_order.target_label() stop_order.stop_label() This script is a powerful tool for visualizing your trading strategy's performance and helps you make better-informed decisions by considering trading commissions in your profit and loss calculations. Library "tradelabels" entry_price(this)   Parameters:      this : Order object @return entry_price take_profit_price(this)   Parameters:      this : Order object @return take_profit_price stop_loss_price(this)   Parameters:      this : Order object @return stop_loss_price is_long(this)   Parameters:      this : Order object @return entry_price is_short(this)   Parameters:      this : Order object @return entry_price percent_to_target(this, target)   Parameters:      this : Order object      target : Target price @return percent risk_reward(this)   Parameters:      this : Order object @return risk_reward_ratio shares(this)   Parameters:      this : Order object @return shares position_size(this)   Parameters:      this : Order object @return position_size commission_cost(this, target_price)   Parameters:      this : Order object @return commission_cost      target_price net_result(this, target_price)   Parameters:      this : Order object      target_price : The target price to calculate net result for (either take_profit_price or stop_loss_price) @return net_result create_take_profit_label(this, prefix, size, offset_x, bg_color, text_color)   Parameters:      this      prefix      size      offset_x      bg_color      text_color create_stop_loss_label(this, prefix, size, offset_x, bg_color, text_color)   Parameters:      this      prefix      size      offset_x      bg_color      text_color create_entry_label(this, prefix, size, offset_x, bg_color, text_color)   Parameters:      this      prefix      size      offset_x      bg_color      text_color create_line(this, target_price, line_color, offset_x, line_style, line_width, draw_entry_line)   Parameters:      this      target_price      line_color      offset_x      line_style      line_width      draw_entry_line Order   Order   Fields:      entry_price : Entry price      stop_loss_price : Stop loss price      stop_loss_percent : Stop loss percent, default 2%      take_profit_price : Take profit price      take_profit_percent : Take profit percent, default 6%      entry_amount : Entry amount, default 5000$      shares : Shares      commission : Commission, default 0.04%
Libreria Pine Script®
di bunulu
4