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.
Penunjuk dan strategi
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.
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.
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.
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).
lib_vsop_coreLibrary "lib_vsop_core"
Foundation library providing core types, evaluators, and utilities
for VSOP87 planetary theory calculations. Required by all planetary
libraries. Includes Earth heliocentric model and Sun geocentric functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87 (Variations Séculaires des Orbites Planétaires)
@accuracy Truncated series - suitable for financial astrology and education
@time_scale Julian millennia from J2000.0 for VSOP87 planets
Julian centuries from J2000.0 for Moon and Pluto
@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 Sun/Earth 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
get_julian_millennia(time_)
Parameters:
time_ (float)
get_julian_centuries(time_)
Parameters:
time_ (float)
eval_vsop87(terms, t)
Parameters:
terms (array)
t (float)
eval_vsop87_derivative(terms, t)
Parameters:
terms (array)
t (float)
mod360(x)
Parameters:
x (float)
custom_atan2(y, x)
Parameters:
y (float)
x (float)
get_earth_helio_radius(t)
Parameters:
t (float)
get_earth_helio_coords(t)
Parameters:
t (float)
get_obliquity(t)
Parameters:
t (float)
get_earth_helio_lon(t)
Parameters:
t (float)
get_sun_geo_lon(t)
Parameters:
t (float)
get_sun_geo_speed(t)
Parameters:
t (float)
get_sun_decl(t)
Parameters:
t (float)
get_bar_gap_ms()
Get bar interval in milliseconds for current timeframe
Returns: (int) Time interval between bars in milliseconds
get_future_time(current_time, bars_ahead)
Calculate future timestamp for projection plotting
Parameters:
current_time (int) : (int) Current bar time in milliseconds (use built-in 'time')
bars_ahead (int) : (int) Number of bars to project into future
Returns: (int) Future timestamp suitable for xloc.bar_time and chart.point.from_time
is_projection_bar()
Check if current bar is suitable for drawing future projections
Returns: (bool) True on last bar when projections should be drawn
vsop_term
Fields:
amp (series float)
phase (series float)
freq (series float)
MK_FractalLibrary "MK_Fractal"
ResCal(price, degree)
Parameters:
price (float)
degree (float)
SupCal(price, degree)
Parameters:
price (float)
degree (float)
CalcAllLevels(price)
Parameters:
price (float)
FindNearestLevel(current_price, resistances, supports)
Parameters:
current_price (float)
resistances (array)
supports (array)
IsTouchSupport(current_price, supports, tolerance_pct)
Parameters:
current_price (float)
supports (array)
tolerance_pct (float)
IsTouchResistance(current_price, resistances, tolerance_pct)
Parameters:
current_price (float)
resistances (array)
tolerance_pct (float)
GetLevelByDegree(price, degree)
Parameters:
price (float)
degree (float)
GetFormattedLevels(price)
Parameters:
price (float)
OrderlyWebhookJSONLibrary "OrderlyWebhookJSON"
Orderly 거래소 자동 거래를 위한 JSON Webhook 메시지 생성 라이브러리. Market/Limit 주문, TP/SL 설정, Percent/Absolute 수량 지정 등을 지원합니다.
createMarketOrder(symbol, leverage, side, position, quantity_type, quantity, tp_type, tp_value, sl_type, sl_value)
Market 주문 JSON 생성 (TP/SL 포함)
Parameters:
symbol (string) : 거래 심볼 (예: "BTCUSDT")
leverage (float) : 레버리지 배율 (예: 10)
side (string) : "Long" 또는 "Short"
position (string) : "Open" 또는 "Close"
quantity_type (string) : "Percent" 또는 "Absolute"
quantity (float) : 수량 값 (Percent인 경우 0-100, Absolute인 경우 실제 수량)
tp_type (string) : "percent" 또는 "price"
tp_value (float) : TP 값 (percent인 경우 퍼센트, price인 경우 절대가격)
sl_type (string) : "percent" 또는 "price"
sl_value (float) : SL 값 (percent인 경우 퍼센트, price인 경우 절대가격)
Returns: JSON 형식 문자열
createLimitOrder(symbol, leverage, side, position, limit_price, quantity_type, quantity, tp_type, tp_value, sl_type, sl_value)
Limit 주문 JSON 생성 (TP/SL 포함)
Parameters:
symbol (string) : 거래 심볼 (예: "BTCUSDT")
leverage (float) : 레버리지 배율 (예: 10)
side (string) : "Long" 또는 "Short"
position (string) : "Open" 또는 "Close"
limit_price (float) : Limit 주문 가격
quantity_type (string) : "Percent" 또는 "Absolute"
quantity (float) : 수량 값 (Percent인 경우 0-100, Absolute인 경우 실제 수량)
tp_type (string) : "percent" 또는 "price"
tp_value (float) : TP 값 (percent인 경우 퍼센트, price인 경우 절대가격)
sl_type (string) : "percent" 또는 "price"
sl_value (float) : SL 값 (percent인 경우 퍼센트, price인 경우 절대가격)
Returns: JSON 형식 문자열
createSimpleMarketOrder(symbol, leverage, side, position, quantity_type, quantity)
Market 주문 JSON 생성 (TP/SL 없음 - 간단 버전)
Parameters:
symbol (string) : 거래 심볼 (예: "BTCUSDT")
leverage (float) : 레버리지 배율 (예: 10)
side (string) : "Long" 또는 "Short"
position (string) : "Open" 또는 "Close"
quantity_type (string) : "Percent" 또는 "Absolute"
quantity (float) : 수량 값
Returns: JSON 형식 문자열
createSimpleLimitOrder(symbol, leverage, side, position, limit_price, quantity_type, quantity)
Limit 주문 JSON 생성 (TP/SL 없음 - 간단 버전)
Parameters:
symbol (string) : 거래 심볼 (예: "BTCUSDT")
leverage (float) : 레버리지 배율 (예: 10)
side (string) : "Long" 또는 "Short"
position (string) : "Open" 또는 "Close"
limit_price (float) : Limit 주문 가격
quantity_type (string) : "Percent" 또는 "Absolute"
quantity (float) : 수량 값
Returns: JSON 형식 문자열
createClosePosition(symbol, side, quantity_type, quantity)
포지션 종료 전용 JSON 생성
Parameters:
symbol (string) : 거래 심볼 (예: "BTCUSDT")
side (string) : "Long" 또는 "Short" (종료할 포지션의 반대 방향)
quantity_type (string) : "Percent" 또는 "Absolute"
quantity (float) : 수량 값 (Percent 100 = 전체 종료)
Returns: JSON 형식 문자열
TradingSystems_AlphaLib_v1_FinalLibrary "TradingSystems_AlphaLib_v1_Final"
Master Library for Institutional Analysis v1
@author jmcanovelles
calc_ema(len)
Calculates standardized EMA
Parameters:
len (simple int)
calc_adx(len)
Calculates precise ADX and DI
Parameters:
len (simple int)
TradingSystems_AlphaLib_v6//@version=6
// @description Master Library for Institutional Grade Analysis v1
// @author jmcanovelles
library("TradingSystems_AlphaLib_v6")
// @function Calculates standardized EMA
// @param len Period for the average
export calc_ema(int len) =>
ta.ema(close, len)
// @function Calculates precise ADX and DI
// @param len Calculation period
export calc_adx(int len) =>
= ta.dmi(len, len)
PrimeFib_constants_v1Library "PrimeFib_constants_v1"
PrimeFib / GoldenWhirl constants (Pine Library). Versioning is handled via TradingView publish versions.
GOLDEN_RATIO()
GOLDEN_RATIO_INV()
PI()
INV_PI()
PHI_SPIRAL()
PHI7()
PHI7_INV()
PSI_PF()
PSI_PF_INV()
LAMBDA_PF()
RHO_PF_THEO()
RHO_BTC_EMP()
RHO_CME_EMP()
RHO_PF_EMP()
RHOT()
OKXJsonLibrary "OKXJson"
f_buildId(prefix, instrument)
Parameters:
prefix (string)
instrument (string)
f_utcTimestamp()
f_investmentType(internalAction, entryType, closeType)
Parameters:
internalAction (string)
entryType (string)
closeType (string)
f_build(id, okxAction, marketPosition, prevMarketPosition, instrument, signalToken, timestampUtc, investmentType, amount, maxLagSeconds)
Parameters:
id (string)
okxAction (string)
marketPosition (string)
prevMarketPosition (string)
instrument (string)
signalToken (string)
timestampUtc (string)
investmentType (string)
amount (string)
maxLagSeconds (string)
Candle Pattern Library [1CG]Candle Pattern Library
A comprehensive and easy-to-use Pine Script™ library for detecting single, two, and three-candle patterns. This library provides detailed pattern analysis including size classification, direction validation, and specific pattern identification.
Quick Start
1. Import the Library
import OneCleverGuy/CandlePatternLibrary/1 as CPL
2. Analyze Candles
Use the main analysis functions to detect patterns. You can analyze the current forming candle or confirmed historical candles.
// 1. Analyze candles (Current , Previous , and the one before )
// Note: We use full variable names for clarity.
CandleData candleNewest = CPL.analyzeCandle(open, high, low, close, 250, 50, 10, 50, 85)
CandleData candleMiddle = CPL.analyzeCandle(open , high , low , close , 250, 50, 10, 50, 85)
CandleData candleOldest = CPL.analyzeCandle(open , high , low , close , 250, 50, 10, 50, 85)
// 2. Analyze multi-candle patterns
// Pass candles in chronological order: Oldest -> Newest
var twoCandleData = CPL.analyzeTwoCandlePattern(candleMiddle, candleNewest, 10, 85)
var threeCandleData = CPL.analyzeThreeCandlePattern(candleOldest, candleMiddle, candleNewest)
Enums Reference
These are the Enum Types exported by the library. When checking results, use the pattern Alias.EnumType.Value (e.g., CPL.CandlePattern.Hammer).
CandlePattern
Enum Type for single-candle formations.
Usage: CPL.CandlePattern.
Values:
Unknown : No specific pattern detected.
RegularBullish : A standard bullish candle.
RegularBearish : A standard bearish candle.
BullishMarubozu : Bullish candle with little to no wicks.
BearishMarubozu : Bearish candle with little to no wicks.
Hammer : Small body at the top of the range (bullish reversal).
ShootingStar : Small body at the bottom of the range (bearish reversal).
SpinningTop : Small body centered in the range.
Doji : Open and close are effectively equal.
LongLeggedDoji : Doji with long upper and lower wicks.
CrossDoji : Doji with the body in the upper section.
DragonflyDoji : Doji where open/close are at the high.
InvertedCrossDoji : Doji with the body in the lower section.
GravestoneDoji : Doji where open/close are at the low.
FourPriceDoji : Open, High, Low, and Close are all equal.
TwoCandlePattern
Enum Type for two-candle formations.
Usage: CPL.TwoCandlePattern.
Values:
None : No two-candle pattern detected.
BullishEngulfingWeak : Bullish candle engulfs the previous body (close does not engulf range).
BullishEngulfingStrong : Bullish candle completely engulfs the previous body close outside range.
BearishEngulfingWeak : Bearish candle engulfs the previous body.
BearishEngulfingStrong : Bearish candle completely engulfs the previous body.
InsideBar : The second candle is completely contained within the first.
TweezerTop : Two candles with matching highs (bearish reversal).
TweezerBottom : Two candles with matching lows (bullish reversal).
BullishRailRoad : Two opposite Marubozus (Down -> Up).
BearishRailRoad : Two opposite Marubozus (Up -> Down).
ThreeCandlePattern
Enum Type for three-candle formations.
Usage: CPL.ThreeCandlePattern.
Values:
None : No three-candle pattern detected.
ThreeWhiteSoldiers : Three consecutive bullish candles.
ThreeBlackCrows : Three consecutive bearish candles.
ThreeWhiteSoldiersWithBullishFVG : Three White Soldiers containing a Bullish FVG.
ThreeWhiteSoldiersWithBearishFVG : Three White Soldiers containing a Bearish FVG.
ThreeBlackCrowsWithBullishFVG : Three Black Crows containing a Bullish FVG.
ThreeBlackCrowsWithBearishFVG : Three Black Crows containing a Bearish FVG.
MorningStar : Bearish -> Small/Doji -> Bullish (Bullish Reversal).
EveningStar : Bullish -> Small/Doji -> Bearish (Bearish Reversal).
BullishAbandonedBaby : Morning Star with gaps between all candles.
BearishAbandonedBaby : Evening Star with gaps between all candles.
EngulfingSandwich : Bearish -> Bullish (Engulfing) -> Bearish (Inside).
BullishFairValueGap : A gap between Candle 1 High and Candle 3 Low.
BearishFairValueGap : A gap between Candle 1 Low and Candle 3 High.
CandleSize
Enum Type for candle size classification.
Usage: CPL.CandleSize.
Values:
Short
Normal
Long
CandleDirection
Enum Type for candle direction classification.
Usage: CPL.CandleDirection.
Values:
Bearish
Neutral
Bullish
Function Reference
Analysis Functions
analyzeCandle(_open, _high, _low, _close, _avgSize, _sizeThresholdPct, _equivTolerance, _bodyTolerance, _positionThreshold)
analyzeCandle - Analyzes a single candle's OHLC data to determine its size, direction, and single-candle pattern.
Parameters:
_open (float) : (float) - Candle open price.
_high (float) : (float) - Candle high price.
_low (float) : (float) - Candle low price.
_close (float) : (float) - Candle close price.
_avgSize (float) : (float) - Baseline size (wick range) to compare against.
_sizeThresholdPct (float) : (float) - % difference from average to be considered Long/Short (e.g., 50.0).
_equivTolerance (float) : (float) - Absolute price diff for Close to equal Open (Doji checks).
_bodyTolerance (float) : (float) - Absolute price diff for "Small Body" checks.
_positionThreshold (int) : (int) - Int (0-100) determining valid wick ratios for Hammers/Shooting Stars (e.g., 85).
Returns: (CandleData) - CandleData object containing CandlePattern, CandleSize, CandleDirection.
analyzeTwoCandlePattern(_candle1, _candle2, _equivTolerance, _positionThreshold)
analyzeTwoCandlePattern - Analyzes two consecutive candles to find pairs like Engulfing, Tweezers, or Inside Bars.
Parameters:
_candle1 (CandleData) : (CandleData) - The first (older) candle data (previous).
_candle2 (CandleData) : (CandleData) - The second (newer) candle data (current).
_equivTolerance (float) : (float) - Price tolerance for matching highs/lows (Tweezers).
_positionThreshold (int) : (int) - Threshold for wick validations.
Returns: (TwoCandleData) - TwoCandleData object containing TwoCandlePattern.
analyzeThreeCandlePattern(_candle1, _candle2, _candle3)
analyzeThreeCandlePattern - Analyzes three consecutive candles to find complex patterns like Morning Stars, Abandoned Babies, or Three White Soldiers.
Parameters:
_candle1 (CandleData) : (CandleData) - The first (oldest) candle data.
_candle2 (CandleData) : (CandleData) - The second (middle) candle data.
_candle3 (CandleData) : (CandleData) - The third (newest) candle data.
Returns: (ThreeCandleData) - ThreeCandleData object containing ThreeCandlePattern.
Naming Utilities
getPatternName(_pattern)
getPatternName - Returns the string name of a candle pattern.
Parameters:
_pattern (CandlePattern) : (CandlePattern) - The candle pattern enum value.
Returns: (string) - Human-readable pattern name (e.g., "Hammer").
getTwoCandlePatternName(_pattern)
getTwoCandlePatternName - Returns the string name of a two-candle pattern.
Parameters:
_pattern (TwoCandlePattern) : (TwoCandlePattern) - The two-candle pattern enum value.
Returns: (string) - Human-readable pattern name (e.g., "Bullish Engulfing").
getThreeCandlePatternName(_pattern)
getThreeCandlePatternName - Returns the string name of a three-candle pattern.
Parameters:
_pattern (ThreeCandlePattern) : (ThreeCandlePattern) - The three-candle pattern enum value.
Returns: (string) - Human-readable pattern name (e.g., "Morning Star").
getSizeName(_size)
getSizeName - Returns the string name of a candle size.
Parameters:
_size (CandleSize) : (CandleSize) - The candle size enum value.
Returns: (string) - Human-readable size name ("Short", "Normal", or "Long").
getDirectionName(_direction)
getDirectionName - Returns the string name of a candle direction.
Parameters:
_direction (CandleDirection) : (CandleDirection) - The candle direction enum value.
Returns: (string) - Human-readable direction name ("Bullish", "Bearish", or "Neutral").
PatternTransitionTablesPatternTransitionTables Library
🌸 Part of GoemonYae Trading System (GYTS) 🌸
🌸 --------- 1. INTRODUCTION --------- 🌸
💮 Overview
This library provides precomputed state transition tables to enable ultra-efficient, O(1) computation of Ordinal Patterns. It is designed specifically to support high-performance indicators calculating Permutation Entropy and related complexity measures.
💮 The Problem & Solution
Calculating Permutation Entropy, as introduced by Bandt and Pompe (2002), typically requires computing ordinal patterns within a sliding window at every time step. The standard successive-pattern method (Equations 2+3 in the paper) requires ≤ 4d-1 operations per update.
Unakafova and Keller (2013) demonstrated that successive ordinal patterns "overlap" significantly. By knowing the current pattern index and the relative rank (position l) of just the single new data point, the next pattern index can be determined via a precomputed look-up table. Computing l still requires d comparisons, but the table lookup itself is O(1), eliminating the need for d multiplications and d additions. This reduces total operations from ≤ 4d-1 to ≤ 2d per update (Table 4). This library contains these precomputed tables for orders d = 2 through d = 5.
🌸 --------- 2. THEORETICAL BACKGROUND --------- 🌸
💮 Permutation Entropy
Bandt, C., & Pompe, B. (2002). Permutation entropy: A natural complexity measure for time series.
doi.org
This concept quantifies the complexity of a system by comparing the order of neighbouring values rather than their magnitudes. It is robust against noise and non-linear distortions, making it ideal for financial time series analysis.
💮 Efficient Computation
Unakafova, V. A., & Keller, K. (2013). Efficiently Measuring Complexity on the Basis of Real-World Data.
doi.org
This library implements the transition function φ_d(n, l) described in Equation 5 of the paper. It maps a current pattern index (n) and the position of the new value (l) to the successor pattern, reducing the complexity of updates to constant time O(1).
🌸 --------- 3. LIBRARY FUNCTIONALITY --------- 🌸
💮 Data Structure
The library stores transition matrices as flattened 1D integer arrays. These tables are mathematically rigorous representations of the factorial number system used to enumerate permutations.
💮 Core Function: get_successor()
This is the primary interface for the library for direct pattern updates.
• Input: The current pattern index and the rank position of the incoming price data.
• Process: Routes the request to the specific transition table for the chosen order (d=2 to d=5).
• Output: The integer index of the next ordinal pattern.
💮 Table Access: get_table()
This function returns the entire flattened transition table for a specified dimension. This enables local caching of the table (e.g. in an indicator's init() method), avoiding the overhead of repeated library calls during the calculation loop.
💮 Supported Orders & Terminology
The parameter d is the order of ordinal patterns (following Bandt & Pompe 2002). Each pattern of order d contains (d+1) data points, yielding (d+1)! unique patterns:
• d=2: 3 points → 6 unique patterns, 3 successor positions
• d=3: 4 points → 24 unique patterns, 4 successor positions
• d=4: 5 points → 120 unique patterns, 5 successor positions
• d=5: 6 points → 720 unique patterns, 6 successor positions
Note: d=6 is not implemented. The resulting code size (approx. 191k tokens) exceeds the Pine Script limit of 100k tokens (as of 2025-12).
SharelineUI_LibraryLibrary "SharelineUI_Library"
get_text_size(opt)
Parameters:
opt (string)
status_color(val)
Parameters:
val (float)
trend_color(trend_cat)
Parameters:
trend_cat (string)
momentum_color(score, bullTh, bearTh)
Parameters:
score (float)
bullTh (float)
bearTh (float)
create_standard_hud(pos, cols, rows)
Parameters:
pos (string)
cols (int)
rows (int)
SharelineCore_LibraryLibrary "SharelineCore_Library"
funding_premium(premiumSym, funding_period, plot_type, interest_rate, fundScale)
Parameters:
premiumSym (string)
funding_period (string)
plot_type (string)
interest_rate (float)
fundScale (float)
cvd_vwap_delta(spotSym, perpSym, normLen, resetCVD)
Parameters:
spotSym (string)
perpSym (string)
normLen (int)
resetCVD (bool)
cvd_trend_norm(spotSymbol, perpSymbol, normLen, resetOnSession)
Parameters:
spotSymbol (string)
perpSymbol (string)
normLen (int)
resetOnSession (bool)
trend_strength_engine(cvdSpot, cvdPerp)
Parameters:
cvdSpot (float)
cvdPerp (float)
bias_engine(plot_value, spotTrendVal, perpTrendVal, spotStrength, perpStrength)
Parameters:
plot_value (float)
spotTrendVal (float)
perpTrendVal (float)
spotStrength (float)
perpStrength (float)
smc_engine(h, l, c, v, ms_len, bos_len, vol_filter, scale_factor, smooth_len, signal_len)
Parameters:
h (float)
l (float)
c (float)
v (float)
ms_len (int)
bos_len (int)
vol_filter (bool)
scale_factor (float)
smooth_len (simple int)
signal_len (simple int)
momentum_engine(o, c, v, fast, slow, signal, rsiLen, normLen, smaShort, smaLong, wMacd, wRsi, wCvd, wVpi)
Parameters:
o (float)
c (float)
v (float)
fast (simple int)
slow (simple int)
signal (simple int)
rsiLen (simple int)
normLen (int)
smaShort (int)
smaLong (int)
wMacd (float)
wRsi (float)
wCvd (float)
wVpi (float)
oi_engine(quotecur, useBinance, useBinance2, useBinance3, useBitmex, useBitmex2, useKraken, d_mult, strength1_mult, strength2_mult)
Parameters:
quotecur (string)
useBinance (bool)
useBinance2 (bool)
useBinance3 (bool)
useBitmex (bool)
useBitmex2 (bool)
useKraken (bool)
d_mult (float)
strength1_mult (float)
strength2_mult (float)
TRZigZagLibLibrary "TRZigZagLib"
method directionName(this)
Gets pivot direction as string
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: "HIGH" or "LOW"
method isHigh(this)
Checks if pivot is a high
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: true if pivot is a high
method isLow(this)
Checks if pivot is a low
Namespace types: Pivot
Parameters:
this (Pivot) : Pivot instance
Returns: true if pivot is a low
method newSettings(minLength, minBarSize, maxBarSize)
Creates default ZigZag settings
Namespace types: series int, simple int, input int, const int
Parameters:
minLength (int) : Minimum pivot length (default: 10)
minBarSize (int) : Minimum bars between pivots (default: 5)
maxBarSize (int) : Maximum bars to lookback (default: 300)
Returns: New ZigZagSettings instance
method setLineStyle(this, lineColor, lineWidth, lineStyle)
Sets line appearance
Namespace types: ZigZagSettings
Parameters:
this (ZigZagSettings) : Settings instance
lineColor (color)
lineWidth (int)
lineStyle (string)
Returns: Modified settings instance
method newZigZag(settings, depth)
Creates a new ZigZag instance
Namespace types: ZigZagSettings
Parameters:
settings (ZigZagSettings) : ZigZag settings
depth (int) : Depth value for this ZigZag
Returns: New ZigZag instance
method calculate(this)
Calculates ZigZag using LuxAlgo-style pivot detection
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
method getLastPivots(this, count)
Gets the last N pivots
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
count (int) : Number of pivots to get (default: 5)
Returns: Array of pivots
method getPivot(this, index)
Gets pivot at index
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
index (int) : Index (0 = most recent)
Returns: Pivot or na
method truncate(this, maxBars)
Truncates old pivots beyond lookback window
Namespace types: ZigZag
Parameters:
this (ZigZag) : ZigZag instance
maxBars (int) : Maximum bars to keep
method newMultiZigZag(settings, minDepth, maxDepth, count)
Creates a new MultiZigZag manager
Namespace types: ZigZagSettings
Parameters:
settings (ZigZagSettings) : Base settings for all ZigZags
minDepth (int) : Minimum depth value
maxDepth (int) : Maximum depth value
count (int) : Number of ZigZag instances (max 11)
Returns: New MultiZigZag instance
method calculateAll(this)
Updates all ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
method getZigZag(this, index)
Gets ZigZag at index
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
index (int) : Index (0 to count-1)
Returns: ZigZag instance or na
method getDepth(this, index)
Gets depth value at index
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
index (int) : Index (0 to count-1)
Returns: Depth value
method size(this)
Gets total number of ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
Returns: Count of ZigZag instances
method truncateAll(this, maxBars)
Truncates all ZigZag instances
Namespace types: MultiZigZag
Parameters:
this (MultiZigZag) : MultiZigZag instance
maxBars (int) : Maximum bars to keep
method distance(p1, p2)
Calculates distance between two pivots
Namespace types: Pivot
Parameters:
p1 (Pivot) : First pivot
p2 (Pivot) : Second pivot
Returns: Price distance (absolute)
method barSpan(p1, p2)
Calculates bar span between two pivots
Namespace types: Pivot
Parameters:
p1 (Pivot) : First pivot
p2 (Pivot) : Second pivot
Returns: Bar span (absolute)
method isAlternating(pivots)
Checks if pivots are alternating (high-low-high or low-high-low)
Namespace types: array
Parameters:
pivots (array) : Array of pivots
Returns: true if alternating pattern exists
Pivot
Pivot point in the chart
Fields:
d (series int) : Direction: 1=high, -1=low
x (series int) : Bar index
y (series float) : Price
confirmed (series bool) : Pivot confirmation flag
ZigZagSettings
ZigZag configuration settings
Fields:
minLength (series int) : Minimum pivot detection length
minBarSize (series int) : Minimum bars between pivots
maxBarSize (series int) : Maximum bars to lookback
lineColor (series color) : ZigZag line color
lineWidth (series int) : ZigZag line width
lineStyle (series string) : ZigZag line style
ZigZag
Single ZigZag instance
Fields:
settings (ZigZagSettings) : Configuration settings
pivots (array) : Array of pivot points (max 25 for patterns)
lastUpdateBar (series int) : Last bar index when updated
depth (series int) : Current depth value
MultiZigZag
Multi-depth ZigZag manager
Fields:
zigzags (array) : Array of ZigZag instances (max 11)
depthValues (array) : Array of depth values being used
currentBar (series int) : Current bar index being processed
