How to Use Percentage Inputs in TradingView Pine Script?

Introduction to Percentage Inputs in Pine Script

As experienced Pine Script developers, we often need flexible ways to control our indicators and strategies. Percentage inputs provide a user-friendly method for adjusting parameters relative to a whole, enhancing customization and adaptability. This article explores the nuances of percentage inputs in Pine Script, offering practical examples and best practices.

What are Percentage Inputs?

Percentage inputs are numerical inputs that represent a value as a percentage of a whole. In Pine Script, these are typically implemented using the input.float function, with constraints to ensure the input remains within a 0-100 range, representing 0% to 100%.

Why Use Percentage Inputs in TradingView?

Percentage inputs enhance user experience by providing an intuitive way to adjust parameters. For instance, setting a stop-loss level as a percentage below the entry price is more understandable than specifying an arbitrary numerical offset. They make it easier for traders to quickly configure strategies based on relative values rather than absolute values, which may need adjustment across different instruments.

Benefits of Using Percentage Inputs

• Intuitive Configuration: Traders can easily understand and modify parameters as percentages.
• Adaptability: Strategies can automatically adjust to different price levels or market conditions.
• Simplified Optimization: Percentage-based parameters often generalize better across different symbols during backtesting and optimization.

Implementing Percentage Inputs with ‘input.float’

Basic Syntax and Usage

The input.float function is the cornerstone of creating percentage inputs. Here’s the basic syntax:

//@version=5
indicator("Percentage Input Example", overlay=true)

percentage_value = input.float(defval=50, title="Percentage Value", minval=0, maxval=100, step=0.1)

plot(percentage_value)

• defval: Sets the default percentage value.
• title: Provides a descriptive label for the input in the indicator settings.
• minval and maxval: Restrict the input range to 0 and 100, ensuring it remains a percentage.
• step: Determines the increment for value changes (e.g., 0.1 for finer adjustments).

Setting Default Values and Ranges

Choosing appropriate default values and ranges is critical. A default value of 50 often makes sense as a neutral starting point. The minval and maxval parameters are vital for enforcing the percentage constraint. Consider the implications of allowing very small or very large percentage values on your calculations.

Applying Percentage Inputs to Calculations

To use the percentage input, you typically divide it by 100 to convert it into a decimal representation. This decimal can then be used in calculations.

//@version=5
indicator("Percentage Calculation Example", overlay=true)

percentage = input.float(defval=10, title="Percentage", minval=0, maxval=100) / 100
close_offset = close * percentage

plot(close + close_offset)

In this example, the close_offset is calculated as a percentage of the closing price and added to the closing price for plotting.

Advanced Techniques for Percentage Inputs

Combining Percentage Inputs with Other Input Types

Percentage inputs can be combined with other input types (e.g., integers, booleans, enums) to create highly configurable indicators and strategies. For instance, you might use a percentage input to define the risk per trade and an integer input to specify the maximum number of open trades.

Creating Dynamic Strategies Based on Percentage Changes

Strategies can be designed to react to percentage changes in price or other indicators. This allows for creating adaptive systems that respond to market volatility.

Using Percentage Inputs to Define Stop Loss and Take Profit Levels

A common use case is to define stop-loss and take-profit levels as percentages of the entry price or ATR (Average True Range). This allows the strategy to dynamically adjust to price volatility.

Practical Examples and Use Cases

Example 1: Percentage-Based Moving Average

This example calculates a moving average where the period is determined by a percentage of a fixed lookback period.

//@version=5
indicator("Percentage-Based Moving Average", overlay=true)

lookback = input.int(100, title="Lookback Period")
percentage = input.float(50, title="Percentage of Lookback", minval=1, maxval=100) / 100

period = round(lookback * percentage)
sma_value = ta.sma(close, period)

plot(sma_value, title="Percentage SMA")

Example 2: Dynamic Position Sizing with Percentage Risk

This example shows how to size positions based on a percentage of your capital at risk.

//@version=5
strategy("Dynamic Position Sizing", overlay=true)

capital = input.float(10000, title="Starting Capital")
risk_percentage = input.float(1, title="Risk Percentage per Trade", minval=0.1, maxval=5) / 100

atr_length = input.int(14, title="ATR Length")
atr = ta.atr(atr_length)

risk_amount = capital * risk_percentage
position_size = floor(risk_amount / atr)

if (ta.crossover(close, ta.sma(close, 20)))
    strategy.entry("Long", strategy.long, qty=position_size)

if (ta.crossunder(close, ta.sma(close, 20)))
    strategy.close("Long")

Example 3: ATR-Based Stop Loss with Percentage Multiplier

Here, the stop loss is placed at a multiple of the ATR, where the multiple is controlled by a percentage input.

//@version=5
strategy("ATR Stop Loss", overlay=true)

atr_length = input.int(14, title="ATR Length")
atr_multiplier = input.float(2, title="ATR Multiplier", minval=0.5, maxval=5)

longStopPrice = close - atr_multiplier * ta.atr(atr_length)

if (ta.crossover(close, ta.sma(close, 20)))
    strategy.entry("Long", strategy.long)

strategy.exit("Stop Loss", "Long", stop=longStopPrice)

Troubleshooting and Best Practices

Common Errors and How to Avoid Them

• Forgetting to Divide by 100: A common mistake is to use the percentage input directly without converting it to a decimal. Always divide by 100 before using it in calculations.
• Incorrect Range: Ensure minval and maxval are set correctly to enforce the percentage constraint.
• Type Mismatches: Be mindful of data types when performing calculations. Use float() or int() to convert values as needed.

Tips for Effective Percentage Input Management

• Descriptive Titles: Use clear and descriptive titles for your percentage inputs.
• Reasonable Default Values: Choose default values that make sense for the intended use case.
• Input Validation: Consider adding additional validation to handle edge cases, such as extremely small or large percentage values that might cause issues in your calculations.

Optimizing Performance with Percentage Inputs

Percentage inputs themselves don’t typically introduce performance bottlenecks. However, be mindful of the calculations they are used in. Optimize those calculations to ensure efficient execution, especially within backtesting loops. Consider using built-in Pine Script functions whenever possible, as they are often optimized for performance.