Q-jXT0ddlmZddlmZddlmZddlmZddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$ddl m%Z&ddl m'Z(dd l)m*Z*dd l+m,Z,m-Z-dd l.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6dd l7m8Z8ddl9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBgdZC dBde4de4deDdeDde4f dZEde1de1fdZF dCde-de5de4de4de2de,f dZGde5de3fdZHe/d !dDde4d"eDde1fd#ZIde-de3fd$ZJde1d%e5de3fd&ZK dCde-d'e5de4de4de2de,f d(ZLde-de3fd)ZM dEde4d*eDd"eDde1fd+ZNde-d,eOde-fd-ZP dFde-d.e5d/e5d0e5d1e5de4de2de-fd2ZQde1d,e4de1fd3ZR dGd4e-d5e-d,e4d6eDde-f d7ZS dHde4d"eDde6e5fd8ZTd9e1defd:ZUde5de5fd;ZV dIdeDd?eDd@eWde,f dAZXy)J)Callable)reduce)floor)mul) float_info)allarray broadcast_to concatenatediffdotexpfabsfullisnanlog logical_andnannanmeannansumndarraynewaxisonespadsignsqrtsumtriuzeros)max)min)sliding_window_view) DataFrameSeries)njit)ArrayDictLikeFloatIntIntFloatList)Imports) v_array v_dataframev_floatv_int v_lowerboundv_offset v_pos_defaultv_scalarv_series) combinationcubeconsecutive_streakdf_error_analysiserf fibonaccigeometric_meanhpolyifisherlog_geometric_meanpascals_triangle percent_rankremapstrided_windowsum_signed_rolling_deltassymmetric_triangleweightszeronr repetition multichoosereturnctt|tt|}}|s|r||zdz }t|||z }|dk(ryttt |||z dd}ttt d|dzd}||zS)aCombination Combination computation. Sources: * [stackoverflow](https://stackoverflow.com/questions/4941753/is-there-a-math-ncr-function-in-python) Parameters: n (Int): ```n``` r (Int): ```r``` repetition (bool): Apply repetition. multichoose (bool): Apply multichoose. Returns: (Int): Combination value Note: ```n``` Choose ```r```: ```(n r)``` r)intrr!rrrange)rHrIrJrK numerator denominators c/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/pandas_ta/utils/_math.pyr6r6?s. tAw<T!WqA[ EAI Aq1u AAvsE!QUB/3IeAq1uoq1K  ##xcBtdgtt|fS)aConsecutive Streak Computes the streak of consecutive value increases or decreases. Parameters: x (Array): Numpy array. Returns: (Array): Streak array of element changes. Note: Logic Yield an array where each value represents the streak value for that bar. 1. Computes the difference between consecutive values. 2. Assigns 1 for each positive change, -1 for each negative change -1 and 0 for no change. Note: Streaks * Positive: Consecutive bars of value increases * Negative: Consecutive bars of value decreases * Zero: When direction of the value change reverses Example: ```py x = np.array([100, 101, 102, 100, 100, 101, 102, 103]) result = consecutive_streak(x) expected = np.array([0, 1, 1, -1, 0, 1, 1, 1]) np.array_equal(result, expected) ``` r)r rr rVs rTr8r8fs@ T$q']+ ,,rUNsrcpwr signal_offsetoffsetkwargsc t|}t|ddd}t|dd}t|}||z}t ||j }t ||j }|dk7r"|j |}|j |}|dk7r"|j |}|j |}tt|rtt|ryd|vr,|j|dd |j|dd d |d |}d ||_ d ||_ dx|_ |_ |j||j|i} t| |j } d || _ |j| _ | S)aCube Transform This transform, by John Ehlers, is used to compress Svalues near zero for a normalized oscillator like the Inverse Fisher Transform. In other words, a Power Transform/Function: ```result = src ^ pwr``` Sources: * [rengel8](https://github.com/rengel8) based on Markus K. (cryptocoinserver)'s source * "Cycle Analytics for Traders", 2014, by John Ehlers, page 200 Parameters: src (Series): Source pwr (float): The transform power. Default: ```3``` signal_offset (int): Signal offset. Default: ```-1``` offset (int): Post shift. Default: ```0``` Other Parameters: fillna (value): ```pd.DataFrame.fillna(value)``` Returns: (DataFrame): 2 columns Note: * Values near ```-1``` and ```1``` are nearly unchanged, whereas values near zero are reduced. * Input effects of spectral dilation should have been removed (i.e. roofing filter). g@F)strictrOrindexNfillnaTinplace_CUBECUBEs transform) r5r1r0r2r$rashiftrrrbnamecategoryr#) rYrZr[r\r]resultct ct_signal_propsdatadfs rTr7r7s|H 3-C sCU 3C-Q/M f FCZF cii (BvSYY/I{ XXf OOF+  XXm $OOM2  59~#eI./6 &"D 1)48Q}o &FVHoBGVH%IN'22BK)$ GGR 3D 4syy )BVHoBG++BK IrUct|}t|}d}d}d}d}d}d}dd||zzz }d||z|z|z|z|z|z|z|z|zt| |zzz } || zS)a]Error Function Computes the erf(x) Sources: * Handbook of Mathematical Functions, formula 7.1.26. * [stackoverflow](https://stackoverflow.com/questions/457408/is-there-an-easily-available-implementation-of-erf-for-python) Parameters: x (IntFloat): ```x``` value. Returns: (Float): Error value g~Z O?gi<15ҿgWU?g9LW@g-UB?g{=@??)rabsr) rVx_signa1a2a3a4a5ptys rTr:r:s!WF AA B B B B BA sQU{A 26B;!#r)Q.3"A26{+ +A A:rUT)cacheweightedc|dkDr|nd}td}dd|zzdd|z z}}t|}td|D]"}t||dzz||dzzz |z ||<$|r||j z S|S)aFibonacci Computes closed form Fibonacci values. Parameters: n (Int): Number of terms (n >= 2). Default: ```2``` weighted (bool): Return weighted values. Default: ```False``` Returns: (Array): Numpy array results rNg@?rsr)rrrQfloatr)rHrsqrt5phipsirlis rTr;r;sUA IEcEk"C3;$7C 1XF 1a[#!a%.31q5>9:UBq  $$ MrUc|j}|dkr|jdSd|jv}|r|jddz}t |dkDr|j d|z z}|s|S|dz Sy)zGeometric Mean Computes the Geometric Mean of positive values. Parameters: x (Series): Values Returns: (Float): Geometric Mean rNr)sizeilocto_numpyrbrprod)rVrH has_zerosmeans rTr<r<sy A1uvvayQZZ\!I HHQK!O 1q5zvvxAE"$t2$(2 rUvct|ts t|}|j|d}}t d|D] }||||zz}|S)aHorner's Polynomial Evaluates a polynomial with an array of polynomial coefficients, ```x```, and a value, ```v```, using Horner's Calculation for Polynomial Evaluation. Parameters: x (Array): Polynomial coefficients as ```np.array``` v (IntFloat): Value Returns: (Float): Polynomial value. Tip: Performance Use a ```np.array``` for best performance. Example: ```py coeffs_0 = [4, -3, 0, 1] # 4x^3 - 3x^2 + 0x + 1 coeffs_1 = np.array(coeffs_0) # Faster coeffs_2 = pd.Series(coeffs_0).to_numpy() x = -6.5 hpoly(coeffs_0, x) => -1224.25 hpoly(coeffs_1, x) or hpoly(coeffs_2, x) => -1224.25 # Faster ``` rrN) isinstancerr rrQ)rVrmr}rs rTr=r=-sN8 a ! !H 661Q4qA 1a[ aD1q5L HrUampc t|}t|d}t|dd}t|}|j }t |dk\|dk}t |s[t|t|}}t|||dd} | "t t| j ry| j }t||z} | dz | dzz } t| |j} t| |j} |dk7r"| j|} | j|} |dk7r"| j|} | j|} d|vr,| j|dd | j|dd d |}d || _d || _| j | | j | i}t#||j}d ||_|S)aInverse Fisher Transform This transform function, by John Ehlers, attempts to create clearer signals by changing the Probability Distribution Function (pdf) for the results of known oscillator-indicators. Sources: * [rengel8](https://github.com/rengel8) based on Markus K. (cryptocoinserver)'s source * "Cycle Analytics for Traders", 2014, by John Ehlers, page 198 * [mesasoftware](https://www.mesasoftware.com/papers/TheInverseFisherTransform.pdf) Parameters: x (Series): Normalized to range ```[-1, 1]``` amp (float): Amplifier. Default: ```1``` signal_offset (int): Signal line offset. Default: ```-1``` offset (int): Post shift. Default: ```0``` Other Parameters: fillna (value): ```pd.DataFrame.fillna(value)``` Returns: (DataFrame): 2 columns Note: * Normalized input, ```x```, with range ```[-1, 1]``` * Data range of ```[-0.5, 0.5]``` would not have a significant impact Example: Preparation Examples Or use _ta.remap()_ function to prep (RSI - 50) * 0.1 RSI [0 to 100] -> -5 to 5 (RSI - 50) * 0.02 RSI [0 to 100] -> -1 to 1 (use amp of 5 to match input of example above) rsrOrrN)from_minfrom_maxto_minto_maxNr`rbTrcre INVFISHER INVFISHERs)r5r4r0r2rrrnp_maxnp_minrBrrr$rarirbrjr#)rVrr[r\r]np_x is_remapped_np_max_np_minx_mapampedrl inv_fishersignalrorprqs rTr>r>TsR  A 3 C-Q/M f F :: '')I ivzm DCAssF c!R.&99 )2 2C #a&# FF67O MrUrrrrc t|}t|dd}t|dd}t|dd}t|dd}t|}||z ||z }}|dks|dkry|||z |j|z zz} t | |j } |dk7r| j |} d|vr| j|dd d |d |d |d || _| S) aremap The standard method of transforming from a source range to a target range using Max-Min. Useful for bounded sources; not unbounded sources like _ohlcv_ data. Sources: * Linear (Max-Min) Normalization Parameters: x (Series): Series of 'x's from_min (IntFloat): Input minimum. Default: ```0.0``` from_max (IntFloat): Input maximum. Default: ```100.0``` to_min (IntFloat): Output minimum. Default: ```0.0``` to_max (IntFloat): Output maximum. Default: ```100.0``` offset (Int): Post shift. Default: ```0``` Other Parameters: fillna (value): ```pd.DataFrame.fillna(value)``` Returns: (Series): 1 column ggY@grsrNr`rbTrcREMAP_re) r5r/r2rr$rarirbrj) rVrrrrr\r]frangetrangerls rTrBrB"s:  Axc*Hx,H VT3 'F VS# &F f F(&6/FF {fk v1::<(+BC CF F!'' *F{f%6 fX& 58*AhZq&BFK MrUcddlm}|j|jdfz}|jdd|jd|z dz|fz}||||dS)aStrided Window Creates a strided window view. Source: * [numpy](https://numpy.org/devdocs/reference/generated/numpy.lib.stride_tricks.as_strided.html) * [Issue #285](https://github.com/twopirllc/pandas-ta/issues/285) Parameters: x (Array): Source length (Int): Window period. Returns: (Array): Numpy Array of Strided Window Arrays Warning: Use if necessary, otherwise avoid when possible! r) as_stridedrONrNF)shapestrides writeable)numpy.lib.stride_tricksrrr)rVrrrrs rTrCrC]s\&3ii199R=**G GGCRLAGGBK&014f= =E aug GGrUopen_close exclusivec\t|d}|s|dz}t||dd}t||djddtf|j }t ||z }t|djt}tt||dfdt |j S) aSum of Signed Rolling Series Deltas Calculates the sum of signed differences between the current closing bar and a rolling window of preceding opening bars. This sum is then padded to match the original series length. Parameters: open_ (Series): ```open``` Series close (Series): ```close``` Series length (Int): Window length. Default: ```4``` exclusive (bool): Exclusive rolling window. Inclusive rolling window when ```False```. Default: ```True``` Returns: (Series): 1 column Notes: Mode **Exclusive**: Rolling window excludes the current bar in the lookback period. **Inclusive**: Rolling window includes the current bar in the lookback period. Example: ```py open_ = Series([95, 83, 71, 132, 129, 145, 133, 101, 68, 96]) close = Series([100, 110, 140, 80, 90, 60, 50, 40, 90, 110]) result = sum_signed_rolling_deltas(close, open_, 4, exclusive=True) expected_result = Series([np.nan, np.nan, np.nan, np.nan, 0.0, -4.0, -4.0, -4.0, -4.0, 0.0]) np.allclose(result, expected_result, rtol=1e-6, equal_nan=True) result = sum_signed_rolling_deltas(close, open_, 4, exclusive=False) expected_result = Series([np.nan, np.nan, np.nan, -1.0, 1.0, -3.0, -3.0, -3.0, -3.0, 1.0]) np.allclose(result, expected_result, rtol=1e-6, equal_nan=True) ``` rNrNrOrrconstant)modeconstant_valuesr`)r3r"r rrrrrastyperr$rrra)rrrr rolling_openclose_broadcasted signed_deltassum_signed_deltass rTrDrDwsP61 %F ! &u6B3BGL$ fg!!W*-|/A/A*\9:M}15<._dots1ayrU)rrs` rTrFrFs  KrUcBt|tjkrdS|S)zZero Zeros inputs near zero. Parameters: x (IntFloat): Value to attempt to zero Returns: (IntFloat): ```0``` or ```x``` r)rtsfltepsilonrXs rTrGrGsA%1,1,rUABplot triangularmethodcPgd}||vr|n|d}||z }|j||}|r:|j||dkDjr|jd|r@|j t t |jjtS|S)aWDataFrame Correlation Analysis Compares two DataFrames using both their difference and their correlations. Parameters: A (DataFrame): DataFrame A B (DataFrame): DataFrame B plot (bool): Create a KDE plot of differences. Default: ```False``` triangular (bool): Return a Triangular Correlation DataFrame. Default: ```False``` method (str): Correlation methods: ```"pearson"```, ```"kendall"```, or ```"spearman"```. Default: ```"pearson"``` Returns: (DataFrame): Correlation DataFrame or a KDE Difference plot )pearsonkendallspearmanr)rkde)kind) corrhistanyrwhererrrrbool) rrrrr _r_method corr_methodr rls rTr9r9s*3I"i/&Yq\K q5D VVAkV *F  q>    DII5 !||Dfll!34;;DABB MrU)rNrFF)NNN)rF)NFF)NNNNN)T)NF)FFr)Ycollections.abcr functoolsrmathrroperatorrsysrrnumpyrr r r r r rrrrrrrrrrrrrrrrrrr rr!rrr"pandasr#r$numbar%pandas_ta._typingr&r'r(r)r*r+pandas_ta.mapsr,pandas_ta.utils._validater-r.r/r0r1r2r3r4r5__all__rr6r8r7r:r;r<r=r>r?r@rPrArBrCrDrErFrGstrr9rrUrTrsP$ "  7$#    027#$ #$#$#$+/#$ #$N -% -E -J=AI II69I I"*IIZ8DDDU4 f  2# U# x# E# R04X X X),X X#+X Xx & U *8 8x%*, ,!, (^,` u  " -H - -*,1%%% %$(% % %rU