Регистрация

Techindicator

lib_fvgLibrary "lib_fvg" Fair Value Gap engine — detection, testing/inversion lifecycle, HTF nesting filters, entry-candidate selection, stop-loss derivation, and FVG drawing — extracted 1:1 from rewrite_strategy.pine. method equals(this, other)   Namespace types: FVG   Parameters:      this (FVG)      other (FVG) method remove(this, item)   Namespace types: array   Parameters:      this (array)      item (FVG) method check_nested_in(this, htf_fvg, check_nested, check_untested, check_nearby, nearby_threshold, check_newer_ltf)   Namespace types: FVG   Parameters:      this (FVG)      htf_fvg (FVG)      check_nested (bool)      check_untested (bool)      check_nearby (bool)      nearby_threshold (float)      check_newer_ltf (bool) method distance_to_price_post_inverse(this, price)   Namespace types: FVG   Parameters:      this (FVG)      price (float) method is_higher_tf_or_closer_to_price_than(this, other)   Namespace types: FVG   Parameters:      this (FVG)      other (FVG) method get_stop_loss(this, entry_price, session_extreme, enable_sl_at_fvg_created_swing_point, trail_session_level_tight_threshold)   Namespace types: FVG   Parameters:      this (FVG)      entry_price (float)      session_extreme (float)      enable_sl_at_fvg_created_swing_point (bool)      trail_session_level_tight_threshold (float) method delete_bar(this)   Namespace types: Bar   Parameters:      this (Bar) method delete_fvg(this)   Namespace types: FVG   Parameters:      this (FVG) log_entry_rejection(enable_log, fvg, reason, smt, note)   Parameters:      enable_log (bool)      fvg (FVG)      reason (series EntryFilterReason)      smt (SMT type from Danieltrade29292/lib_smt/1)      note (string) method invalidate_fvg(this, fvg, reason, entry_block_reason, lifecycle)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      fvg (FVG)      reason (series FVGFilterReason)      entry_block_reason (series EntryFilterReason)      lifecycle (series FVGLifecycle) method add_fvg(this, fvg, enable_single_fvg_per_tf)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      fvg (FVG)      enable_single_fvg_per_tf (bool) method detect_fvg(this, tf, tf_id, t2, h2, l2, h1, l1, h0, l0, min_gap_size, fvg_deprecation_period, enable_single_fvg_per_tf)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      tf (string)      tf_id (int)      t2 (int)      h2 (float)      l2 (float)      h1 (float)      l1 (float)      h0 (float)      l0 (float)      min_gap_size (float)      fvg_deprecation_period (int)      enable_single_fvg_per_tf (bool) method invalidate_all_of_direction(this, fvg_is_bullish, reason)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      fvg_is_bullish (bool)      reason (series FVGFilterReason) method invalidate_fvgs_inversed_pre_smt(this, smt_buffer, enable_log)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      smt_buffer (SMTBuffer type from Danieltrade29292/lib_smt/1)      enable_log (bool) method try_park_in(this, htf_pool, check_nested, check_untested, check_nearby, nearby_threshold, check_newer_ltf)   Namespace types: FVG   Parameters:      this (FVG)      htf_pool (array)      check_nested (bool)      check_untested (bool)      check_nearby (bool)      nearby_threshold (float)      check_newer_ltf (bool) method update_htf_relations(this, enable_filter_by_full_nest_in_HTF_fvg, enable_filter_by_untested, enable_filter_by_edge_nearby_HTF_fvg, nearby_HTF_threshold, enable_filter_by_newer_LTF_fvg)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      enable_filter_by_full_nest_in_HTF_fvg (bool)      enable_filter_by_untested (bool)      enable_filter_by_edge_nearby_HTF_fvg (bool)      nearby_HTF_threshold (float)      enable_filter_by_newer_LTF_fvg (bool) method update_fvgs(this, tf2, tf2_updated, fvg2_o, fvg2_h, fvg2_l, fvg2_c, tf3, tf3_updated, fvg3_o, fvg3_h, fvg3_l, fvg3_c, tf4, tf4_updated, fvg4_o, fvg4_h, fvg4_l, fvg4_c, min_inversion_distance, max_inversion_distance, tested_by_mode, max_tests_before_inverse)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      tf2 (string)      tf2_updated (bool)      fvg2_o (float)      fvg2_h (float)      fvg2_l (float)      fvg2_c (float)      tf3 (string)      tf3_updated (bool)      fvg3_o (float)      fvg3_h (float)      fvg3_l (float)      fvg3_c (float)      tf4 (string)      tf4_updated (bool)      fvg4_o (float)      fvg4_h (float)      fvg4_l (float)      fvg4_c (float)      min_inversion_distance (float)      max_inversion_distance (float)      tested_by_mode (series FVGTestedByMode)      max_tests_before_inverse (int) method find_next_best_waiting_fvgs(this, smt_buffer)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      smt_buffer (SMTBuffer type from Danieltrade29292/lib_smt/1) method find_entry_candidate_fvg(this, smt_buffer, enable_filter_by_inversion_bar_close_in_untested_HTF_fvg, enable_log)   Namespace types: FVGBuffer   Parameters:      this (FVGBuffer)      smt_buffer (SMTBuffer type from Danieltrade29292/lib_smt/1)      enable_filter_by_inversion_bar_close_in_untested_HTF_fvg (bool)      enable_log (bool) method draw_bar(this, is_bullish, bgcolor, border_color, labelcolor, txt, show_box)   Namespace types: Bar   Parameters:      this (Bar)      is_bullish (bool)      bgcolor (color)      border_color (color)      labelcolor (color)      txt (string)      show_box (bool) method draw_fvg(this, color_bull, color_bear, debug)   Namespace types: FVG   Parameters:      this (FVG)      color_bull (color)      color_bear (color)      debug (bool) method draw_fvgs(this, color_bull, color_bear, debug)   Namespace types: array   Parameters:      this (array)      color_bull (color)      color_bear (color)      debug (bool) method draw_entry_fvg(this, color_bull, color_bear, debug)   Namespace types: FVG   Parameters:      this (FVG)      color_bull (simple color)      color_bear (simple color)      debug (bool) method delete_fvgs(this)   Namespace types: array   Parameters:      this (array) Bar   Fields:      o (series float)      h (series float)      l (series float)      c (series float)      top (series float)      btm (series float)      t_open (series int)      i_open (series int)      t_close (series int)      i_close (series int)      bar_box (series box)      bar_label (series label) FVG   Fields:      is_bullish_original (series bool)      is_bullish_post_inverse (series bool)      tf (series string)      tf_id (series int)      top_left (chart.point)      bottom_right (chart.point)      hh (series float)      ll (series float)      deprecate_at (series int)      sl_level (series float)      is_active (series bool)      test_count (series int)      first_test_idx (series int)      is_inversed (series bool)      has_touched (series bool)      fvg_box (series box)      tooltip_label (series label)      hidden (series bool)      draw_signal_inversed (series bool)      draw_signal_text (series bool)      draw_signal_highlight (series bool)      draw_signal_set_candidate (series bool)      draw_signal_reset_candidate (series bool)      fill_state (series FVGFillState)      lifecycle (series FVGLifecycle)      filter_reason (series FVGFilterReason)      entry_filter_reason (series EntryFilterReason)      tf_inversion_bar (Bar)      inversion_idx (series int) FVGBuffer   Fields:      items (array)      inversed (array)      invalidated (array)
Библиотека Pine Script®
от Danieltrade29292
lib_smtLibrary "lib_smt" SMT divergence + session detection/lifecycle, SMT buffers, premium/discount zones, and their on-chart drawing — extracted 1:1 from rewrite_strategy.pine. method equals(this, other)   Namespace types: SMT   Parameters:      this (SMT)      other (SMT) method delete_smt(this)   Namespace types: SMT   Parameters:      this (SMT) method delete_smts(this)   Namespace types: array   Parameters:      this (array) method replace(this, value)   Namespace types: array   Parameters:      this (array)      value (Session) method replace(sess, idx, value, remove_buffer)   Namespace types: array   Parameters:      sess (array)      idx (int)      value (Session)      remove_buffer (array) method reset(this)   Namespace types: SessionSignals   Parameters:      this (SessionSignals) method reset(this)   Namespace types: SessionLevel   Parameters:      this (SessionLevel) method reset(this)   Namespace types: Session   Parameters:      this (Session) method invalidate_smt(this, smt, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      smt (SMT)      reason (series SMTFilterReason) method invalidate_session(this, sess, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      sess (Session)      reason (series SMTFilterReason) method set_intra(this, smt)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      smt (SMT) method reset_intra(this, reason, sess, reset_bull, reset_bear)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      reason (series SMTFilterReason)      sess (Session)      reset_bull (bool)      reset_bear (bool) method invalidate_all_daily_smts(this, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      reason (series SMTFilterReason) method invalidate_all_session_smts(this, is_bullish, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      is_bullish (bool)      reason (series SMTFilterReason) method invalidate_entry_daily_smt(this, entry_smt, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      entry_smt (SMT)      reason (series SMTFilterReason) method invalidate_by_detected_session_id(this, id, reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      id (int)      reason (series SMTFilterReason) method invalidate_swept_sessions(this, session_signals, overflow_buffer)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      session_signals (SessionSignals)      overflow_buffer (array) method add_smt(this, smt)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      smt (SMT) method update_smt(this, other_high, other_low, smt_buffer, enable_invalidation_by_distance, invalidation_dist_chart_led, invalidation_dist_other_led)   Namespace types: SMT   Parameters:      this (SMT)      other_high (float)      other_low (float)      smt_buffer (SMTBuffer)      enable_invalidation_by_distance (bool)      invalidation_dist_chart_led (float)      invalidation_dist_other_led (float) method update_smts(this, other_high, other_low, enable_invalidation_by_distance, invalidation_dist_chart_led, invalidation_dist_other_led)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      other_high (float)      other_low (float)      enable_invalidation_by_distance (bool)      invalidation_dist_chart_led (float)      invalidation_dist_other_led (float) method update_session_level_sweeps(this, other_high, other_low)   Namespace types: Session   Parameters:      this (Session)      other_high (float)      other_low (float) method detect_smt(this, smt_h1, smt_l1, smt_c1, smt_other_h1, smt_other_l1, is_smt_tf_new_bar, smt_buffer, active_session_id, smt_min_age, is_intra, is_blocked_intra_smt_bull, is_blocked_intra_smt_bear, timeout_intra, touch_tolerance, intra_min_swing_age)   ───────────────────────────────────────────────────────────────────────────── session.detect_smt — check if chart/other has swept H or L §2.2.1 Level SMT Detection / §2.2.2 Daily SMT Detection / §2.2.3 Intra SMT Detection is_intra=true → called on live active session (§2.2.3); uses running H/L, equal high/low counts is_intra=false → called on archived session (§2.2.1/§2.2.2); levels are fixed at capture time active_session_id: session currently open, stored as detected_session_id on new SMTs so §2.3.2 London-detected invalidation can filter correctly on NY open ─────────────────────────────────────────────────────────────────────────────   Namespace types: Session   Parameters:      this (Session)      smt_h1 (float)      smt_l1 (float)      smt_c1 (float)      smt_other_h1 (float)      smt_other_l1 (float)      is_smt_tf_new_bar (bool)      smt_buffer (SMTBuffer)      active_session_id (int)      smt_min_age (int)      is_intra (bool)      is_blocked_intra_smt_bull (bool)      is_blocked_intra_smt_bear (bool)      timeout_intra (int)      touch_tolerance (float)      intra_min_swing_age (int) method detect_smts(this, signals, smt_h1, smt_l1, smt_c1, smt_other_h1, smt_other_l1, is_smt_tf_new_bar, smt_buffer, active_session_id, smt_min_age, touch_tolerance)   Namespace types: array   Parameters:      this (array)      signals (SessionSignals)      smt_h1 (float)      smt_l1 (float)      smt_c1 (float)      smt_other_h1 (float)      smt_other_l1 (float)      is_smt_tf_new_bar (bool)      smt_buffer (SMTBuffer)      active_session_id (int)      smt_min_age (int)      touch_tolerance (float) method has_active_daily_smt(this, seeks_bullish)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      seeks_bullish (bool) method find_best_smt_by_prio(this, minimum_prio, seeks_bullish)   Namespace types: array   Parameters:      this (array)      minimum_prio (int)      seeks_bullish (bool) method find_best_smt_by_direction(this, intra_smts_enabled, seeks_bullish)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      intra_smts_enabled (bool)      seeks_bullish (bool) method update_best_smts(this, pd_zone, intra_smts_enabled, allow_bullish_intra_smt_post_cutoff_if_has_daily_smt_active, allow_bearish_intra_smt_post_cutoff_if_has_daily_smt_active)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      pd_zone (int)      intra_smts_enabled (bool)      allow_bullish_intra_smt_post_cutoff_if_has_daily_smt_active (bool)      allow_bearish_intra_smt_post_cutoff_if_has_daily_smt_active (bool) method rotate(this, sess, max)   Namespace types: array   Parameters:      this (array)      sess (Session)      max (int) method add_session(this, sess, overflow_buffer)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      sess (Session)      overflow_buffer (array) method evict_consumed_days(this, overflow_buffer, max_history_days)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      overflow_buffer (array)      max_history_days (simple int) method clear_invalidated_smts(this, keep_level, keep_intra, keep_reason)   Namespace types: SMTBuffer   Parameters:      this (SMTBuffer)      keep_level (bool)      keep_intra (bool)      keep_reason (bool) method archive(this)   Namespace types: SessionLevel   Parameters:      this (SessionLevel) method archive(this)   Namespace types: Session   Parameters:      this (Session) method update_levels(this, is_smt_tf_new_bar, other_high, other_low, smt_t1, smt_h1, smt_l1, smt_other_h1, smt_other_l1)   Namespace types: Session   Parameters:      this (Session)      is_smt_tf_new_bar (bool)      other_high (float)      other_low (float)      smt_t1 (int)      smt_h1 (float)      smt_l1 (float)      smt_other_h1 (float)      smt_other_l1 (float) method update_session(this, signals, smt_buffer, new_day, other_high, other_low, smt_t1, smt_h1, smt_l1, smt_c1, smt_other_h1, smt_other_l1, is_smt_tf_new_bar, smt_min_age, timeout_intra, in_any_no_intra_smt_zone, enable_block_intra_smts_pre_high_prio_sweep, previous_session, intra_min_swing_age)   Namespace types: Session   Parameters:      this (Session)      signals (SessionSignals)      smt_buffer (SMTBuffer)      new_day (bool)      other_high (float)      other_low (float)      smt_t1 (int)      smt_h1 (float)      smt_l1 (float)      smt_c1 (float)      smt_other_h1 (float)      smt_other_l1 (float)      is_smt_tf_new_bar (bool)      smt_min_age (int)      timeout_intra (int)      in_any_no_intra_smt_zone (bool)      enable_block_intra_smts_pre_high_prio_sweep (bool)      previous_session (Session)      intra_min_swing_age (int) method draw_session(this, show_chart, show_panel)   Namespace types: Session   Parameters:      this (Session)      show_chart (bool)      show_panel (bool) method draw_session_consumed(this)   Namespace types: Session   Parameters:      this (Session) method delete(this)   Namespace types: Session   Parameters:      this (Session) method delete(this)   Namespace types: array   Parameters:      this (array) method register(this, enabled, session, _fill_color, _text, _text_color, _border_color, prio, id, is_daily, is_session, enable_intra_smts, is_no_intra_smt_zone, smt_timeout, strategy_config)   Namespace types: array   Parameters:      this (array)      enabled (bool)      session (string)      _fill_color (color)      _text (string)      _text_color (color)      _border_color (color)      prio (int)      id (int)      is_daily (bool)      is_session (bool)      enable_intra_smts (bool)      is_no_intra_smt_zone (bool)      smt_timeout (int)      strategy_config (StrategyConfig) method short_id(this)   Namespace types: SMT   Parameters:      this (SMT) method label_text(this, other_ticker, include_filter_reason, is_leader)   Namespace types: SMT   Parameters:      this (SMT)      other_ticker (string)      include_filter_reason (bool)      is_leader (bool) method draw_smt(this, other_ticker, show_label_leader, show_label_follower, verbose)   Namespace types: SMT   Parameters:      this (SMT)      other_ticker (string)      show_label_leader (bool)      show_label_follower (bool)      verbose (bool) method draw_smts(this, other_ticker, show_label_leader, show_label_follower, show_filter_reason)   Namespace types: array   Parameters:      this (array)      other_ticker (string)      show_label_leader (bool)      show_label_follower (bool)      show_filter_reason (bool) get_pd_range(enable, bars_lookback, new_hour)   Parameters:      enable (simple bool)      bars_lookback (int)      new_hour (bool) draw_pd(new_hour, pd_start, pd_high, pd_equilibrium, pd_low)   Parameters:      new_hour (bool)      pd_start (int)      pd_high (float)      pd_equilibrium (float)      pd_low (float) SMT   Fields:      detected_session_id (series int)      leader (series int)      leader_level (chart.point)      sweep (chart.point)      follow_level (chart.point)      session_id (series int)      prio (series int)      is_bullish (series bool)      deprecate_at (series int)      detection_bar (series int)      detection_close (series float)      valid_from (series int)      invalidated (series bool)      filter_reason (series SMTFilterReason)      leader_line (series line)      leader_label (series label)      follow_line (series line)      follow_intermediate_line (series line)      follow_label (series label)      smt_color (series color)      draw_remove_highlight (series bool)      used_for_trade (series bool)      trade_end_time (series int) SessionLevel   tracks session H/L   Fields:      chart (chart.point)      other (chart.point)      chart_smt_tf (chart.point)      other_smt_tf (chart.point)      is_consumed (series bool)      smt (SMT) StrategyConfig   Fields:      big_win_threshold (series float)      cutoff_hour (series int)      cutoff_tz (series string)      cutoff_mode (series SessionCutoffMode)      max_losses (series int)      max_wins (series int) Session   Fields:      id (series int)      prio (series int)      timeout (series int)      session (series string)      h (SessionLevel)      l (SessionLevel)      _fill_color (series color)      _text (series string)      _text_color (series color)      _border_color (series color)      is_daily (series bool)      is_session (series bool)      is_no_intra_smt_zone (series bool)      enable_intra_smts (series bool)      strategy_config (StrategyConfig)      start_time (series int)      end_time (series int)      cutoff_at (series int)      is_active (series bool)      is_consumed (series bool)      box_chart (series box)      box_other (series box)      mean_sum (series float)      mean_count (series float)      mean (series float)      is_any_low_swept (series bool)      is_any_high_swept (series bool)      draw_signal_consumed (series bool)      tooltip_chart (series label)      tooltip_other (series label) SessionSignals   Fields:      signal_session_started (series int)      signal_session_ending (series int)      signal_session_ended (series int)      signal_no_intra_smt_zone_started (series int)      signal_no_intra_smt_zone_ending (series int)      signal_no_intra_smt_zone_ended (series int)      signal_intra_smt_h (series int)      signal_intra_smt_l (series int)      signal_session_consumed (series bool) SMTBuffer   Fields:      session_smts (array)      daily_smts (array)      intra_smts (array)      invalidated (array)      delete_buffer (array)      monitored_sessions (array)      monitored_days (array)      consumed_days (array)      max_days (series int)      best_bull_smt (SMT)      best_bear_smt (SMT)
Библиотека Pine Script®
от Danieltrade29292
MarketReactionLibrary "MarketReaction" Modular library for sessions, Initial Balance, PSY ranges, VWAPs, alerts, and macro sentiment helpers. getSessionConfig(source)   Returns session config by source name.   Parameters:      source (simple string) : Session source: Tokyo, New York, London, Jerusalem, EU B, US B.   Returns: SessionConfig. sessionModule(session, timeZone, sessionText, sessionColor, sessionDuration, showVisuals, showLabels, showLines, showMiddleLine, showBg, bgTransp)   Builds session high/low/middle lines, label, background fill and VWAP.   Parameters:      session (simple string) : Session string.      timeZone (simple string) : IANA timezone.      sessionText (simple string) : Label text.      sessionColor (color) : Session color.      sessionDuration (simple int) : Approximate session duration in ms.      showVisuals (bool) : Show this session visuals.      showLabels (bool) : Show labels.      showLines (bool) : Show high/low lines.      showMiddleLine (bool) : Show middle line.      showBg (bool) : Show background fill.      bgTransp (int) : Background transparency.   Returns: SessionResult. initialBalanceModule(session, ibSession, timeZone, sessionLabel, showDLabels, showWLabels, showMLabels, showPrevD, showPrevW, showPrevM, dColor, wColor, mColor)   Calculates Daily, Weekly, Monthly Initial Balance and W/M IB VWAPs.   Parameters:      session (simple string) : Full session string.      ibSession (simple string) : IB sub-session string.      timeZone (simple string) : IANA timezone.      sessionLabel (simple string) : Session label.      showDLabels (bool) : Show D.IB labels.      showWLabels (bool) : Show W.IB labels.      showMLabels (bool) : Show M.IB labels.      showPrevD (bool) : Calculate previous daily IB.      showPrevW (bool) : Calculate previous weekly IB.      showPrevM (bool) : Calculate previous monthly IB.      dColor (color) : Daily IB label color.      wColor (color) : Weekly IB label color.      mColor (color) : Monthly IB label color.   Returns: IBResult. psyRangeModule(session, timeZone, showLabels, showPrev, sessionColor)   Calculates PSY high/low, previous PSY levels, labels, and VWAP.   Parameters:      session (simple string) : Session string.      timeZone (simple string) : Timezone.      showLabels (bool) : Show PSY labels.      showPrev (bool) : Show previous PSY levels.      sessionColor (color) : PSY color.   Returns: PSYResult. rangeSignal(highLevel, lowLevel, price)   Returns enter/exit signals for a range.   Parameters:      highLevel (float) : Range high.      lowLevel (float) : Range low.      price (float) : Price source.   Returns: RangeSignal. tablePosition(pos)   Converts table position string to Pine position.   Parameters:      pos (simple string) : Position text.   Returns: Pine table position. SessionConfig   Session configuration.   Fields:      session (series string) : Full session time.      ib (series string) : Initial Balance sub-session time.      tz (series string) : Session timezone.      label (series string) : Session label.      col (series color) : Session color.      duration (series int) : Approximate session duration in milliseconds. SessionResult   Session result.   Fields:      high (series float) : Session high.      low (series float) : Session low.      mid (series float) : Session middle.      vwap (series float) : Session VWAP.      inSession (series bool) : True if bar is inside session.      firstBar (series bool) : True on first session bar.      highLine (series line) : Session high line.      lowLine (series line) : Session low line.      midLine (series line) : Session middle line. IBResult   Initial Balance result.   Fields:      dHigh (series float) : Daily IB high.      dLow (series float) : Daily IB low.      pdHigh (series float) : Previous daily IB high.      pdLow (series float) : Previous daily IB low.      wHigh (series float) : Weekly IB high.      wLow (series float) : Weekly IB low.      pwHigh (series float) : Previous weekly IB high.      pwLow (series float) : Previous weekly IB low.      mHigh (series float) : Monthly IB high.      mLow (series float) : Monthly IB low.      pmHigh (series float) : Previous monthly IB high.      pmLow (series float) : Previous monthly IB low.      wVwap (series float) : Weekly IB VWAP.      mVwap (series float) : Monthly IB VWAP.      inSession (series bool) : True if bar is inside selected full session.      inIB (series bool) : True if bar is inside selected IB session.      ibFirstBar (series bool) : True on first IB bar.      sessionFirstBar (series bool) : True on first full-session bar. PSYResult   PSY range result.   Fields:      high (series float) : Current PSY high.      low (series float) : Current PSY low.      pHigh (series float) : Previous PSY high.      pLow (series float) : Previous PSY low.      vwap (series float) : PSY VWAP.      inSession (series bool) : True if bar is inside PSY range.      firstBar (series bool) : True on first PSY bar. RangeSignal   Range signal result.   Fields:      enter (series bool) : True when price enters range.      exit (series bool) : True when price exits range.      topDn (series bool) : Crossunder from above high.      topUp (series bool) : Crossover above high.      botUp (series bool) : Crossover from below low.      botDn (series bool) : Crossunder below low.
Библиотека Pine Script®
от shmuelmordechay
AxiomMovingAverageLibraryAxiom Moving Average Library Overview If your Pine script offers a moving average type selector, you have probably written the same dispatch logic more than once. An enum, a switch, and a quiet hope that the next script you copy it into stays consistent with the last one. This library replaces that pattern. Import it, use the MaType enum for your dropdown, and call get_ma() to route the user's choice to the right computation. Eight standard moving average types — SMA, EMA, RMA, WMA, VWMA, HMA, and SWMA — all backed by Pine's built-in ta.* functions. Nothing custom under the hood. Why it exists This is a maintenance problem, and it compounds. Every Axiom indicator and strategy that gives users a moving average choice needs the same underlying infrastructure: a type list, a dispatcher, and correct parameter handling for each type. When that logic lives inside every script individually, it drifts. One script picks up HMA support; another doesn't. A third gets the defaults wrong. None of this is visible until someone notices that the same configuration produces different behavior across two Axiom tools. That kind of inconsistency doesn't announce itself — it just erodes confidence in the products over time. This library makes the dispatch code shared. Every consuming script references the same enum, calls the same wrappers, and gets the same result for the same inputs. The repetitive parts stay consistent so you can focus on the work that's actually yours — choosing which averages to offer, deciding what lengths make sense, and building the logic around the result. The plumbing shouldn't be something you rewrite every time. Quickstart import AxiomCharts/AxiomMovingAverageLibrary/1 as maLib maChoice = input.enum(maLib.MaType.EMA, title = "MA Type") maLength = input.int(20, title = "MA Length", minval = 1) maValue = maLib.get_ma(maChoice, close, maLength) Import the library, give your users a dropdown, and route their selection through get_ma(). That covers the standard integration. Recommended alias : maLib — short, and it distinguishes this from the Pro library if you end up using both. API The library exports three things: an enum, eight individual wrapper functions, and one dispatcher. MaType enum Eight values, each mapping to a standard moving average: MaType.SMA - Simple Moving Average MaType.EMA - Exponential Moving Average MaType.RMA - Wilder / Relative Moving Average MaType.WMA - Weighted Moving Average MaType.VWMA - Volume-Weighted Moving Average MaType.HMA - Hull Moving Average MaType.SWMA - Symmetrically Weighted Moving Average The enum works directly with input.enum(), so you can wire it into a settings dropdown without building your own type list. Wrapper functions Each type has a named function: ma_sma(src, length), ma_ema(src, length), ma_rma(src, length), ma_wma(src, length), ma_vwma(src, length), ma_hma(src, length), and ma_swma(src). Two behaviors worth knowing before you use them: SWMA takes no length. Pine's ta.swma applies a fixed symmetrical weighting over 4 bars. The wrapper accepts src only. If you route through get_ma with MaType.SWMA, the length argument is accepted for signature consistency but ignored. The window is always 4. get_ma dispatcher Accepts a MaType value and routes to the correct wrapper. If an unrecognized value reaches the switch, it falls back to SMA as a safety net. Examples Direct wrapper call When you only need one moving average type and don't need a dropdown: import AxiomCharts/AxiomMovingAverageLibrary/1 as maLib smoothed = maLib.ma_ema(close, 20) For a single MA type in a single script, a direct ta.ema(close, 20) is simpler and carries no dependency. The library earns its keep when you need the shared enum or when multiple scripts need to stay in sync. User-selectable dropdown The most common pattern — let users pick the MA type from a settings menu: import AxiomCharts/AxiomMovingAverageLibrary/1 as maLib maChoice = input.enum(maLib.MaType.EMA, title = "MA Type") maLength = input.int(20, title = "MA Length", minval = 1) maValue = maLib.get_ma(maChoice, close, maLength) Watch for: VWMA on symbols without volume ta.vwma requires volume data. On symbols that don't report volume — some forex feeds, certain indices — the result is na. The library does not guard against this. If your script includes VWMA as an option, handle the no-volume case in your own code. FAQ What's the difference between Lite and Pro? Lite covers eight standard moving averages. Each one wraps a Pine built-in — no custom math involved. The Pro library adds thirteen additional types on top of those eight, including DEMA, TEMA, KAMA, JMA, FRAMA, T3MA, VAMA, ZLMA, ZLEMA, Laguerre, and McGinley variants. If your needs outgrow the standard eight, that's when Pro becomes relevant. Why doesn't SWMA accept a length? That's a Pine constraint. ta.swma applies a fixed symmetrical weighting across 4 bars. There is no length parameter to pass, so the wrapper doesn't accept one either. If you route through get_ma with MaType.SWMA, the length argument is there for API consistency but doesn't affect the output. Can I use VWMA on any symbol? Only on symbols that report volume data. On instruments without volume, VWMA returns na. The library won't catch that for you — if your script offers VWMA, check for volume data and handle the na case in your own code. What Pine version do I need? Pine v6. The library uses v6 enum syntax, so scripts on v5 or earlier cannot import it. Limitations Pine v6 required. Scripts on earlier versions cannot import this library. Eight standard types only. Adaptive averages (KAMA, JMA, FRAMA), lag-compensated filters (T3MA, ZLMA, McGinley), and other specialized types are not included. The Pro library covers those. SWMA uses a fixed 4-bar window. The length parameter passed through get_ma is ignored for SWMA. VWMA needs volume data. On symbols without volume, it returns na. Your script should account for this. The SMA fallback is a safety net, not a feature. If an unrecognized value reaches get_ma, it defaults to SMA. In practice, Pine's enum type system prevents this at compile time. Don't build routing logic around it. Versioning and release notes Pin your import to a specific version number you have actually verified in the environment where you are using the library: import AxiomCharts/AxiomMovingAverageLibrary/ If you later need to move from Lite to Pro, expect changes: a different library title and an expanded MaType enum with additional values. It's not a drop-in swap — your code will need updating. Support and training Visit our website at axiomcharts.com for any documentation or questions. Disclaimer This library is published for educational and informational purposes. It provides standardized moving average computation utilities for Pine Script developers. It does not generate trading signals, recommend positions, or guarantee any financial outcome. All trading decisions and their consequences are yours. Use this library as one part of your own research and process.
Библиотека Pine Script®
от AxiomCharts
MahjongAIEngineCombinatoric Full Matrix Suit & Structure Partitioning Module EXECUTIVE SUMMARY This specialized library handles heavy multi-set partition checks, isolating specific matrix dimensions to verify advanced structural alignments. By offloading resource-intensive loop matrices, it prevents AST node exhaustion in parent script containers. EXPORTED FUNCTIONS & QUANTITATIVE LOGIC - check_somete(int counts): Quantifies the exact concentration of elements across independent suit boundaries (Indices 0-8, 9-17, 18-26, and 27-33). It returns a tuple ` ` based on structural suit isolation mathematics, identifying full or partial flush configurations. - is_toitoi(int counts): Evaluates the complete matrix row states to verify if the count of identical elements forming triplet formations equals exactly 4. It scans the integrated index space, filtering out any sequential data configurations. 概要 この特化型ライブラリは、高度な構造的整列を検証するために、特定の行列次元を分離して高負荷なマルチセット・パーティションチェックを処理します。リソースを大量に消費するループマトリックスをオフロードすることで、親スクリプトコンテナ内でのASTノードの枯渇を防止します。 エクスポート関数と定量的ロジック - check_somete(int counts): 独立したスート境界（インデックス0-8、9-17、18-26、および27-33）にわたる要素の正確な集中度を定量化します。構造的な分離数学に基づいてタプル ` ` を返し、清一色または混一色の構成を識別します。 - is_toitoi(int counts): 行列全体の行状態を評価し、トリプレット構成（3枚組）を形成する同一要素の数が正確に4に等しいかどうかを検証します。統合されたインデックス空間を走査し、シーケンス（順子）データ構成を完全に排除します。
Библиотека Pine Script®
от ALT_analyst
MahjongHighYakuCombinatoric Full Matrix Suit & Structure Partitioning Module EXECUTIVE SUMMARY This specialized library handles heavy multi-set partition checks, isolating specific matrix dimensions to verify advanced structural alignments. By offloading resource-intensive loop matrices, it prevents AST node exhaustion in parent script containers. EXPORTED FUNCTIONS & QUANTITATIVE LOGIC - check_somete(int counts): Quantifies the exact concentration of elements across independent suit boundaries (Indices 0-8, 9-17, 18-26, and 27-33). It returns a tuple ` ` based on structural suit isolation mathematics, identifying full or partial flush configurations. - is_toitoi(int counts): Evaluates the complete matrix row states to verify if the count of identical elements forming triplet formations equals exactly 4. It scans the integrated index space, filtering out any sequential data configurations. 概要 この特化型ライブラリは、高度な構造的整列を検証するために、特定の行列次元を分離して高負荷なマルチセット・パーティションチェックを処理します。リソースを大量に消費するループマトリックスをオフロードすることで、親スクリプトコンテナ内でのASTノードの枯渇を防止します。 エクスポート関数と定量的ロジック - check_somete(int counts): 独立したスート境界（インデックス0-8、9-17、18-26、および27-33）にわたる要素の正確な集中度を定量化します。構造的な分離数学に基づいてタプル ` ` を返し、清一色または混一色の構成を識別します。 - is_toitoi(int counts): 行列全体の行状態を評価し、トリプレット構成（3枚組）を形成する同一要素の数が正確に4に等しいかどうかを検証します。統合されたインデックス空間を走査し、シーケンス（順子）データ構成を完全に排除します。
Библиотека Pine Script®
от ALT_analyst
MahjongYakuEngineNon-Standard Discrete Array Structure Matcher EXECUTIVE SUMMARY This structural matcher acts as an anomalous state detector, bypassing standard 面子 (meld) partitioning to identify non-standard discrete distribution models. It guarantees immediate verification of unique matrix forms through absolute address mapping. EXPORTED FUNCTIONS & QUANTITATIVE LOGIC - is_kokushi(string hand): Evaluates a raw string array against a fixed terminal-honor set. It maps the 14-element space directly onto 13 unique discrete anchor positions. If the unique element set count equals 13, it flags a perfect terminal anomalous state. - is_chiitoitsu(string hand): Scans the active element sequence to verify the absolute existence of exactly 7 unique paired elements. It prevents state contamination by ensuring no single node possesses a frequency count greater than 2 or less than 2. 概要 この構造マッチングライブラリは、異常状態検出器として機能し、標準的な面子分割をバイパスして非標準的な離散分布モデルを識別します。絶対アドレスマッピングを介して、固有のマトリックス形式の即時検証を保証します。 エクスポート関数と定量的ロジック - is_kokushi(string hand): 生の文字列配列を固定の端位・字牌セットと照合して評価します。14要素の空間を13の固有の離散アンカー位置に直接マッピングし、一意の要素セット数が13に等しい場合、完全な端位異常状態（国士無双）を検出します。 - is_chiitoitsu(string hand): アクティブな要素シーケンスをスキャンし、正確に7つのユニークなペア要素の絶対的な存在を検証します。単一のノードが2を超える、または2未満の頻度カウントを持たないことを保証し、状態の汚染を防止します（七対子の正確な判定）。
Библиотека Pine Script®
от ALT_analyst
MahjongLowYakuLinear Pattern Recognition & Distribution Constraint Calculator EXECUTIVE SUMMARY This modular evaluation library provides mathematical isolation metrics to identify specific linear constraints within a 34-element frequency distribution matrix. It is optimized to perform low-overhead conditional pattern matches without inducing cloud server thread timeouts. EXPORTED FUNCTIONS & QUANTITATIVE LOGIC - is_tanyao(int counts): Validates if the distribution matrix strictly isolates elements between indices 1-7, 10-16, and 19-25. It executes a binary evaluation sequence over terminal and honor index groups, outputting false instantly if any edge element count is greater than zero. - count_yakuhai(int counts): Evaluates specific honor nodes (indices 27 through 33) to determine if any terminal triplet state exists. The mathematical output dynamically increments the state score per completed subset, facilitating fast han-value compilation for downstream logic. 概要 このモジュール型評価ライブラリは、34要素の頻度分布マトリックス内における特定の線形制約を識別するための数学的分離メトリクスを提供します。クラウドサーバーの実行タイムアウトを誘発することなく、低オーバーヘッドで条件付きパターンマッチングを実行するように最適化されています。 エクスポート関数と定量的ロジック - is_tanyao(int counts): 分布マトリックスが要素を特定のインデックス（1-7、10-16、19-25）内に厳格に隔離しているかどうかを検証します。端位および字牌インデックスグループに対してバイナリ評価シーケンスを実行し、境界要素のカウントが0より大きい場合は即座に偽を出力します。 - count_yakuhai(int counts): 特定の字牌ノード（インデックス27から33）を評価し、完了したトリプレット（暗刻・明刻）状態が存在するかを判定します。完了したサブセットごとに出力値を動的にインクリメントし、後続のロジックの飜数コンパイルを高速化します。
Библиотека Pine Script®
от ALT_analyst
MahjongCoreEngineLocalized Core Grid Evaluation & Array Processing Engine EXECUTIVE SUMMARY This library functions as the primary matrix controller and multidimensional array conversion processor for live-tick simulation models. It provides structural utilities to convert raw multi-element datasets into localized counts, offering deterministic memory alignment optimized for Pine Script v6's structural limitations. EXPORTED FUNCTIONS & QUANTITATIVE LOGIC - hand_to_counts(string hand): Translates an arbitrary array of string elements (Unicode vectors) into a standardized 34-element fixed-integer array representing frequency distribution. This reduces the search space for combinations from factorial complexity to linear static constraints, preserving Abstract Syntax Tree (AST) overhead. - is_standard_form(int counts): A deterministic combinatoric explorer that evaluates if the 34-element matrix satisfies the standard terminal grouping format: 4 sets (melds) and 1 pair (eye). It runs recursive backtracking memory pointers to guarantee 100% mathematical validity under live compilation loops. 概要 本ライブラリは、ライブティック・シミュレーションモデルにおける主要なマトリックスコントローラおよび多次元配列変換プロセッサとして機能します。生の複数要素データセットを局所的なカウント配列に変換する構造的ユーティリティを提供し、Pine Script v6の制限に最適化された決定論的なメモリ配置を実現します。 エクスポート関数と定量的ロジック - hand_to_counts(string hand): 任意の文字列配列（Unicodeベクター）を、出現頻度分布を表す標準化された34要素の固定整数配列へと変換します。これにより、組み合わせの探索空間を階乗の複雑さから線形静的制約へと縮小し、コンパイル負荷（ASTオーバーヘッド）を保護します。 - is_standard_form(int counts): 34要素のマトリックスが、標準的な終了状態グループ形式（4面子1雀頭）を満たしているかを決定論的に評価する組み合わせ探索エンジンです。再帰的なバックトラッキング・メモリポインタを実行し、ライブコンパイル環境下で100%の数学的妥当性を保証します。
Библиотека Pine Script®
от ALT_analyst
GB_JSON_LibLibrary "GB_JSON_Lib" Alert payload string builders for GB-RMBP+ strategy. N8N JSON entries/exits, Autoview key=value strings, PineConnector CSV. n8n_entry_json(act, mode_lower, ticker, tf, price_now, lev, sug_lev, sl_price, liq_price, order_pct, tp1, tp1p, tp1a, tp2, tp2p, tp2a, tp3, tp3p, tp3a, tp4, tp4p, tp4a, tp5, tp5p, tp5a, tp6, tp6p, tp6a)   Build the N8N entry-side JSON payload, byte-identical to v1.0.77 output.   Parameters:      act (simple string) : "buy" or "sell"      mode_lower (simple string) : Execution mode in lowercase (stealth/hybrid/visible)      ticker (simple string) : syminfo.ticker      tf (simple string) : timeframe.period      price_now (float) : close      lev (float) : Final effective leverage used for the order      sug_lev (float) : Suggested leverage from risk-loss calculation      sl_price (float) : Stop-loss price (or 0 if none)      liq_price (float) : Calculated liquidation price      order_pct (float) : Order size as % of equity      tp1 (float)      tp1p (float)      tp1a (bool)      tp2 (float)      tp2p (float)      tp2a (bool)      tp3 (float)      tp3p (float)      tp3a (bool)      tp4 (float)      tp4p (float)      tp4a (bool)      tp5 (float)      tp5p (float)      tp5a (bool)      tp6 (float)      tp6p (float)      tp6a (bool)   Returns: JSON string n8n_tp_exit_json(act, ticker, tp_idx, tp_pct, pos_size)   Build per-TP exit JSON payload.   Parameters:      act (simple string) : "closelong" or "closeshort"      ticker (simple string) : syminfo.ticker      tp_idx (int) : TP number 1..6      tp_pct (float) : Exit % for this TP      pos_size (float) : math.abs(strategy.position_size)   Returns: JSON string n8n_close_json(act, ticker)   Build a full-position close JSON payload.   Parameters:      act (simple string) : "closelong" or "closeshort"      ticker (simple string) : syminfo.ticker   Returns: JSON string n8n_order_pct(qty, price, lev, equity)   Compute order size as percentage of equity.   Parameters:      qty (float) : Final order quantity      price (float) : Current close      lev (float) : Effective leverage      equity (float) : strategy.equity   Returns: Rounded percentage to 4 decimals av_entry_str(user, side, exchange, lev, symbol, ccy, testing)   Build Autoview entry command string. Uses Pine placeholder '{{strategy.order.contracts}}' for the quantity.   Parameters:      user (simple string) : Acct identifier      side (simple string) : "long" or "short"      exchange (simple string) : Exchange name      lev (float) : Leverage value      symbol (simple string) : Symbol string      ccy (simple string) : "currency" or "contracts"      testing (simple string) : "" or " d=1"   Returns: Autoview-formatted command string av_exit_str(user, side, exchange, symbol, ccy, testing, is_short)   Build Autoview exit command string. Short exits append "%" to qty per v1.0.77.   Parameters:      user (simple string) : Acct identifier      side (simple string) : "long" or "short"      exchange (simple string) : Exchange name      symbol (simple string) : Symbol string      ccy (simple string) : "currency" or "contracts"      testing (simple string) : "" or " d=1"      is_short (simple bool) : True if this is a short exit (appends "%")   Returns: Autoview-formatted command string pc_alert_str(licence_id, symbol)   Build PineConnector CSV alert payload. Uses Pine placeholders for action and contracts.   Parameters:      licence_id (int) : Numeric license ID      symbol (simple string) : Symbol with optional suffix (e.g. "EURUSD.a")   Returns: CSV-formatted command string
Библиотека Pine Script®
от GreedyBastardpro
GB_Cond_LibLibrary "GB_Cond_Lib" Condition operator evaluator + AND/OR combiner for GB-RMBP+ strategy. Replaces 12-branch ternary chains and the 50-branch combiner used for external filter rules. eval_cond_op(v1, op, v2)   Evaluate a binary condition between two series given an operator string.   Parameters:      v1 (float) : Left-hand series      op (simple string) : Operator: "CrossUp", "CrossDown", ">", ">=", "<", "<=", "==", "> Previous", ">= Previous", "< Previous", "<= Previous", "== Previous"      v2 (float) : Right-hand series   Returns: Boolean result; false if op is unrecognized (including "🚫 None") eval_cond_op_with_default(v1, op, v2, default_true)   Same as eval_cond_op, but if op is unrecognized returns `default_true` (preserves the v1.0.77 quirk for LCond5/SCond5 which used `(make_custom ? true : true)` fallback).   Parameters:      v1 (float) : Left-hand series      op (simple string) : Operator string      v2 (float) : Right-hand series      default_true (bool) : Value returned when op is "🚫 None" or unknown combine_AND(u1, u2, u3, u4, u5, c1, c2, c3, c4, c5, make_custom)   Combine 5 condition booleans with AND, gated by 5 "use" flags. Matches v1.0.77 condition_function_AND exactly: if no flags are checked, returns (make_custom ? false : true) — the strategy's "no filters = pass" default.   Parameters:      u1 (simple bool)      u2 (simple bool)      u3 (simple bool)      u4 (simple bool)      u5 (simple bool)      c1 (bool)      c2 (bool)      c3 (bool)      c4 (bool)      c5 (bool)      make_custom (simple bool) : The make_custom strategy flag   Returns: Combined boolean combine_OR(u1, u2, u3, u4, u5, c1, c2, c3, c4, c5, make_custom)   Combine 5 condition booleans with OR, gated by 5 "use" flags. Matches v1.0.77 condition_function_OR exactly.   Parameters:      u1 (simple bool)      u2 (simple bool)      u3 (simple bool)      u4 (simple bool)      u5 (simple bool)      c1 (bool)      c2 (bool)      c3 (bool)      c4 (bool)      c5 (bool)      make_custom (simple bool)
Библиотека Pine Script®
от GreedyBastardpro
GB_MA_LibLibrary "GB_MA_Lib" Moving Average bank + timeframe helper for GB-RMBP+ strategy. 22 MA implementations as standalone pure functions, plus htf_for_period. Functions are lazy: only the one you call actually computes. calc_sma(src, len)   Simple Moving Average   Parameters:      src (simple float) : Source series      len (simple int) : Length   Returns: SMA series calc_ema(src, len)   Exponential Moving Average   Parameters:      src (simple float)      len (simple int) calc_hma(src, len)   Hull Moving Average   Parameters:      src (simple float)      len (simple int) calc_wma(src, len)   Weighted Moving Average   Parameters:      src (simple float)      len (simple int) calc_vwma(src, len)   Volume Weighted Moving Average   Parameters:      src (simple float)      len (simple int) calc_rma(src, len)   Wilder/Running Moving Average   Parameters:      src (simple float)      len (simple int) calc_alma(src, len)   Arnaud Legoux Moving Average   Parameters:      src (simple float)      len (simple int) calc_swma(src)   Symmetrically-Weighted Moving Average (length fixed by Pine)   Parameters:      src (simple float) calc_dema(src, len)   Double Exponential Moving Average   Parameters:      src (simple float)      len (simple int) calc_tema(src, len)   Triple Exponential Moving Average   Parameters:      src (simple float)      len (simple int) calc_zema(src, len)   Zero-lag EMA variant (EMA1 + difference)   Parameters:      src (simple float)      len (simple int) calc_zlema(src, len)   Zero-Lag EMA   Parameters:      src (simple float)      len (simple int) calc_trama(src, len)   TRAMA (Trend-Regularity Adaptive MA, Lux Algo)   Parameters:      src (simple float)      len (simple int) calc_pkama(src, len)   P-KAMA (Power-Kaufman Adaptive MA)   Parameters:      src (simple float)      len (simple int) calc_t3(src, len)   T3 Moving Average   Parameters:      src (simple float)      len (simple int) calc_tma(src, len)   Triangular Moving Average   Parameters:      src (simple float)      len (simple int) calc_var(src, len)   VAR (Variable Index Dynamic MA-like)   Parameters:      src (simple float)      len (simple int) calc_tsf(src, len)   Time Series Forecast   Parameters:      src (simple float)      len (simple int) calc_zlsma(src, len)   Zero-Lag Least-Squares Moving Average   Parameters:      src (simple float)      len (simple int) calc_mcginley(src, len)   McGinley Dynamic   Parameters:      src (simple float)      len (simple int) calc_zldema(src, len)   Zero-Lag DEMA   Parameters:      src (simple float)      len (simple int) calc_zltema(src, len)   Zero-Lag TEMA   Parameters:      src (simple float)      len (simple int) htf_for_period(tf)   Maps chart timeframe to a higher timeframe string (used for HTF MA bias).   Parameters:      tf (simple string) : Current timeframe.period   Returns: HTF string for request.security
Библиотека Pine Script®
от GreedyBastardpro
CyberCausalityLib# CyberCausalityLib v17 CyberCausalityLib provides information-theoretic and econometric causality detection for identifying directional influence between price series, filtering spurious correlations, and detecting lead-lag relationships across assets. ## What it does Delivers 15+ causality functions in three categories: Transfer Entropy (information-theoretic directional causality), Granger Causality (econometric lagged correlation), and PCMCI filtering (partial correlation mediation for spurious causality detection). Answers questions like "Does Bitcoin volume predict Ethereum price?" and "Is Asset A→B correlation direct or mediated by Asset C?" Outputs causality scores, directional indicators, and optimal lag values for multi-basket aggregation, lead-lag pair trading, and filtering false correlations driven by common factors. ## How it works Transfer Entropy measures directional information flow: `TE(X→Y) = H(Y_t | Y_{t-1}) - H(Y_t | Y_{t-1}, X_{t-lag})` using Shannon entropy. Discretizes price data into 4-8 bins, calculates joint/conditional entropies. Higher TE = X predicts future Y beyond Y's own history. Granger Causality aggregates lagged correlations: `Granger = Σ(w_i × corr(Y_t, X_{t-i}))` with weights `w_i = |corr_i| / Σ|corr_j|`. Supports Pearson/Spearman/Kendall. Returns magnitude + directional coefficient. PCMCI filtering detects spurious causality via partial correlation: `ρ(X,Y|Z)`. If partial << raw correlation, Z mediates X→Y (indirect causality). Reduces score proportionally. ## Why this is original First TradingView library with information-theoretic causality. Pine has no native entropy, Granger tests, or partial correlation. Existing libraries offer only basic correlation without directionality or lag optimization. Unique features: - Transfer Entropy with Shannon entropy discretization - Granger Causality with auto-lag search (1-10) - PCMCI filtering (up to 4 mediators) - Ensemble aggregation (5 baskets) - Möbius transformation state tracking No other Pine library combines information theory, econometrics, and graph-based causality with NA guards and graceful degradation. ## How to use it ```pine //@version=6 indicator("CyberCausalityLib Demo", overlay=false) import cybermediaboy/CyberCausalityLib/17 as C import cybermediaboy/NumLib/4 as N // Transfer Entropy: Does volume predict price? var price_buf = array.new() var vol_buf = array.new() if bar_index >= 99 array.clear(price_buf) array.clear(vol_buf) for i = 0 to 99 array.push(price_buf, close ) array.push(vol_buf, volume ) = C.f_calculate_te_score_v2( price_buf, vol_buf, 100, 5, 2 ) // te_score > 0.15 → volume predicts price plot(te_score, "TE Score", color.blue) // Granger Causality: Lead-lag detection var x_buf = array.new() var y_buf = array.new() // ...populate buffers... = C.f_calculate_granger_score( y_buf, x_buf, 100, 5, "Pearson" ) // granger > 0.3 → X Granger-causes Y // PCMCI Filtering: Remove spurious correlation = C.f_calculate_granger_score(y_buf, x_buf, 100, 5, "Pearson") filtered = C.f_pcmci_filter_score( raw, y_buf, x_buf, mediator_buf, array.new(), array.new(), array.new(), 100 ) // filtered << raw → indirect causality ``` ## Key functions - `f_calculate_te_score_v2()` - Transfer Entropy (recommended) - `f_calculate_granger_score()` - Granger Causality with lag search - `f_pcmci_filter_score()` - Spurious correlation filtering - `f_compute_te_ensemble()` - Multi-basket aggregation - `f_shannon_entropy()` - Shannon entropy calculation - `MobiusState` UDT - Non-linear state tracking ## Dependencies Requires NumLib v4 for correlation functions (Pearson/Spearman/Kendall). ```pine import cybermediaboy/CyberCausalityLib/17 as C import cybermediaboy/NumLib/4 as N ``` ## Version history - **v17** (2026-04-17): Added HAR-RV forecast, Durbin-Watson autocorrelation test, PCA explained variance, improved entropy discretization (v2 algorithm) - **v16** (2026-03-xx): Added PCMCI filtering, Möbius state tracking UDT - **v15** (2026-02-xx): Added Granger causality, multi-lag search, correlation at lag - **v14** (2026-01-xx): Initial release with Transfer Entropy, ensemble aggregation ## License Mozilla Public License 2.0 ## Author © cybermediaboy ## Support For questions, bug reports, or feature requests, comment on the library publication page or reference the source code documentation.
Библиотека Pine Script®
от cybermediaboy
1
RegimeLibLibrary "RegimeLib" RegimeLib — Bayesian online change-point detection (BOCPD) with score-driven variance. Implements Tsaknaki, Lillo, Mazzarisi 2023 (arXiv:2307.02375) score-driven extension to Adams & MacKay 2007 BOCPD. Maintains run-length distribution P(r_t | data_{1:t}) and detects regime changes when MAP run length resets. Layer L0 (imports NumLib/4 for math helpers only). DESIGN DECISIONS: 1. Score-driven variance adaptation (GARCH-like) handles heteroskedasticity. 2. Broadcast pattern: single BOCPD instance shared across multiple setups via regime_id. 3. varip state arrays (run_length_probs, run_means, run_variances) persist across bars. 4. Compute cost: O(L) per bar where L = max_run_length (default 100). f_default_regime_reading()   Create default RegimeReading   Returns: Empty RegimeReading f_bocpd_regime_score_driven(x, hazard, max_run_length, omega, alpha, beta, rl_probs, run_means, run_vars, prev_map, regime_counter)   BOCPD with score-driven variance adaptation (Tsaknaki et al. 2023)   Parameters:      x (float) : Current observation (e.g. log return)      hazard (simple float) : Hazard rate H (probability of regime change per bar), default 1/250      max_run_length (simple int) : Maximum run length L to track (caps array size), default 100      omega (simple float) : Score-driven variance ω parameter, default 1e-4      alpha (simple float) : Score-driven variance α parameter (score weight), default 0.05      beta (simple float) : Score-driven variance β parameter (persistence), default 0.94      rl_probs (array) : varip array run-length probabilities (size L+1, caller-managed)      run_means (array) : varip array online means per run (size L+1, caller-managed)      run_vars (array) : varip array online variances per run (size L+1, caller-managed)      prev_map (int) : varip int previous MAP run length (caller-managed)      regime_counter (float) : varip float regime ID counter (caller-managed)   Returns: RegimeReading f_bocpd_regime(x, hazard, max_run_length, rl_probs, run_means, run_vars, prev_map, regime_counter)   Vanilla BOCPD (fixed variance, no score-driven adaptation)   Parameters:      x (float) : Current observation      hazard (simple float) : Hazard rate H      max_run_length (simple int) : Maximum run length L      rl_probs (array) : varip array run-length probabilities (caller-managed)      run_means (array) : varip array online means per run (caller-managed)      run_vars (array) : varip array online variances per run (caller-managed)      prev_map (int) : varip int previous MAP run length (caller-managed)      regime_counter (float) : varip float regime ID counter (caller-managed)   Returns: RegimeReading f_init_bocpd_state(max_run_length, initial_mean, initial_var)   Initialize BOCPD state arrays (call once on first bar)   Parameters:      max_run_length (simple int) : Maximum run length L      initial_mean (float) : Initial mean estimate      initial_var (float) : Initial variance estimate   Returns: Tuple of (rl_probs, run_means, run_vars) RegimeReading   RegimeReading — output of BOCPD regime detector   Fields:      map_run_length (series int) : Current MAP run length (bars since last regime change)      change_point_detected (series bool) : True if regime change detected on this bar      regime_id (series float) : Incrementing counter per regime (resets on change-point)      predictive_likelihood (series float) : Diagnostic: P(x_t | data_in_run_r*)      current_variance (series float) : Score-driven variance estimate at MAP run length
Библиотека Pine Script®
от cybermediaboy
OscLibLibrary "OscLib" OscLib — Oscillator primitives and normalization utilities. Provides centered/clamped normalization for bounded and unbounded oscillators, multi-oscillator dispatcher, and pivot-based divergence detection. Architecture: L0 (no library dependencies, uses ta.* primitives only) f_center_bounded(raw, midpoint)   Centered normalization for bounded oscillators (RSI, MFI, Stoch, WPR)   Parameters:      raw (float) : Raw oscillator value      midpoint (float) : Center point (typically 50.0 for RSI/MFI/Stoch)   Returns: Centered value in range f_clamp_normalize(raw, threshold)   Clamped normalization for unbounded oscillators (CCI, MACD Hist, ATR)   Parameters:      raw (float) : Raw oscillator value      threshold (float) : Scaling threshold (e.g., 200 for CCI, 2*ATR for MACD)   Returns: Clamped value in range f_compute_osc(kind, src, len)   Multi-oscillator dispatcher   Parameters:      kind (string) : Oscillator type: "RSI", "CCI", "MFI", "STOCH", "WPR"      src (float) : Source series (typically close or hlc3)      len (simple int) : Oscillator period/length   Returns: Raw oscillator value f_divergence_pivot(osc, price, lb_left, lb_right)   Pivot-based divergence detection (matches REOS production pattern)   Parameters:      osc (float) : Oscillator series      price (float) : Price series (typically close)      lb_left (int) : Left lookback for pivot detection      lb_right (int) : Right lookback for pivot detection   Returns: bearish_div: price makes higher high, oscillator doesn't bullish_div: price makes lower low, oscillator doesn't
Библиотека Pine Script®
от cybermediaboy
fpa_unified_libLibrary "fpa_unified_lib" lineStyle(styleText)   Parameters:      styleText (string) labelSize(sizeText)   Parameters:      sizeText (string) normalizeSession(sessionInput, hideWeekends)   Parameters:      sessionInput (string)      hideWeekends (bool) isSessionActive(sessionInput, timezoneInput)   Parameters:      sessionInput (string)      timezoneInput (string) tfInRange(lowTf, highTf)   Parameters:      lowTf (string)      highTf (string) parseTradingDayOpenMinutes(sessionInput)   Parameters:      sessionInput (string) safeColor(c, transp)   Parameters:      c (color)      transp (int) updateRay(lineRef, shouldShow, startBarIndex, yPrice, lineColor, lineWidth, lineStyleText, rightOffsetBars, lookbackBars)   Parameters:      lineRef (line)      shouldShow (bool)      startBarIndex (int)      yPrice (float)      lineColor (color)      lineWidth (int)      lineStyleText (string)      rightOffsetBars (int)      lookbackBars (int) updateLabel(labelRef, shouldShow, yPrice, textValue, labelColor, rightOffsetBars, sizeText)   Parameters:      labelRef (label)      shouldShow (bool)      yPrice (float)      textValue (string)      labelColor (color)      rightOffsetBars (int)      sizeText (string) trimLines(arr, limit)   Parameters:      arr (array)      limit (int) trimLabels(arr, limit)   Parameters:      arr (array)      limit (int) parseFloatList(textArea)   Parameters:      textArea (string)
Библиотека Pine Script®
от btraemoore
cloudTheoryLibrary "cloudTheory" // OBJECTTIVE: A Combination of EMA to Draw Cloud Pattern on Chart // // The "2-EMA Line System" is one of the most oldest and durable // frameworks in technical analysis where we plot one "fast" (short) // and one "slow" (long) exponential moving average line on the same // chart and their relationships determine the state of the security. drawCloud(fastLength, slowLength, src)   Parameters:      fastLength (simple int) : - Fast EMA Length, the shorter length which typically determines the current rhythm of the security.      slowLength (simple int) : - Slow EMA Length, the longer length which determines the underlying drift of the security.      src (float) : - Which value of the candle should be used to calculate the moving average; defaults to candle close value.   Returns: - EMA Values and the flags to determine the current sentiment.
Библиотека Pine Script®
от ZenithClown
si_squeeze_live_summaryLibrary "si_squeeze_live_summary" Lane-owned live summary entrypoint for the squeeze / expansion prototype. Staged for future host wiring without moving squeeze logic into the meta layer. calc_squeeze_live_summary(regime_fast_length, regime_slow_length, regime_compression_length, regime_atr_length, regime_compression_threshold, structure_pivot_left, structure_pivot_right, structure_basis_length, structure_displacement_atr, fair_value_atr_length, fair_value_extreme_atr)   Public host-callable live squeeze summary surface. Returns the standardized 10-field primitive tuple.   Parameters:      regime_fast_length (simple int)      regime_slow_length (simple int)      regime_compression_length (int)      regime_atr_length (simple int)      regime_compression_threshold (float)      structure_pivot_left (int)      structure_pivot_right (int)      structure_basis_length (simple int)      structure_displacement_atr (float)      fair_value_atr_length (simple int)      fair_value_extreme_atr (float)
Библиотека Pine Script®
от rovurfmovviy
EntropyLibLibrary "EntropyLib" Entropy Library - Composite entropy calculation for oscillators with binary and ternary modes f_clamp(x, lo, hi)   Clamp value to range   Parameters:      x (float) : Value to clamp      lo (float) : Lower bound      hi (float) : Upper bound   Returns: Clamped value f_binary_entropy(x, length)   Calculate Shannon binary entropy from a series   Parameters:      x (float) : Input series (oscillator, price changes, etc.)      length (int) : Lookback period for entropy calculation   Returns: Binary entropy value where 0=deterministic, 1=maximum uncertainty f_ternary_entropy(x, length, flatPct)   Calculate ternary entropy (up/down/flat states)   Parameters:      x (float) : Input series      length (int) : Lookback period for entropy calculation      flatPct (simple float) : Percentile threshold for flat zone (e.g., 55.0 means middle 55% is "flat")   Returns: Ternary entropy value f_composite_entropy(osc, price, volume, length, osc_weight, price_weight, vol_weight, mode, flatPct)   Calculate composite entropy from oscillator, price, and volume components   Parameters:      osc (float) : Primary oscillator series      price (float) : Price series (typically close)      volume (float) : Volume series      length (int) : Lookback period for entropy calculation      osc_weight (float) : Weight for oscillator entropy component (e.g., 0.4)      price_weight (float) : Weight for price entropy component (e.g., 0.4)      vol_weight (float) : Weight for volume entropy component (e.g., 0.2)      mode (string) : Entropy mode: "binary" or "ternary"      flatPct (simple float) : Percentile for ternary flat zone (only used if mode="ternary", default 55.0)   Returns: Composite entropy f_composite_entropy_simple(osc, length, mode, flatPct)   Simplified composite entropy using only oscillator   Parameters:      osc (float) : Oscillator series      length (int) : Lookback period      mode (string) : Entropy mode: "binary" or "ternary"      flatPct (simple float) : Percentile for ternary flat zone (default 55.0)   Returns: Composite entropy f_composite_entropy_standard(osc, price, length, mode, flatPct)   Standard composite entropy with oscillator + price (50/50 split, no volume)   Parameters:      osc (float) : Oscillator series      price (float) : Price series      length (int) : Lookback period      mode (string) : Entropy mode: "binary" or "ternary"      flatPct (simple float) : Percentile for ternary flat zone (default 55.0)   Returns: Composite entropy f_entropy_weighted_signal(signal, entropy)   Apply entropy weighting to a signal (REOS-style formula)   Parameters:      signal (float) : Input signal/oscillator      entropy (float) : Entropy value   Returns: Entropy-weighted signal: sign(signal) * |signal| * (1 - entropy) f_detect_true_pivots(osc_series, price_series, pivot_left, pivot_right, entropy_len, max_entropy)   Detects true structural pivots by filtering out high-entropy noise   Parameters:      osc_series (float) : The oscillator series to evaluate      price_series (float) : The underlying price series      pivot_left (int) : Bars to the left of the pivot      pivot_right (int) : Bars to the right of the pivot      entropy_len (int) : Lookback window for entropy calculation (usually 8-14)      max_entropy (float) : The maximum allowed joint entropy for a valid pivot (e.g., 0.4)   Returns: - True pivot flags and pivot values f_detect_spring(osc_series, price_series, chaos_len, osc_overbought, osc_oversold, min_chaos)   Detects extreme market compression (chaos) at oscillator extremes   Parameters:      osc_series (float) : The oscillator series to evaluate      price_series (float) : The underlying price series      chaos_len (int) : Ultra-short lookback window (e.g., 3, 4, or 5 bars)      osc_overbought (float) : The upper extreme threshold (e.g., 90)      osc_oversold (float) : The lower extreme threshold (e.g., 10)      min_chaos (float) : The minimum joint entropy required to signal compression (e.g., 0.8)   Returns: - Spring flag and chaos intensity f_optimize_thresholds(osc_series, base_ob, base_os, entropy_len, expansion_factor)   Dynamically adjusts OB/OS levels based on background entropy   Parameters:      osc_series (float) : The oscillator series      base_ob (float) : The baseline overbought level (e.g., 80)      base_os (float) : The baseline oversold level (e.g., 20)      entropy_len (int) : Lookback for the background entropy evaluation (e.g., 30)      expansion_factor (float) : How much the bands can expand/contract (e.g., 10.0 points)   Returns: - Adaptive overbought and oversold thresholds
Библиотека Pine Script®
от cybermediaboy
1
rangeBreakoutLibrary "rangeBreakout" markRange(trackTimePeriod, drawTimePeriod, highLineColor, lowLineColor, middleLineColor, maxLookbackDays)   Parameters:      trackTimePeriod (simple string) : - Time range for which the high and low values are tracked. This is the range; any breakout above/below this period can indicate a potential long/short entry condition.      drawTimePeriod (simple string) : - Time range for which the range is valid, this is typically from the end of the `trackTimePeriod` to the end of the day (or session) for security.      highLineColor (color)      lowLineColor (color)      middleLineColor (color)      maxLookbackDays (simple int) : - Number of historic days to retain the range value.   Returns: - Values to print the range values, and a boolean indicator that indicates if the current time is within the tracking time period. The library can then be forward integrated into other indicators, strategies, and other libraries of TradingView, thus one function can be used globally.
Библиотека Pine Script®
от ZenithClown
OriginLifecycleLibrary "OriginLifecycle" Strict Highlander v7 origin lifecycle for engulfing indicators. Exports enums, an OriginCandidate UDT, and four helper functions used by engulfing_opportunities_v20.6+ to detect, track, promote, invalidate, and consume origin levels discovered on lower timeframes inside an engulfment zone. Published-as-library rationale: the engulfing indicator is already at Pine v6's top-level-declaration limit (CE10295). Moving these types and functions into a library frees ~7 declarations in the main script without changing semantics. Reference: highlander_v7.pine:212-293 for the state-transition rules this implementation mirrors. tickStateMachine(c, bO, bH, bL, bC, bTime)   Pure state-transition function. One closed LTF bar in, updated candidate out. Mirrors highlander_v7.pine:212-293.   Parameters:      c (OriginCandidate) : The current candidate state.      bO (float) : Bar open.      bH (float) : Bar high.      bL (float) : Bar low.      bC (float) : Bar close.      bTime (int) : Bar start time in ms.   Returns: Updated OriginCandidate with `lastProcessedTime := bTime`. Caller is responsible for: - Only passing CLOSED LTF bars. - Skipping bars whose time <= c.lastProcessedTime. - On BROKEN_BSUT, looking for a retest in subsequent bars to delete. scanForBreakCandidates(isBullish, zoneLow, zoneHigh, prevO, prevH, prevL, prevC, prevT, currO, currH, currL, currC, currT, ltfValid, ltfMin, tfLabel, outCandidates)   Find new BREAK pairs in the engulfment zone and push them to `outCandidates` if not already tracked. De-dup key is (price, createdTime, tfLabel).   Parameters:      isBullish (bool) : true -> look for SUPPORT (green-green) pairs; false -> look for RESISTANCE (red-red) pairs.      zoneLow (float) : Lower bound of the engulfment zone (inclusive).      zoneHigh (float) : Upper bound of the engulfment zone (inclusive).      prevO (array)      prevH (array)      prevL (array)      prevC (array)      prevT (array)      currO (array)      currH (array)      currL (array)      currC (array)      currT (array)      ltfValid (bool) : Pre-computed validity flag for this LTF.      ltfMin (int) : LTF length in minutes (baked into each new candidate).      tfLabel (string) : Display string, e.g. "1H".      outCandidates (array) : The per-pattern candidate array to push into.   Returns: Nothing (mutates outCandidates). processNewLTFBars(candidates, ltfMin, prevO, prevH, prevL, prevC, prevT, currO, currH, currL, currC, currT, ltfValid)   Drive the state machine across unprocessed LTF bars for every candidate whose `ltfMinutes == ltfMin`. Removes candidates that reach BROKEN_BSUT AND see a retest within the buffer.   Parameters:      candidates (array) : The per-pattern candidate array to update.      ltfMin (int) : The LTF length this buffer represents; candidates with a different ltfMinutes are skipped.      prevO (array)      prevH (array)      prevL (array)      prevC (array)      prevT (array)      currO (array)      currH (array)      currL (array)      currC (array)      currT (array)      ltfValid (bool) : Validity flag.   Returns: Nothing (mutates candidates). applyConsumedOnTouch(candidates, greedyEntries, greedyConsumedFlags, isBullish, curLow, curHigh)   Per-tick sweep. Marks CONFIRMED origins and untouched greedy entries as consumed once price wicks into them. Caller passes `curLow`/`curHigh` because library functions cannot reference the `low`/`high` chart globals directly.   Parameters:      candidates (array) : Per-pattern origin-candidate array.      greedyEntries (array) : Per-pattern greedy-entry price array.      greedyConsumedFlags (array) : Parallel bool array — resized lazily to match greedyEntries size.      isBullish (bool) : Drives the touch check for greedy entries (origins use their own per-candidate dir).      curLow (float) : Current bar low (pass `low` from caller).      curHigh (float) : Current bar high (pass `high` from caller).   Returns: Nothing (mutates both arrays). OriginCandidate   A single tracked origin candidate.   Fields:      tfLabel (series string) : Display string ("1H", "5m" etc.).      ltfMinutes (series int) : Lower-timeframe length in minutes; used for the      price (series float) : The origin level price.      dir (series OriginDir) : UP (support) or DOWN (resistance).      state (series OriginState) : Current lifecycle state.      firstTouchTime (series int) : ms timestamp of first touch (0 if `touchSeen == false`).      touchSeen (series bool) : True once this candidate has been touched at least once.      createdTime (series int) : ms timestamp of the d1 bar that formed the BREAK pair.      lastProcessedTime (series int) : ms timestamp of the last LTF bar fed through the      consecutiveDirCount (series int) : Counter for 2-bar CONFIRMED confirmation, 0-2.
Библиотека Pine Script®
от HybriD_ez
KernelLens🟦 KernelLens is a professional kernel regression library for Pine Script v6, providing eight mathematically rigorous Nadaraya–Watson estimators, a three-mode filter layer, a unified string dispatcher, and a suite of trading utilities — all built from the ground up on correct non-parametric statistics. Unlike existing Pine smoothing libraries — which inherit a decade-old loop-bound bug that silently reduces every kernel window to a handful of bars, regardless of the bandwidth parameter — KernelLens is built with auditable math, NA-safe iteration, input validation at every entry point, and academic references cited inline next to the formulas they describe. The library integrates eight independent kernel families — Rational Quadratic, Gaussian, Periodic, Locally Periodic, Epanechnikov, Tricube, Triangular, and Cosine — behind a consistent API, with every raw estimator wrapped in a filter layer (None / Smooth / Zero Lag), a unified dispatcher for dropdown-driven kernel selection, and five utility exports covering slope detection, trend state, crossover signaling, residual confidence bands, and Silverman's rule-of-thumb bandwidth recommendation. Every public function validates its inputs, raises descriptive runtime errors on misuse, and returns `na` only when there is genuinely no data — never as a silent fallback. 🟦 MATHEMATICAL FOUNDATION **The Nadaraya–Watson Estimator** Given a source series `y_t` and a symmetric kernel `K` with scale parameter `ℓ` (the "bandwidth"), the Nadaraya–Watson estimator of the regression function `m(x) = E ` evaluated at the current bar is: ``` Σᵢ K(dᵢ / ℓ) · y_{t−i} ŷ(t) = ─────────────────────── Σᵢ K(dᵢ / ℓ) ``` where `dᵢ` is the bar-distance from the kernel center and the sum runs over a finite window determined by the effective support of `K`. The estimator is a locally weighted average: bars close to the kernel center contribute heavily, distant bars contribute proportionally less, and bars outside the support contribute nothing. It is asymptotically unbiased up to `O(ℓ²)` for twice-differentiable `m`, with variance of order `(n·ℓ)⁻¹` — the classical bias–variance trade-off that defines all non-parametric smoothers. **Why Kernel Regression Beats Rolling Means** A simple moving average gives every bar in the window the same weight. Kernel regression gives each bar a weight that decays smoothly with distance, producing: - **Smoother output** — no step artifacts when bars enter / leave the window - **Better bias control** — the peak of the kernel sits exactly on the point being estimated - **Kernel-specific behavior** — compact-support kernels eliminate tail contamination entirely; Rational Quadratic's `α` parameter exposes multi-scale mixing; Periodic kernels resonate with known cycle lengths The math has been the academic standard for non-parametric regression since Nadaraya (1964) and Watson (1964). KernelLens brings it to Pine Script v6 in its correct, bug-free form. 🟦 THE EIGHT KERNELS All eight kernels implement the Nadaraya–Watson weighting scheme. They differ in support (compact versus infinite), smoothness (how many times differentiable), and how weight decays with distance. | # | Kernel | Formula | Support | Smoothness | Character | |---|---|---|---|---|---| | 1 | **Rational Quadratic** | `(1 + d² / (2·α·ℓ²))^(−α)` | ℝ | C∞ | Multi-scale mixer — `α` controls stretch versus wiggle | | 2 | **Gaussian (RBF)** | `exp(−d² / (2·ℓ²))` | ℝ | C∞ | The canonical smoother — smoothest possible with L² optimality | | 3 | **Periodic** | `exp(−2·sin²(π·d/p) / ℓ²)` | ℝ | C∞ | Resonates with repetition distance `p` — ideal for cycles | | 4 | **Locally Periodic** | Periodic · Gaussian | ℝ | C∞ | Seasonal patterns that slowly drift with trend | | 5 | **Epanechnikov** | `(3/4)(1 − u²) · 𝟙{|u|≤1}` | | C⁰ | Asymptotically MSE-optimal (Watson 1964) — no tail contamination | | 6 | **Tricube** | `(70/81)(1 − \|u\|³)³ · 𝟙{|u|≤1}` | | C² | The LOWESS standard — near-Gaussian with compact support | | 7 | **Triangular** | `(1 − \|u\|) · 𝟙{|u|≤1}` | | C⁰ | Simplest non-uniform kernel — fastest to compute | | 8 | **Cosine** | `(π/4)·cos(π·u/2) · 𝟙{|u|≤1}` | | C¹ | Raised-cosine taper — smoother boundary than Epanechnikov | where `u = d/ℓ` and `𝟙` is the indicator function. **Infinite-Support vs Compact-Support — Why Both Matter** | | Infinite Support (RQ, Gauss, Periodic, LocPeriodic) | Compact Support (Epa, Tricube, Triangular, Cosine) | |---|---|---| | **Tail weight** | Never exactly zero | Exactly zero beyond ±ℓ | | **Loop depth** | `3·ℓ` (3-σ cutoff, ≈99.7% mass) | Exactly `ℓ` | | **Bar contamination** | Distant bars still pull the estimate a tiny amount | Distant bars cannot affect the estimate at all | | **Best for** | Smooth trends, Gaussian-process intuition | Robust regression, outlier resistance | KernelLens picks the correct loop depth automatically based on kernel family: `_depthInfinite` for Gaussian-family kernels, `_depthCompact` for bounded kernels, `_depthPeriodic` for Periodic (which must span enough cycles to reach stable weights). **Why Eight, Not Four** Most Pine kernel libraries ship only the four kernels from MacKay's Gaussian process tutorial. KernelLens adds the four compact-support classical kernels because: - **Epanechnikov** minimises asymptotic mean squared error among all non-negative kernels of bounded support (Watson 1964) — it is the MSE-optimal baseline against which all other kernels are measured - **Tricube** is the kernel used by LOWESS (Cleveland 1979), the de-facto standard for robust locally weighted scatterplot smoothing - **Triangular** is the cheapest non-uniform compact kernel — useful when loop-budget matters on intraday charts with huge dataset size - **Cosine** is C¹-continuous at the support boundary, unlike Epanechnikov's C⁰ discontinuity, producing visibly smoother transitions at kernel edges Adding them makes the library an academically complete toolkit, not just a Pine port of one tutorial. 🟦 FILTER LAYER — NONE / SMOOTH / ZERO LAG Every kernel export accepts a `_filter` parameter with three valid values. The filter layer is implemented identically across all eight kernels, so switching kernel families does not change filter behavior. **"No Filter" — Single-Pass Raw Estimate** ``` ŷ = K(y) ``` One Nadaraya–Watson pass over the source. Cheapest mode, most reactive, fully represents the underlying kernel. Use this when you want the kernel's raw behavior with no additional smoothing or lag correction. **"Smooth" — Double-Pass Estimate** ``` ŷ = K(K(y)) ``` The kernel is applied once to the source, then applied again to its own output using the same bandwidth and the same parameters. The result is a more strongly smoothed curve at the cost of one extra loop pass per bar. This is mathematically equivalent to convolving the kernel with itself — the effective kernel is wider and flatter, pulling longer-range context into each estimate without requiring the user to double the bandwidth. **"Zero Lag" — Ehlers De-Lagged Estimate** ``` ŷ = 2·K(y) − K(K(y)) ``` The ZLEMA identity from Ehlers (*Rocket Science for Traders*, 2000): subtract the smoothing lag from the raw estimate, effectively shifting the output back in time to match the source more closely. The intuition: `K(y)` lags `y` by some amount; `K(K(y))` lags `K(y)` by the same amount; so `K(y) − K(K(y))` is an estimate of the lag itself, and adding it back to `K(y)` cancels out. The result tracks the source more tightly than either pass alone, at the cost of slightly noisier turning points. **Lazy Evaluation — No Wasted Cycles** In `"No Filter"` mode, the second pass is skipped entirely — it never runs. The filter branch uses an `if` block (not a ternary), so Pine's short-circuit semantics prevent the unused computation. A single kernel call costs one pass; `"Smooth"` or `"Zero Lag"` costs two. You only pay for what you use. 🟦 KERNEL CENTER OFFSET — THE `_phase` PARAMETER Every KernelLens kernel takes a `_phase` parameter that shifts the kernel center into the past by `_phase` bars. It is the library's non-repainting knob. **_phase = 0 — Live Estimate** The kernel is centered on the current bar. The most recent price has maximum weight, and the estimate is as fresh as possible. Suitable for live signal generation, but the most recent bar can re-evaluate as it develops within its interval — standard Pine real-time behavior. **_phase > 0 — Non-Repainting Historical Estimate** The kernel center is moved `_phase` bars into the past. The estimate becomes the smoothed value *at that historical bar*, not the current bar. Once the bar at `bar_index − _phase` is fully confirmed (`barstate.isconfirmed`), its estimate cannot change again. This is the standard trick for publishing kernel indicators that do not repaint: you get a stable, historically accurate curve at the cost of shifting the entire output `_phase` bars to the right on the chart. A `_phase = 25` call gives a curve that lags live price by 25 bars but is guaranteed stable for every past bar. **Why It Belongs in the Library, Not the Caller** Pushing `_phase` into the kernel's own loop is not the same as evaluating the kernel at a shifted source (`K(src )`). Shifting the source just uses a stale input with a current-bar-centered kernel, which still produces a fresh estimate of a stale series. KernelLens's `_phase` genuinely moves the kernel center, producing a historical-bar estimate that computes over the correct surrounding window. 🟦 NON-REPAINTING BEHAVIOR Repainting is the single most-asked question about any Pine indicator, and the single most common source of silent failure when a retail trader moves from backtest to live. A strategy that looks flawless on historical bars and then bleeds money the moment it is deployed is almost always suffering from some form of repainting. KernelLens is engineered from first principles to eliminate every class of repainting by construction — not by patching symptoms, but by removing the dependencies that cause repainting in the first place. **The Two Forms of Repainting** | Form | Symptom | Typical Cause | |---|---|---| | **Historical repainting** | A bar that was closed days or weeks ago silently changes its plotted value when the chart is refreshed or scrolled | `request.security()` with `lookahead = barmerge.lookahead_on`, un-gated higher-timeframe data, or incorrect array rotation that reads into future bars | | **Real-time repainting** | The plotted value on the live (current developing) bar flickers tick-by-tick as new price ticks arrive, then freezes at a final value when the bar closes | The indicator reads `close ` (or any current-bar value) inside a weighted sum — the current-bar weight changes every tick | KernelLens avoids the first kind **entirely and unconditionally**: the library contains no `request.security` calls, no higher-timeframe lookups, no `lookahead_on` usage, and no array rotation that could leak future bars into the window. Every historical bar plotted by any KernelLens kernel is computed exclusively from bars that existed at the time that bar was closed. The plotted history is immutable. Real-time repainting is controlled explicitly by the `_phase` parameter — it is the user's choice whether to accept tick-by-tick flicker on the live bar in exchange for zero lag (`_phase = 0`) or to eliminate the flicker entirely at the cost of a small fixed lag (`_phase ≥ 1`). **Why Kernel Regression Normally Repaints (And How KernelLens Stops It)** A traditional Nadaraya–Watson call centered on the current bar evaluates: ``` ŷ(t) = Σᵢ K(dᵢ/ℓ) · y_{t−i} for i = 0 … depth ``` On the live bar, the term `y_{t−0} = close ` is the current real-time price — which changes on every tick. Every tick moves the weighted sum, every tick moves the estimate, and the trader watching the chart sees the kernel plot flicker as the bar develops. The historical bars (where `close ` for that past bar is now fixed) are stable, but the live plot is unstable. KernelLens's `_phase` parameter shifts the loop so the kernel runs over `i = _phase … _phase + depth`. With `_phase = 2`: ``` ŷ(t) = Σᵢ K((i−2)/ℓ) · y_{t−i} for i = 2 … 2 + depth ``` The sum no longer touches `close ` or `close ` — every bar it reads is already confirmed and cannot change. The live-bar kernel output is therefore identical from the first tick of the bar to the last tick of the bar, and identical again when the bar finally closes. There is no flicker and nothing to repaint. **The Lag / Stability Trade-Off** | `_phase` | Lag on Live Bar | Live-Bar Flicker | Historical Repainting | Best For | |---|---|---|---|---| | **0** | 0 bars | Yes (real-time only; history is stable) | None | Scalping, academic research, calibration | | **1** | 1 bar | None | None | Fast day-trading; minimum acceptable lag for a live trading desk | | **2** | 2 bars | None | None | Default for most users — the sweet spot between freshness and stability | | **3** | 3 bars | None | None | Swing trading — extra margin against false flickers from erratic ticks | | **5+** | 5+ bars | None | None | Position trading, long-term chart analysis, published signal marks | Even at `_phase = 0`, **historical repainting never occurs** — only the live bar flickers during its own development. Once a bar closes, its plotted value is final; scrolling away and back, refreshing the chart, or re-opening TradingView will never change that historical plot. The flicker is exclusively a live-bar tick-by-tick phenomenon. **KernelLens as a Non-Repainting Primitive** KernelLens exposes real-time flicker as an explicit, user-controlled trade-off rather than a hidden behavior. The caller picks any point on the spectrum from "fully live" (`_phase = 0`, maximum reactivity with tick-by-tick flicker) to "fully confirmed" (`_phase ≥ 1`, one or more bars of lag in exchange for a curve that never redraws) with a single integer parameter. Historical repainting — the dangerous form that silently rewrites past plots — is eliminated unconditionally regardless of `_phase`. **How to Verify Non-Repainting Yourself** Do not trust the word "non-repainting" from any library — always verify. KernelLens can be verified in about thirty seconds: 1. Load a chart with KernelLens on it using `_phase = 2` (or any value > 0). 2. Take a screenshot at any specific historical bar. 3. Scroll far to the left, refresh the chart, or reload the indicator. 4. Return to the same bar. The plotted value at that bar must be pixel-identical to the screenshot — because the computation on that bar used only the bars before it, which have not changed. 5. Repeat with `_phase = 0`. The historical bars must still be pixel-identical — only the live bar's plot can differ between observations, and only because the live bar's `close` is now a different number than it was when you took the screenshot. For a stricter test, use TradingView's **Bar Replay** mode. Enable Bar Replay, step forward one bar at a time, and watch the kernel plot on each newly-closed bar. With `_phase ≥ 1`, the value plotted on each newly-closed bar will exactly match what the indicator shows after you exit replay mode and view the same bar normally. This is the gold-standard test — Bar Replay reproduces live-bar tick arrival in a controlled way. **Common Misconceptions** > *"Any Pine indicator that uses `close` repaints."* False. Using `close` on a confirmed bar does not repaint — the confirmed bar's close is locked. What can repaint is using `close` on the live bar, and only within that live bar's interval. KernelLens with `_phase > 0` never reads the live-bar close at all. > *"`lookahead = barmerge.lookahead_on` is always wrong."* Context-dependent. `lookahead_on` is used correctly in some multi-timeframe indicators to request a higher-TF value that is already settled on the lower TF. KernelLens does not use `request.security` at all, so this question does not apply — but for libraries that do, `lookahead_on` is only problematic when it leaks values from bars that were not yet closed at the lower-TF time of evaluation. > *"Non-repainting means zero lag."* False. Zero lag and non-repainting are orthogonal properties. KernelLens `_phase = 0` is zero lag with real-time flicker; `_phase = 2` is two-bar lag with no flicker. You can have any combination of the two, and the right choice depends on the trading style. > *"The `FILTER_ZEROLAG` mode makes the indicator non-repainting."* False. `FILTER_ZEROLAG` is an Ehlers-style de-lagging filter applied to the kernel output; it reduces the perceived lag of the estimate, but it does not affect whether the live bar flickers. Non-repainting is controlled exclusively by `_phase`. Choose `_phase` for repainting behavior, and `_filter` for smoothness / lag shape — they are independent knobs. **When to Accept Real-Time Flicker (`_phase = 0`)** Despite everything above, there are legitimate reasons to deliberately use `_phase = 0`: - **Academic research and backtesting** — you want the kernel mathematics in its classical form, centered on the point being estimated, with no phase adjustment - **Scalping on very short timeframes** — a 2-bar lag on a 1-minute chart is a 2-minute delay, which can matter when you are exiting within a 4-minute window - **Visual calibration** — when you are choosing a bandwidth by eye, the live-bar flicker actually helps: you see how sensitive the curve is to each incoming tick, which is diagnostic information - **Indicators that read the kernel output only on `barstate.isconfirmed`** — if your signal logic is gated by `if barstate.isconfirmed`, then live-bar flicker is invisible to your signal (it sees only the frozen close-of-bar value), and you can safely use `_phase = 0` with no practical consequence For every other case — and especially for any live alert or automated trading system — use `_phase ≥ 1`. Two bars of lag on a clean, stable curve is almost always worth more than zero lag on a curve that redraws itself several times per bar. 🟦 UNIFIED DISPATCHER — `estimate()` For indicators where the user picks a kernel from a dropdown, writing eight separate ternary branches is tedious and error-prone. KernelLens ships with a unified dispatcher that routes to the correct kernel based on a string argument: ```pine import a_jabbaroff/KernelLens/1 as kl line = kl.estimate( kernelType = kl.KERNEL_GAUSS, src = close, bandwidth = 32, shapeAlpha = 1.0, period = 1, phase = 2, filter = kl.FILTER_SMOOTH) ``` The dispatcher forwards to the matching typed export, so there is no performance penalty versus calling the kernel directly — it is a compile-time routing pass. Unknown kernel names raise a descriptive `runtime.error` naming every valid alternative, so typos fail loudly instead of silently returning `na`. **Public Constants** KernelLens exposes its string constants so callers never type the magic values by hand: | Constant | Value | |---|---| | `FILTER_NONE` | `"No Filter"` | | `FILTER_SMOOTH` | `"Smooth"` | | `FILTER_ZEROLAG` | `"Zero Lag"` | | `KERNEL_RQ` | `"Rational Quadratic"` | | `KERNEL_GAUSS` | `"Gaussian"` | | `KERNEL_PERIODIC` | `"Periodic"` | | `KERNEL_LOCPER` | `"Locally Periodic"` | | `KERNEL_EPA` | `"Epanechnikov"` | | `KERNEL_TRICUBE` | `"Tricube"` | | `KERNEL_TRIANG` | `"Triangular"` | | `KERNEL_COSINE` | `"Cosine"` | Using the constants in your caller code means the Pine compiler — not a runtime string compare — catches typos at edit time. 🟦 UTILITY LAYER — FIVE PROFESSIONAL HELPERS KernelLens ships with five utility exports that complement the core estimators. They are the functions you almost always write immediately after getting a smoothed line, factored out so you don't rewrite them in every indicator. **`slope(estimate, step)` — Discrete First Derivative** Returns `(y_t − y_{t−step}) / step`, the normalized rate of change over `step` bars. Use it to detect whether a kernel output is trending up, flat, or down — the foundation for any trend-following signal built on top of KernelLens. ```pine rising = kl.slope(line, 3) > 0.0 ``` **`trendState(estimate, step)` — Ternary Trend Indicator** Returns `+1` if the estimate is rising, `−1` if falling, `0` if exactly flat over the window. A single-call replacement for hand-rolled `line > line ? 1 : line < line ? -1 : 0` ladders. **`crossSignal(fast, slow)` — Bi-directional Crossover** Returns `+1` on the bar where `fast` crosses above `slow` (bullish), `−1` on a bearish cross, and `0` otherwise. Built on `ta.crossover` / `ta.crossunder`, so the signal is non-repainting once the bar is confirmed. **`confidenceBand(src, estimate, window)` — Residual Standard Deviation** Computes the rolling standard deviation of `(src − estimate)` over a user-defined window. Use the return value as the half-width of a confidence band around the estimate: ```pine est = kl.gaussian(close, 32, 2, kl.FILTER_SMOOTH) sigma = kl.confidenceBand(close, est, 50) upper = est + 1.96 * sigma lower = est - 1.96 * sigma ``` This is a computationally cheap proxy for the full kernel-weighted local variance — ideal when you need visual bands without paying for a second weighted pass. **`silvermanBandwidth(src, window)` — Optimal ℓ Suggestion** Returns the Silverman rule-of-thumb bandwidth: ``` h ≈ 1.06 · σ · n^(−1/5) ``` where `σ` is the rolling standard deviation of the source and `n` is the window size. This is the classical starting point for Gaussian-family bandwidths in academic texts (Silverman 1986). Because Pine requires `simple int` for kernel bandwidth, the returned value is intended for diagnostic display — plot it, read it off the chart, then hard-code the rounded integer into the kernel call. 🟦 INPUT VALIDATION — FAIL LOUDLY, FAIL EARLY Every public function in KernelLens validates its inputs through a set of internal `_assert*` helpers. Invalid arguments never produce silent `na` fallbacks or buried zero-divisions — they raise `runtime.error` with a descriptive message identifying the function, the parameter, and the expected range. | Helper | Checks | Raises On | |---|---|---| | `_assertFilter` | Filter string is `FILTER_NONE`, `FILTER_SMOOTH`, or `FILTER_ZEROLAG` | Typos like `"No FIlter"` (capital I) — a bug that exists in at least one published kernel indicator | | `_assertBandwidth` | Bandwidth is a strictly positive integer | Negative or zero bandwidth, which would cause division by zero or infinite loops | | `_assertPeriod` | Period is a strictly positive integer | Zero period, which would cause `sin(π·d/0)` in Periodic kernels | | `_assertAlpha` | Rational Quadratic shape parameter is strictly positive | Zero or negative `α`, which would invert the RQ formula | Error messages are prefixed `KernelLens:` (or `KernelLens.:`) so they are easy to spot in the TradingView runtime log. Every message names the parameter that failed, the value that was passed, and the set of valid alternatives — so a misconfigured chart tells you exactly what to fix. 🟦 LOOP DEPTH — THE BUG FIX THAT MOTIVATED KERNELLENS The two most popular Pine kernel libraries on TradingView share the same fatal bug: both compute their loop depth as ```pine _size = array.size(array.from(_src)) ``` where `array.from(_src)` creates a **one-element array containing the current value of `_src`**, so `_size` is always `1`. The loop then runs `for i = 0 to 1 + startAtBar`, effectively using only `startAtBar + 2` bars — completely ignoring the user's bandwidth. Every published kernel indicator built on those libraries inherits this silent miscalculation. KernelLens replaces the broken helper with three explicit depth selectors: | Helper | Depth | Used By | |---|---|---| | `_depthInfinite(bw)` | `max(bw · 3, 4)` | Gaussian, Rational Quadratic, Locally Periodic | | `_depthCompact(bw)` | `max(bw, 4)` | Epanechnikov, Tricube, Triangular, Cosine | | `_depthPeriodic(bw, p)` | `max(bw · 3, p · 10, 4)` | Periodic | For Gaussian-family kernels, the `3·ℓ` cutoff captures approximately 99.7% of the kernel mass (the three-sigma rule). For compact-support kernels, the depth equals the bandwidth exactly — the loop terminates at the kernel's natural zero point. For Periodic kernels, the depth is the larger of the scale-based and cycle-based minima, so the loop always spans enough periods to produce a stable weighted average. The loop counter `i` runs over bar offsets starting at `_phase`, every bar lookup is NA-checked before being incorporated into the sum, and the final `num / den` division is guarded against zero denominators. On a fresh chart, the kernel gracefully returns `na` for bars where the window extends past available history, rather than producing poisoned sums from implicit NA arithmetic. 🟦 API REFERENCE **Core Kernel Estimators — Eight Exports** | Export | Signature | |---|---| | `rationalQuadratic` | `(src, bandwidth, shapeAlpha, phase, filter) → float` | | `gaussian` | `(src, bandwidth, phase, filter) → float` | | `periodic` | `(src, bandwidth, period, phase, filter) → float` | | `locallyPeriodic` | `(src, bandwidth, period, phase, filter) → float` | | `epanechnikov` | `(src, bandwidth, phase, filter) → float` | | `tricube` | `(src, bandwidth, phase, filter) → float` | | `triangular` | `(src, bandwidth, phase, filter) → float` | | `cosineKernel` | `(src, bandwidth, phase, filter) → float` | **Unified Dispatcher** | Export | Signature | |---|---| | `estimate` | `(kernelType, src, bandwidth, shapeAlpha, period, phase, filter) → float` | **Utility Layer — Five Exports** | Export | Signature | |---|---| | `slope` | `(estimate, step) → float` | | `trendState` | `(estimate, step) → int` | | `crossSignal` | `(fast, slow) → int` | | `confidenceBand` | `(src, estimate, window) → float` | | `silvermanBandwidth` | `(src, window) → float` | **Parameter Types** | Name | Pine Type | Description | |---|---|---| | `src` | `series float` | Source series (close, hl2, ohlc4, or any other price-derived series) | | `bandwidth` | `simple int` | Kernel scale `ℓ`, must be `> 0` | | `shapeAlpha` | `simple float` | Rational Quadratic shape parameter, must be `> 0` | | `period` | `simple int` | Periodic repetition distance, must be `> 0` | | `phase` | `simple int` | Kernel center offset in bars, must be `≥ 0` | | `filter` | `simple string` | One of `FILTER_NONE`, `FILTER_SMOOTH`, `FILTER_ZEROLAG` | | `kernelType` | `simple string` | One of the eight `KERNEL_*` constants | | `step` | `simple int` | Finite-difference step for `slope` / `trendState`, must be `≥ 1` | | `window` | `simple int` | Rolling window for `confidenceBand` / `silvermanBandwidth`, must be `≥ 2` | 🟦 USAGE EXAMPLES **Minimal — One Gaussian Curve** ```pine //@version=6 indicator("KernelLens — Gaussian Demo", overlay = true) import a_jabbaroff/KernelLens/1 as kl line = kl.gaussian(close, 32, 2, kl.FILTER_SMOOTH) plot(line, "Gaussian", color = color.orange, linewidth = 2) ``` **Fast / Slow Crossover System** ```pine //@version=6 indicator("KernelLens — RQ Crossover", overlay = true) import a_jabbaroff/KernelLens/1 as kl fast = kl.rationalQuadratic(close, 8, 1.0, 2, kl.FILTER_NONE) slow = kl.rationalQuadratic(close, 32, 1.0, 2, kl.FILTER_SMOOTH) cross = kl.crossSignal(fast, slow) plot(fast, "Fast", color = color.aqua, linewidth = 2) plot(slow, "Slow", color = color.orange, linewidth = 2) plotshape(cross == 1, "Bull", location = location.belowbar, color = color.lime, style = shape.triangleup, size = size.tiny) plotshape(cross == -1, "Bear", location = location.abovebar, color = color.red, style = shape.triangledown, size = size.tiny) ``` **Confidence Band Envelope** ```pine //@version=6 indicator("KernelLens — Confidence Band", overlay = true) import a_jabbaroff/KernelLens/1 as kl est = kl.tricube(close, 48, 2, kl.FILTER_SMOOTH) sigma = kl.confidenceBand(close, est, 50) k = 1.96 upper = est + k * sigma lower = est - k * sigma plot(est, "Estimate", color = color.orange, linewidth = 2) p1 = plot(upper, "+1.96σ", color = color.new(color.aqua, 70)) p2 = plot(lower, "−1.96σ", color = color.new(color.aqua, 70)) fill(p1, p2, color = color.new(color.aqua, 92)) ``` **Dropdown-Driven Kernel Selection** ```pine //@version=6 indicator("KernelLens — Dropdown", overlay = true) import a_jabbaroff/KernelLens/1 as kl kernelType = input.string(kl.KERNEL_GAUSS, "Kernel", options = ) bandwidth = input.int(32, "Bandwidth", minval = 2) alphaRQ = input.float(1.0,"RQ Alpha", minval = 0.01, step = 0.25) period = input.int(20, "Period", minval = 1) phase = input.int(2, "Phase", minval = 0) filter = input.string(kl.FILTER_SMOOTH, "Filter", options = ) line = kl.estimate(kernelType, close, bandwidth, alphaRQ, period, phase, filter) plot(line, "KernelLens", color = color.orange, linewidth = 2) ``` 🟦 TIMEFRAME PRESETS — BANDWIDTH BY STYLE Kernel bandwidth is the single most important parameter. It controls the trade-off between reactivity (small `ℓ`, tight fit, noisier) and stability (large `ℓ`, smooth curve, slower to react). The presets below are tested starting points — adjust by ±25 % to taste. --- **SCALPER — 1m / 3m / 5m** | Parameter | Value | |---|---| | Bandwidth (ℓ) | 8 | | Phase | 1 | | Filter | `FILTER_NONE` | | Best Kernel | Rational Quadratic or Gaussian | | RQ shapeAlpha | 1.0 | **Why:** Short bandwidth means the kernel reacts within a handful of bars. `FILTER_NONE` removes the double-pass lag, so the estimate tracks price as tightly as possible. Phase 1 keeps the estimate nearly live while still avoiding the current-bar tick noise. --- **DAY TRADER — 15m / 30m / 1H** | Parameter | Value | |---|---| | Bandwidth (ℓ) | 16 | | Phase | 2 | | Filter | `FILTER_SMOOTH` | | Best Kernel | Gaussian or Tricube | | RQ shapeAlpha | 1.0 | **Why:** Balanced reactivity — the 16-bar Gaussian is the default Silverman range for intraday price data, and `FILTER_SMOOTH` removes most of the bar-to-bar chop without significantly increasing lag. Tricube provides near-identical behaviour with strict compact support and is preferred on noisy assets where outlier bars should not influence the curve. --- **SWING TRADER — 4H / 1D** | Parameter | Value | |---|---| | Bandwidth (ℓ) | 32 | | Phase | 3 | | Filter | `FILTER_SMOOTH` | | Best Kernel | Rational Quadratic | | RQ shapeAlpha | 2.0 | **Why:** Swing trades need structural signals, not intraday noise. Rational Quadratic with `α = 2.0` mixes medium and long length scales, producing a curve that ignores transient spikes but catches genuine regime shifts. Phase 3 shifts the estimate three bars back so each swing decision is made against a fully confirmed kernel output. --- **POSITION / LONG-TERM — 1D / 1W / 1M** | Parameter | Value | |---|---| | Bandwidth (ℓ) | 64 | | Phase | 5 | | Filter | `FILTER_SMOOTH` or `FILTER_ZEROLAG` | | Best Kernel | Gaussian or Locally Periodic | | Period (if LP) | 52 (weekly cycle) | **Why:** Position traders care about the macro trajectory. A Gaussian with ℓ = 64 produces a curve that only turns on genuine multi-month inflections. Locally Periodic with `period = 52` is the ideal choice when a clear seasonal cycle is present — it uses both the long-range Gaussian envelope and the 52-bar periodicity to highlight cycle turns that align with trend. --- **RESEARCH — Academic / Backtest** | Parameter | Value | |---|---| | Bandwidth (ℓ) | Compute via `silvermanBandwidth(src, 200)` | | Phase | 0 | | Filter | `FILTER_NONE` | | Best Kernel | Epanechnikov | **Why:** Epanechnikov is the MSE-optimal kernel; `FILTER_NONE` keeps the estimator in its classical single-pass form; `phase = 0` centers the kernel on the bar being evaluated. This is the configuration that matches the statistical literature exactly — use it when publishing research, running Monte-Carlo studies, or calibrating against reference implementations. 🟦 BANDWIDTH SELECTION Bandwidth `ℓ` is the single most consequential choice in kernel regression. Too small and the estimate overfits local noise; too large and it flattens real structure. KernelLens exposes two helpers to support both manual and semi-automated bandwidth selection. **Manual — Start with ℓ ≈ √n** A practical starting point for financial time series: set `ℓ ≈ √window_of_interest`. If you care about 100-bar structure, try `ℓ = 10`. If you care about 400-bar structure, try `ℓ = 20`. Adjust by ±25 % based on how noisy the result looks. **Silverman's Rule of Thumb** The closed-form optimal bandwidth for Gaussian-family kernels under Gaussian source assumptions: ``` h ≈ 1.06 · σ · n^(−1/5) ``` Call `silvermanBandwidth(src, window)` to compute this value live. Because Pine requires `simple int` bandwidth at compile time, the returned value is for diagnostic use — plot it, read the stable value off the chart, then hard-code the rounded integer into your kernel calls. **Leave-One-Out Cross-Validation (Manual)** For academic rigor, compute the leave-one-out mean squared error for a range of bandwidths and pick the minimum. KernelLens does not automate this (it would require `series int` bandwidth, which Pine does not support inside kernel loops), but the formula is straightforward: ``` LOOCV(ℓ) = (1/n) · Σᵢ (yᵢ − ŷᵢ⁻ⁱ(ℓ))² ``` where `ŷᵢ⁻ⁱ` is the kernel estimate at bar `i` computed without including bar `i` in the sum. Evaluate offline, pick the minimum, hard-code the result. 🟦 FILTER SELECTION — WHEN TO USE EACH | Filter | Best For | Avoid When | |---|---|---| | `FILTER_NONE` | Live signal generation, research / calibration, compact-support kernels on noisy data | Choppy markets where you need extra smoothing | | `FILTER_SMOOTH` | Swing and position trades, confidence band midlines, most day-trading setups | Scalping — the double pass adds measurable lag | | `FILTER_ZEROLAG` | Regime detection, crossover systems that need the curve to track price tightly | Low-volume assets — Zero Lag amplifies high-frequency noise | The three filters use the same underlying kernel with the same bandwidth, so switching between them does not require re-tuning. Default to `FILTER_SMOOTH` when in doubt — it is the best-behaved option across the widest range of assets and timeframes. 🟦 COMPATIBILITY KernelLens targets Pine Script v6 and runs on every TradingView chart — no exchange, asset class, or timeframe restriction. - **Crypto** — Spot, futures, perpetual contracts - **Forex** — All majors, minors, and exotics - **Equities** — Stocks, ETFs, indices - **Commodities** — Metals, energy, agriculture - **Timeframes** — 1 minute through Monthly The library is deterministic — given the same source and parameters, every bar of every symbol produces the same estimate. No calibration is needed across assets; the bandwidth parameter alone controls smoothness, and the kernel formulas are scale-free in the source dimension. Silverman's bandwidth helper automatically adapts to each asset's volatility. 🟦 TECHNICAL NOTES - **Pine Script v6** — uses the modern type system, strict type checking, and the `switch` expression in the unified dispatcher - **Non-repainting** — kernel outputs for any confirmed bar depend only on that bar's history; there is no look-ahead, no `request.security` with lookahead, and no dependency on the unconfirmed current bar unless `_phase = 0` is deliberately chosen - **NA-safe iteration** — every bar lookup inside a kernel loop is guarded by `if not na(y)`, so chart history gaps and warm-up bars cannot poison the weighted sum - **Division-by-zero protection** — every kernel's final division checks `den > 0.0` and returns `na` if the denominator collapses (which can only happen on truly empty windows) - **Input validation** — every public function asserts its preconditions up front via `_assertFilter`, `_assertBandwidth`, `_assertPeriod`, `_assertAlpha`, and raises `runtime.error` with a descriptive message on misuse — no silent `na` fallbacks - **Lazy filter evaluation** — the `"No Filter"` path never executes the second kernel pass; the `if`-branch check short-circuits, so single-pass mode is as cheap as a raw kernel call - **Correct loop bounds** — `_depthInfinite`, `_depthCompact`, and `_depthPeriodic` compute the correct window size per kernel family, fixing the silent `_size = 1` bug that plagues every other published Pine kernel library - **No persistent state** — the library is purely functional: no `var`, no arrays, no history buffers that grow over time; every export is a pure expression of `(inputs) → output`, so Pine's `max_*_count` limits cannot be exceeded and the library cannot leak memory - **O(bandwidth) per bar per kernel call** — the loop depth is bounded by the constants in Section 0; there is no hidden quadratic behavior and the cost scales linearly with the user-chosen bandwidth - **Unicode-safe comments** — the source uses academic notation (`σ`, `ℓ`, `α`, `ŷ`, `ℝ`) where it improves readability; all strings are plain ASCII for runtime compatibility 🟦 ACADEMIC REFERENCES Every kernel and every formula in KernelLens is cited inline in the source. The combined bibliography: - **Nadaraya, E. A. (1964).** On estimating regression. *Theory of Probability & Its Applications*, 9(1), 141–142. - **Watson, G. S. (1964).** Smooth regression analysis. *Sankhyā: The Indian Journal of Statistics, Series A*, 26(4), 359–372. - **Cleveland, W. S. (1979).** Robust locally weighted regression and smoothing scatterplots. *Journal of the American Statistical Association*, 74(368), 829–836. *(Tricube kernel, LOWESS.)* - **Silverman, B. W. (1986).** *Density Estimation for Statistics and Data Analysis*. Chapman & Hall, London. *(Bandwidth rule of thumb.)* - **Wand, M. P. & Jones, M. C. (1995).** *Kernel Smoothing*. Chapman & Hall. *(Unified treatment of all eight kernels.)* - **MacKay, D. J. C. (1998).** Introduction to Gaussian Processes. *NIPS Tutorial*. *(Periodic and Rational Quadratic kernels.)* - **Ehlers, J. F. (2000).** *Rocket Science for Traders*. John Wiley & Sons. *(Zero-lag smoothing trick.)* - **Rasmussen, C. E. & Williams, C. K. I. (2006).** *Gaussian Processes for Machine Learning*. MIT Press. *(Locally Periodic and Rational Quadratic kernels.)* 🟦 VERSIONING & LICENSE - **Version** — 1.0.0 - **Pine Script** — v6 - **License** — Mozilla Public License 2.0 - **Status** — Production-ready KernelLens follows semantic versioning. Minor versions add new exports without breaking existing ones; patch versions fix bugs; major versions may change function signatures and will be announced in the changelog. 🟦 DISCLAIMER KernelLens is a mathematical library for non-parametric regression on financial time series using the Nadaraya–Watson method. The library is provided solely for educational and research purposes and does not constitute financial, investment, or trading advice. Kernel regression is a local smoothing technique. It estimates the mean of a source series in the neighborhood of the current bar based on historical data, but it does not predict future prices, does not generate trading signals on its own, and does not guarantee the profitability of any strategy built on top of its output. Past performance of any model does not guarantee future results. Markets contain systemic risks that cannot be eliminated by any amount of mathematical rigor in the kernel itself. Responsibility for any trading decisions made using this library rests entirely with the user. Always apply sound capital management, conduct your own independent analysis, and never risk capital you are not prepared to lose. The author assumes no liability for direct or indirect losses incurred through the use of KernelLens or any indicator built on top of it.
Библиотека Pine Script®
от a_jabbaroff
1
IndiaVixLibrary "IndiaVix" getPrevDayClose(_symbol, _tf)   Parameters:      _symbol (simple string)      _tf (simple string) getSentientValues(_enable, _vix, _indexInput, _symbol, _sigma, _tredingDays)   Parameters:      _enable (bool)      _vix (float)      _indexInput (float)      _symbol (simple string)      _sigma (simple float)      _tredingDays (simple int) getVix(_tf)   Parameters:      _tf (simple string) method chgVsPrev(this)   Namespace types: Vix   Parameters:      this (Vix) method chgVsPDC(this)   Namespace types: Vix   Parameters:      this (Vix) method dailyMovePts(this, _c)   Namespace types: Vix   Parameters:      this (Vix)      _c (float) method isRising(this)   Namespace types: Vix   Parameters:      this (Vix) method regime(this)   Namespace types: Vix   Parameters:      this (Vix) Vix   Fields:      now (series float)      prev (series float)      eod (series float)
Библиотека Pine Script®
от sanjeevrjha