VWATR Stop-Loss BandsPurpose
The script provides an adaptive stop‑loss framework built from VWATR, it anchors protective levels to price extremes and scales them with both volatility and volume. The objective is to create stop‑loss zones that reflect real market intensity rather than arbitrary fixed distances.
How it works
The script computes true range, multiplies it by volume, and smooths both the volume‑weighted range and raw volume using the selected moving average, their ratio forms VWATR, a volatility measure normalized by traded volume. It then calculates the standard deviation of VWATR to capture volatility‑of‑volatility. Stop‑loss levels are constructed by offsetting the low and high by one VWATR, with additional layers created by adding or subtracting one to five standard deviations. The plots use strong colors for core levels and progressively lighter tones for outer layers, establishing a clear visual hierarchy.
Rationale
This structure gives the trader stop‑loss levels that adapt to changing market conditions, expanding during high‑energy phases and contracting during quiet periods, which reduces premature stop‑outs and aligns risk with actual volatility. The standard deviation layers provide a graded map of volatility stress, allowing the user to assess how far price must travel to breach increasingly extreme thresholds. The result is a stop‑loss system that is both reactive and context‑aware, offering more informed decision‑making than static offsets.
Indicateurs et stratégies
CCT [masterchi]CCT - Candle Continuation Theory
A visual tool for tracking Higher Timeframe (HTF) candle structure and virgin level breaks.
Features:
Side Panel HTF Candles
Displays HTF candles (default: 1H) in a compact panel to the right of your chart
Shows the last 5 completed HTF candles plus the current developing candle
Real-time countdown timer shows time remaining in current HTF bar
Virgin Level Detection
Automatically identifies "virgin" highs and lows from HTF candles
A level remains virgin until price touches it
When a candle CLOSES beyond a virgin level, it's marked as "broken"
Blue lines = broken virgin highs | Red lines = broken virgin lows
Note: Only levels from candles currently in the Side Panel are tracked - as older candles scroll out, their levels are no longer displayed
Dual Display
Broken levels shown on both the Side Panel and Main Chart
Lines stop 1 candle after the breaking candle (or extend with option)
Customization
Configurable HTF timeframe
Line style (Solid/Dashed/Dotted) and thickness
Full color control for Side Panel candles and broken levels
Toggle visibility for all elements
Use Case: Identify when price breaks through untested HTF levels - these breaks often lead to continuation or provide key areas for pullback entries.
SMI Trigger SystemSMI TRIGGER SYSTEM - DESCRIPTION
Overview
SMI Trigger System is a momentum oscillator that identifies trend changes and reversals using the Smoothed Stochastic Momentum Index (SMI). Features a color-changing line (green = bullish, red = bearish), cloud shading for momentum zones, and triangle markers that appear exactly when momentum flips.
What Makes It Unique:
Real-time color-changing momentum line
Cloud shading split at zero line
Triangle triggers at exact momentum flip points
Overbought/oversold limit lines
Built-in alerts for all key signals
Fully customizable appearance
Works on all timeframes
How to Use
THE DISPLAY
Green line/cloud: Bullish momentum
Red line/cloud: Bearish momentum
Above zero: Bulls in control
Below zero: Bears in control
Upper limit (+40): Overbought
Lower limit (-40): Oversold
SIGNALS
🟢 Green Triangle (▲) - Momentum flipping bullish. Buy signal, most powerful below zero.
🔴 Red Triangle (▼) - Momentum flipping bearish. Sell signal, most powerful above zero.
TRADING STRATEGIES
1. Trend Following
In uptrends: Only take green triangles, ignore red
In downtrends: Only take red triangles, ignore green
Use higher timeframe for trend, lower for entries
Example: Daily uptrend → trade green triangles on 1H chart
2. Limit Reversals
Red triangle at upper limit (+40) = strong reversal signal, go short
Green triangle at lower limit (-40) = strong reversal signal, go long
Wait for triangle AND price confirmation
Most reliable on 4H/Daily timeframes
3. Zero Line Trading
SMI crosses above zero → bullish bias, take green triangles
SMI crosses below zero → bearish bias, take red triangles
Zero acts as momentum baseline
4. Divergence Setups
Price higher high + SMI lower high = bearish divergence → take next red triangle
Price lower low + SMI higher low = bullish divergence → take next green triangle
Most powerful at overbought/oversold limits
ENTRIES & EXITS
Enter: On triangle appearance
Stop: Beyond recent opposite-color triangle
Target: Limit levels or opposite triangle
Add: Additional same-color triangles in strong trends
TIMEFRAME GUIDE
Scalping (1-5m): Lower %K to 3-4, take all trend-aligned triangles
Day trading (15-60m): Default settings (5/3), focus on limit reversals
Swing trading (4H-Daily): Higher %K to 7-10, trade only extreme readings
ADJUSTING SENSITIVITY
SMI %K Length (default: 5):
Lower (3-4) = More signals, faster - good for scalping
Higher (7-10) = Fewer signals, stronger - good for swing trading
SMI %D Length (default: 3):
Lower (1-2) = More responsive
Higher (5-7) = Smoother
ALERTS
Built-in alerts for:
Triangle appears (momentum flips)
SMI crosses zero (trend change)
SMI crosses limits (overbought/oversold)
Enable in settings, configure in TradingView alert dialog.
CUSTOMIZATION
Toggle cloud/triangles on/off
Adjust triangle size and positioning
Customize all colors
Triangle label cap prevents clutter
Key Settings
SMI %K Length (default: 5): Controls sensitivity and signal frequency
SMI %D Length (default: 3): Controls smoothing
SMI Limit (default: 40): Overbought/oversold threshold
Show SMI Cloud (default: ON): Cloud shading
Show SMI Flip Triangles (default: ON): Trigger markers
Triangle Size/Offset: Appearance customization
Enable Alerts (default: ON): Alert notifications
Key Features
✅ Color-changing momentum line
✅ Cloud shading for momentum zones
✅ Triangle triggers at exact flips
✅ Overbought/oversold limits
✅ Built-in alert system
✅ Fully customizable
✅ All timeframes
✅ Adjustable sensitivity
NPR21
Disclaimer
The information and publications are not meant to be, and do not constitute, financial, investment, trading, or other types of advice or recommendations supplied or endorsed by TradingView.
Rango y Apertura PersonalizadoThis indicator highlights the opening times, and also shows the highest and lowest point on that candle.
VAM Pro (Multi-Model) [Final]Volatility Adjusted Momentum (VAM) Pro+ is a professional quantitative tool designed to measure trend strength by normalizing momentum against market volatility. Standard momentum indicators often fail during high-volatility periods because they treat every price change the same regardless of market noise. This indicator solves that problem by scaling price changes based on their statistical significance using Z-Score logic. This Pro+ version is specifically optimized for Scalping and Intraday Trading by introducing advanced volatility estimators and mathematical horizon adjustments that superior to classic standard deviation models.
The indicator allows you to choose the most suitable volatility model for your specific asset class. The Parkinson Volatility model is highly recommended for Crypto markets because it uses the High-Low range instead of just close prices, effectively capturing intraday wicks and liquidation spikes that standard deviation often misses. For Equities and Forex, the Garman-Klass model is the most efficient choice as it utilizes the full Open-High-Low-Close data set to account for opening gaps and professional trading ranges.
The mathematical core of the script features a strict Horizon Adjustment based on the Square Root of Time rule. This aligns the one-bar volatility risk with your chosen momentum lookback period to ensure a mathematically consistent calculation. By default, the script uses Logarithmic Returns to maintain scale invariance, which is critical for assets with high percentage swings like Cryptocurrencies. To trade with VAM Pro, look for the histogram color and its relation to the Zero line. A Green histogram indicates positive volatility-adjusted momentum where bulls are dominant, while a Red histogram shows bearish dominance. Values reaching the +2.0 or -2.0 Sigma levels represent statistically extreme moves that often act as exhaustion points or precede strong mean-reversion opportunities. When the histogram crosses the yellow signal line, it provides an early warning that the current momentum is fading.
Investment involves risk. The Volatility Adjusted Momentum (VAM) Pro+ is an analytical tool and does not constitute financial advice, investment recommendations, or an offer to buy or sell any security. Past performance is not indicative of future results. Market conditions can change rapidly, and technical indicators may produce false signals. Always perform your own due diligence, use proper risk management, and consult with a certified financial advisor before making any trading decisions. The author assumes no responsibility for any financial losses incurred through the use of this script.
Options Liquidity Meter (OLM)❓ The question behind this indicator
When trading options, it is common to experience situations where price moves in the expected direction, yet the option contract does not increase in value as anticipated.
This typically happens when one or more of the following conditions is missing:
Insufficient liquidity participation
Lack of volatility expansion
Weak or passive order flow
Options Liquidity Meter (OLM) was created to address this specific question:
“If price moves from here, are there conditions for option premiums to actually expand?”
🎯 What this indicator does
Options Liquidity Meter is a context tool, not a trading system.
It evaluates whether the current market environment is favorable for option premium expansion , based on three core engines:
Liquidity (Relative Volume)
Measures whether price movement is supported by meaningful participation.
Volatility State
Identifies compression, release, and expansion phases, where options tend to respond differently.
Order Flow Activity (OBV-based)
Acts as a proxy for active vs. passive participation, helping filter hollow moves.
These components are combined into a single, easy-to-read options context.
🟢🟡🔴 Options Context Output
The indicator displays one consolidated state:
RED — NO EXPANSION
Price may move, but option premiums often do not respond.
YELLOW — BUILDING
Liquidity or volatility is developing. Conditions are improving but not fully aligned.
GREEN — EXPANSION LIKELY
Liquidity, volatility expansion, and active flow are aligned.
This is a favorable environment for option premium expansion.
The same logic is reflected visually through the background color and summarized in the dashboard.
📊 How to read the dashboard
The dashboard shows:
Liquidity: LOW / OK / HIGH
Volatility: COMPRESSED / RELEASED / EXPANDING
Order Flow: FLAT / ACTIVE
Options Context: NO EXPANSION / BUILDING / EXPANSION LIKELY
Below, a Background Color Meaning section explains what each color represents, making the indicator intuitive and educational.
📍 Where to apply this indicator
Options Liquidity Meter must be applied to the underlying asset chart, such as:
Indices (SPY, SPX, QQQ, etc.)
Stocks
Futures
ETFs
It is not designed to be applied to option contracts themselves.
The indicator evaluates the market conditions of the underlying, which are the drivers that influence option premium behavior.
Contract selection (strike, delta, gamma, expiration) remains the trader’s responsibility.
🧠 How to use it
Use your own methodology to define:
Direction
Structure
Entries and exits
Use Options Liquidity Meter to evaluate:
Whether the current environment supports option premium expansion
If the context is RED, be cautious — price may move without rewarding options.
If the context is GREEN, the environment is statistically more favorable for options responsiveness.
🔗 Complementary tools
Options Liquidity Meter is designed to complement, not replace, other tools.
It works well alongside:
Opening Path Selector (EMA200 Context Tool)
For deciding which asset offers the cleanest directional context.
Multi-Tool VWAP + EMAs (Multi-Timeframe) + Key Levels
For in-chart structure, bias, and reference levels.
Each tool addresses a different stage of the decision process and can be used independently.
⚠️ Important notes
This indicator provides context only
It does not generate trading signals
No indicator guarantees results
Use at your own risk.
BTC - DCA vs HODL Calculator MatrixBTC - DCA vs. HODL Calculator Matrix | RM
Overview
The BTC - DCA vs. HODL Calculator Matrix is a high-performance telemetry laboratory designed to settle the ultimate debate in Bitcoin accumulation: Is it more efficient to deploy all capital at once ( Lump Sum & HODL ) or utilize a recurring purchase strategy ( DCA )? More importantly, if DCA is the choice, which exact frequency and weekday provides the mathematical edge?
The Calculator Matrix was engineered to solve a critical limitation in the current script ecosystem (at least I couldnt find such an indicator): the inability to compare multiple DCA frequencies and specific calendar days simultaneously within a single dashboard. While developing this tool, I found that existing calculators typically only permit testing one strategy at a time (e.g., a generic "Weekly" buy). This script fills that gap by utilizing a high-performance array-based "Telemetry Engine" to rank dozens of variables—including every individual weekday and specific monthly dates—against a HODL benchmark in real-time. This unique simultaneous comparison allows investors to mathematically identify "Weekday Alpha" across any user-defined timeframe.
Core Philosophy
The script utilizes a Normalized Capital Model . To ensure a true "apples-to-apples" comparison, your total capital (e.g., $10,000) is distributed with mathematical precision across the exact number of entries for each specific strategy. This eliminates the ROI skewing commonly found in basic scripts, ensuring that every strategy is judged on the same total dollar expenditure over the same "Race Track."
Key Features & Analytics
• The Podium System: An automated ranking algorithm that awards 🥇 Gold, 🥈 Silver, and 🥉 Bronze medals to the top three performing strategies. Spoiler: Regular Winner: 1-time HODL (Lump Sum)
• Simultaneous Strategy Testing: Compare Daily, 7 different Weekly days (Mon-Sun), and Monthly dates (1st–28th) all at once.
• Risk Telemetry: Integrated Max Drawdown (MDD) sensors for every strategy, revealing the "Emotional Cost" of your accumulation path.
• Race Track Visuals: Blue dashed "Green Flag" and "Checkered Flag" lines visually define the boundaries of your backtest.
• Dashboard Customization: Use the "Odd/Even" filter to keep the matrix sleek and readable on (nearly) any screen resolution.
The Strategies Tested
• 1-TIME HODL: The benchmark (Lump sum entry on Day 1 - meaning all the capital is deployed at the start date).
• DAILY DCA: High-frequency, day-by-day accumulation (the capital is split amongst the different entries).
• WEEKLY (SUN-SAT): Evaluates which specific day of the week historically captures the best entries (e.g., "Weekend Dips").(The capital is split amongst the different entries).
• MONTHLY (1-28 + END): Tests monthly date performance to optimize for beginning-of-month or end-of-month cycles. (The capital is split amongst the different entries).
Monte Carlo Simulation & Python Research
While this tool allows you to manually check any specific timeframe, manual testing is limited by "Start Date Bias." To find the Universal Winner , I have conducted a Monte Carlo Simulation using 100 random entry dates over the last 5 years via Python/Colab. This research reveals the statistical probability of a day (like Saturday) winning the Gold medal across all market conditions.
Access the Python Heatmap Research in my substack article (link for substack in Bio).
How to Use
1. Set the Race Track: Input Start and End dates in the settings.
2. Fuel the Engine: Set your Total Capital ($).
3. Analyze the Matrix: Compare ROI vs. MAX DD. The goal is not just the highest return, but the best Risk-Adjusted return.
Technical Implementation
This script utilizes an array-based telemetry engine to handle the simultaneous calculation of 30+ independent investment strategies. To ensure computational efficiency and bypass the limitations of standard security-based backtesting, I implemented a custom-built accumulator logic using array.new_float() and array.set() . The core calculation loop ( if in_race and is_new_day ) processes capital deployment on a per-bar basis, utilizing ta.change(time("D")) to ensure entry synchronization with the Daily UTC close. By decoupling the unit accumulation ( u_weekly , u_monthly ) from the final valuation logic ( f_get_stats ), the script maintains a Normalized Capital Model. This ensures that even with complex comparative logic across varying frequencies, the script provides a mathematically rigorous, reproducible result that matches real-world execution at the Daily UTC Midnight close.
Note: All calculations are made on the "close" bar, which means UTC 00:00. By creating a strategy or using the research, make sure to be aware of your time zone
Disclaimer: Past performance is not indicative of future results. This tool is for educational and research purposes only. Rob Maths is not liable for any financial losses.
Tags:
robmaths, Rob Maths, DCA, HODL, Bitcoin, BTC, Backtest, RiskManagement, Investment, Strategy, Statistics
Buy / Sell Volume HeaderBuy / Sell Volume Header
Description
- Buy / Sell Volume Header displays real-time buying and selling volume with percentages in a clean dashboard at the top or bottom of your chart. The indicator calculates buying pressure as volume weighted toward the close relative to the bar's range, and selling pressure as volume weighted toward the high.
- Perfect for day traders and scalpers who need instant visual confirmation of buying vs selling pressure without cluttering their chart with additional panes.
Key Features:
- Real-time buy/sell volume split with percentages
- Customizable lookback period (1 bar for current, or sum multiple bars)
- Adjustable table position (top/bottom, left/center/right)
- Five size options (Tiny to Huge)
- Color-coded: Green (buying volume), Red (selling volume)
- Clean, minimal design that doesn't obstruct price action
Calculation Method:
- Buying Volume = Total Volume × (Close - Low) / (High - Low)
- Selling Volume = Total Volume × (High - Close) / (High - Low)
How to Use:
- Select header location (default: Top Right) and table size (default: Normal). Set lookback period to 1 for current bar only, or higher values to see cumulative volume over multiple bars.
Reading the Display:
- Green Box (Left): Buying volume and percentage of total
- Red Box (Right): Selling volume and percentage of total
- Numbers update in real-time on every tick
Trading Applications:
- Trend Confirmation:
- In uptrends, buying volume should consistently be >60%.
- In downtrends, selling volume should be >60%. Divergences warn of potential reversals.
Breakout Validation:
- Valid breakouts show 70%+ volume in breakout direction.
- Breakouts with <55% directional volume often fail.
Reversal Signals:
- When price makes new high but buying volume drops below 50%, watch for reversal. When price makes new low but selling volume drops below 50%, watch for bounce.
Scalping Entry:
- Enter long when buying volume spikes above 65-70% with price momentum. Enter short when selling volume spikes above 65-70% with price momentum.
Best Practices:
- Use lookback=1 for intraday scalping. Use lookback=3-5 for swing context. Combine with price action for confirmation. Volume percentages work best on liquid instruments (MNQ, MES, stocks with high volume).
NPR21
Disclaimer
The information and publications are not meant to be, and do not constitute, financial, investment, trading, or other types of advice or recommendations supplied or endorsed by TradingView.
52W High / Low + 20% Retracement52-Week High / Low with 20% Retracement Level
This indicator provides a visual context for momentum and drawdown
analysis using 52-week price extremes.
What it shows:
- The 52-week high and 52-week low levels.
- A retracement level defined as a fixed percentage (default 20%)
below the 52-week high.
How to interpret it:
- Price above the retracement level indicates that the stock has
corrected in a controlled manner and the broader momentum structure
is still intact.
- Price below the retracement level suggests a deeper drawdown and
potential deterioration of momentum.
Intended use:
- Designed as a quality filter, not as an entry or exit signal.
- Helps identify stocks with strong momentum that are consolidating
rather than breaking down.
- Should be combined with trend and liquidity filters.
Notes:
- The retracement percentage is adjustable.
- This indicator is descriptive, not predictive.
- It does not replace risk management or stop-loss rules.
*/
Super DCA (DEMO)Spot Trading Signal Indicator with Priority-Based DCA Strategy
This indicator is designed for spot trading with a Dollar Cost Averaging (DCA) approach. It generates buy signals with 5 priority levels, allowing you to build your position gradually with multiple orders.
lib_ephemeris █ PLANETARY EPHEMERIS MASTER LIBRARY
Unified API for calculating planetary positions. Import this single library to access all 11 celestial bodies: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Theory: VSOP87 (planets), ELP2000-82 (Moon), Meeus (Pluto)
═══════════════════════════════════════════════════════════════
█ QUICK START
//@version=6
indicator("Planetary Ephemeris Demo")
import BlueprintResearch/lib_ephemeris/1 as eph
// Get all planets
sun = eph.string_to_planet("Sun")
moon = eph.string_to_planet("Moon")
mercury = eph.string_to_planet("Mercury")
venus = eph.string_to_planet("Venus")
mars = eph.string_to_planet("Mars")
jupiter = eph.string_to_planet("Jupiter")
saturn = eph.string_to_planet("Saturn")
uranus = eph.string_to_planet("Uranus")
neptune = eph.string_to_planet("Neptune")
pluto = eph.string_to_planet("Pluto")
// Get longitude for each planet (geocentric)
sun_lon = eph.get_longitude(sun, time, true)
moon_lon = eph.get_longitude(moon, time, true)
mercury_lon = eph.get_longitude(mercury, time, true)
venus_lon = eph.get_longitude(venus, time, true)
mars_lon = eph.get_longitude(mars, time, true)
jupiter_lon = eph.get_longitude(jupiter, time, true)
saturn_lon = eph.get_longitude(saturn, time, true)
uranus_lon = eph.get_longitude(uranus, time, true)
neptune_lon = eph.get_longitude(neptune, time, true)
pluto_lon = eph.get_longitude(pluto, time, true)
// Plot all planets
plot(sun_lon, "Sun", color.yellow)
plot(moon_lon, "Moon", color.silver)
plot(mercury_lon, "Mercury", color.orange)
plot(venus_lon, "Venus", color.green)
plot(mars_lon, "Mars", color.red)
plot(jupiter_lon, "Jupiter", color.purple)
plot(saturn_lon, "Saturn", color.olive)
plot(uranus_lon, "Uranus", color.aqua)
plot(neptune_lon, "Neptune", color.blue)
plot(pluto_lon, "Pluto", color.gray)
═══════════════════════════════════════════════════════════════
█ AVAILABLE FUNCTIONS
Core Data Access:
• string_to_planet(string) → Planet enum
• get_longitude(Planet, time, preferGeo) → degrees [0, 360)
• get_declination(Planet, time) → degrees
• get_speed(Planet, time) → degrees/day
• is_retrograde(Planet, time) → true/false
Planetary Averages:
• get_avg6_geo_lon(time) → 6 outer planets average
• get_avg6_helio_lon(time)
• get_avg8_geo_lon(time) → 8 classical planets average
• get_avg8_helio_lon(time)
Utility:
• normalizeLongitude(lon) → normalize to [0, 360)
═══════════════════════════════════════════════════════════════
█ SUPPORTED PLANET STRINGS
Works with symbols or plain names (case-insensitive):
• "☉︎ Sun" or "Sun"
• "☽︎ Moon" or "Moon"
• "☿ Mercury" or "Mercury"
• "♀ Venus" or "Venus"
• "🜨 Earth" or "Earth"
• "♂ Mars" or "Mars"
• "♃ Jupiter" or "Jupiter"
• "♄ Saturn" or "Saturn"
• "⛢ Uranus" or "Uranus"
• "♆ Neptune" or "Neptune"
• "♇ Pluto" or "Pluto"
═══════════════════════════════════════════════════════════════
█ COORDINATE SYSTEMS
Geocentric: Positions relative to Earth (default for Sun/Moon)
Heliocentric: Positions relative to the Sun
Use the preferGeo parameter in get_longitude():
• true = geocentric
• false = heliocentric
Sun and Moon always return geocentric (heliocentric not applicable).
═══════════════════════════════════════════════════════════════
█ FUTURE PROJECTIONS
Project planetary positions into the future using polylines:
import BlueprintResearch/lib_vsop_core/1 as core
// Get future timestamp (250 bars ahead)
future_time = core.get_future_time(time, 250)
// Calculate future position
future_lon = eph.get_longitude(mars, future_time, true)
Use with polyline.new() to draw projected paths on your chart. See the commented showcase code in this library's source for a complete 250-bar projection example.
═══════════════════════════════════════════════════════════════
█ OPEN SOURCE
This library is part of an open-source planetary ephemeris project.
Free to use with attribution. MIT License.
═══════════════════════════════════════════════════════════════
█ REFERENCES
• Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
• Bretagnon & Francou. "VSOP87 Solutions" (1988)
• Chapront-Touzé & Chapront. "ELP2000-82" (1983)
═══════════════════════════════════════════════════════════════
© 2025 BlueprintResearch (Javonnii) • MIT License
@version=6
normalizeLongitude(lon)
Normalizes any longitude value to the range [0, 360) degrees.
Parameters:
lon (float) : (float) Longitude in degrees (can be any value, including negative or >360).
Returns: (float) Normalized longitude in range [0, 360).
string_to_planet(planetStr)
Converts a planet string identifier to Planet enum value.
Parameters:
planetStr (string) : (string) Planet name (case-insensitive). Supports formats: "Sun", "☉︎ Sun", "sun", "SUN"
Returns: (Planet) Corresponding Planet enum. Returns Planet.Sun if string not recognized.
@note Supported planet strings: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto
get_longitude(p, t, preferGeo)
Returns planetary longitude with automatic coordinate system selection.
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
preferGeo (bool) : (bool) If true, return geocentric; if false, return heliocentric.
Returns: (float) Longitude in degrees, normalized to range [0, 360).
@note Sun and Moon always return geocentric regardless of preference (heliocentric not applicable).
get_declination(p, t)
Returns planetary geocentric equatorial declination.
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
Returns: (float) Geocentric declination in degrees, range where positive is north.
@note Declination is always geocentric (no heliocentric equivalent in library).
get_speed(p, t)
Returns planetary geocentric longitude speed (rate of change).
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion. Returns na for Moon.
@note Speed is always geocentric (no heliocentric equivalent in library). Moon speed calculation not implemented.
get_avg6_geo_lon(t)
get_avg6_geo_lon
@description Returns the arithmetic average of the geocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average geocentric longitude of the six outer planets in degrees, range [0, 360).
get_avg6_helio_lon(t)
get_avg6_helio_lon
@description Returns the arithmetic average of the heliocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average heliocentric longitude of the six outer planets in degrees, range [0, 360).
get_avg8_geo_lon(t)
get_avg8_geo_lon
@description Returns the arithmetic average of the geocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average geocentric longitude of all eight classical planets in degrees, range [0, 360).
get_avg8_helio_lon(t)
get_avg8_helio_lon
@description Returns the arithmetic average of the heliocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average heliocentric longitude of all eight classical planets in degrees, range [0, 360).
is_retrograde(p, t)
Returns true if the planet is currently in retrograde motion (geocentric speed < 0) == 0 = stationary.
Parameters:
p (series Planet) : The planet to check.
t (float) : Time in Unix timestamp (milliseconds).
Returns: true if the planet is in retrograde, false otherwise.
lib_vsop87_mercuryLibrary "lib_vsop87_mercury"
Heliocentric and geocentric position calculations for Mercury
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Mercury data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Mercury's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Mercury's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Mercury's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.31-0.47 AU.
get_geo_speed(t)
Computes Mercury's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Mercury's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Mercury's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Mercury's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
lib_vsop87_venusLibrary "lib_vsop87_venus"
Heliocentric and geocentric position calculations for Venus
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Venus data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Venus's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Venus's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Venus's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.72-0.73 AU.
get_geo_speed(t)
Computes Venus's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Venus's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Venus's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Venus's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
lib_elp2000_moonLibrary "lib_elp2000_moon"
get_geo_ecl_lon(T)
Parameters:
T (float)
get_geo_ecl_lat(T)
Parameters:
T (float)
get_obliquity(T)
Parameters:
T (float)
get_declination(T)
Parameters:
T (float)
get_true_node_lon(T)
Parameters:
T (float)
get_true_south_node_lon(T)
Parameters:
T (float)
get_node_declination(T)
Parameters:
T (float)
get_south_node_declination(T)
Parameters:
T (float)
lib_vsop87_marsLibrary "lib_vsop87_mars"
get_helio_lon(t)
Computes Mars's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Mars's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Mars's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 1.38-1.67 AU.
get_geo_speed(t)
Computes Mars's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Mars's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Mars's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Mars's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
FTI CycleCounter_V2_2512_28This indicator provides keeps track of the momentum in either direction and keeps track of the time it takes to complete the cycle in either direction. This will indicate when a new cycle to the upside or to the downside is about to start. You may use this for booking profits and switching your trade in the other direction. Besides that it will also indicate the angle of ascent/descent and also when the price is likely to go sideways
lib_vsop87_jupiterLibrary "lib_vsop87_jupiter"
get_helio_lon(t)
Computes Jupiter's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Jupiter's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Jupiter's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 4.95-5.46 AU.
get_geo_speed(t)
Computes Jupiter's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Jupiter's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Jupiter's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Jupiter's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
SNIPER Trend Continuation V1TC SNIPER (Trend Continuation)
### When to Use
- Market is **OUT OF BALANCE** (trending, momentum)
- Clear **displacement** away from prior value
- **New York session** (AVOID London open fakeouts!)
- Strong directional moves with follow-through
### The Setup Sequence
```
1. IMPULSE DETECTED
└── Strong directional move (2× ATR+)
└── Multiple momentum bars
└── Price above/below fast EMA
2. LVN ZONE IDENTIFIED
└── 23.6% - 61.8% Fibonacci retracement
└── Low volume pullback area
3. PRICE PULLS BACK TO LVN
└── Retraces into the zone
└── Volume decreases (exhaustion)
4. AGGRESSION CONFIRMATION
└── Entry candle in trend direction
└── Volume spikes (1.3×+ average)
└── Fat body, minimal adverse wick
└── EMA alignment confirms trend
5. ENTRY → TARGET: PREV POC
```
lib_vsop87_saturnLibrary "lib_vsop87_saturn"
get_helio_lon(t)
Computes Saturn's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Saturn's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Saturn's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 9.02-10.05 AU.
get_geo_speed(t)
Computes Saturn's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Saturn's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Saturn's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Saturn's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
lib_vsop87_uranusLibrary "lib_vsop87_uranus"
Heliocentric and geocentric position calculations for Uranus
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Uranus data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Uranus's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Uranus's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Uranus's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 18.28-20.09 AU.
get_geo_speed(t)
Computes Uranus's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Uranus's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Uranus's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Uranus's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
Ocean's Zero-Point [Pro]Ocean's Zero-Point – The Physics of Market Tension
Stop chasing price. Start trading the snap.
Ocean's Zero-Point is a next-generation oscillator designed for precision mean-reversion trading. Unlike standard RSI or Stochastic indicators that rely on lagging momentum averages, this tool measures Market Tension, the statistical distance between price and its "Fair Value."
It doesn't just tell you if the market is moving; it tells you how "stretched" the rubber band is and the exact moment it's about to snap back.
🌊 Key Features
The Zero-Point Engine (Statistical Tension) - Markets are elastic. They expand and contract around a mean. Standard indicators fail because they don't account for volatility. This engine uses a normalized Z-Score Algorithm to calculate exactly how many Standard Deviations price has moved away from the baseline.
The Logic: When the wave hits +2.0 or -2.0, the market is statistically overextended (the rubber band is fully stretched).
Result: You identify true extremes, filtering out weak fluctuations.
Zero-Lag Baseline (HMA) - To find the "Zero Point" (Fair Value), precision is key.
Standard Indicators: Use SMA or EMA, which lag behind price.
This Tool: Uses the Hull Moving Average (HMA).
Result: The baseline reacts almost instantly to price changes, ensuring the tension reading is always synchronized with the current market tick.
Liquid Flow Visualization - Designed for instant readability. The indicator uses a dynamic Liquid Gradient system to visualize market energy.
Gold Energy (Bottom): Deep oversold tension. Represents "Discount" zones and potential bullish reversals.
Sky Blue Energy (Top): Peak bullish tension. Represents "Premium" zones and potential bearish reversals.
Liquid Glow: Fills the area between the wave and the zero line, allowing you to gauge momentum density at a glance.
Fractal Pivot Detection (Internal Logic) - The engine continuously scans for fractal pivot points within the tension wave to identify structural turning points in real-time.
⚙️ Settings & Customization
Tension Length: Controls the lookback period for the Fair Value baseline.
Snap Sensitivity: Adjusts the Standard Deviation threshold (Mult). Higher values = Rarer, stronger signals. Lower values = More frequent scalping signals.
Visuals: Fully customizable "Bullish Energy" (Sky Blue) and "Bearish Energy" (Gold) colors.
lib_vsop87_neptuneLibrary "lib_vsop87_neptune"
Heliocentric and geocentric position calculations for Neptune
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Neptune data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Neptune's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Neptune's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Neptune's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 29.81-30.33 AU.
get_geo_speed(t)
Computes Neptune's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Neptune's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Neptune's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Neptune's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
lib_meeus_plutoLibrary "lib_meeus_pluto"
Heliocentric and geocentric position calculations for Pluto using
Meeus truncated analytical series. Valid ±1 century from J2000.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory Meeus truncated series (not full planetary theory)
@accuracy Arcminute precision within ±1 century of J2000
@time_scale Julian centuries from J2000.0 (use core.get_julian_centuries)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998), Chapter 37
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Pluto data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Pluto's heliocentric ecliptic longitude using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). Accurate within ±1 century from J2000.
get_helio_lat(t)
Computes Pluto's heliocentric ecliptic latitude using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric ecliptic latitude in degrees, range approximately . Accurate within ±1 century from J2000.
get_helio_radius(t)
Computes Pluto's heliocentric radius (distance from Sun) using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 29.6-49.3 AU. Accurate within ±1 century from J2000.
get_geo_lon(t)
Computes Pluto's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Pluto's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Pluto's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
get_geo_speed(t)
Computes Pluto's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
