iXT`SSKJr SSKJr SSKJr SSKJr SSK J r SSK J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$ SSK J%r& SSK J'r( SS K)J*r* SS K+J,r,J-r- SS K.J/r/ SS K0J1r1J2r2J3r3J4r4J5r5J6r6 SS K7J8r8 SSK9J:r:J;r;Jr>J?r?J@r@JArAJBrB /SQrCSBS\4S\4S\DS\DS\44 SjjrES\1S\14SjrFSCS\-S\5S\4S\4S\2S\,4 SjjrGS\5S\34SjrH\/"S S!9SDS\4S"\DS\14S#jj5rIS\-S\34S$jrJS\1S%\5S\34S&jrKSCS\-S'\5S\4S\4S\2S\,4 S(jjrLS\-S\34S)jrMSES\4S*\DS"\DS\14S+jjrNS\-S,\OS\-4S-jrPSFS\-S.\5S/\5S0\5S1\5S\4S\2S\-4S2jjrQS\1S,\4S\14S3jrRSGS4\-S5\-S,\4S6\DS\-4 S7jjrSSHS\4S"\DS\6\54S8jjrTS9\1S\4S:jrUS\5S\54S;jrVSIS<\,S=\,S>\DS?\DS@\WS\,4 SAjjrXg)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 multichoosereturnc$[[U55[[U55pU(dU(aX-S- n[XU- 5nUS:Xag[[[ XU- S5S5n[[[ SUS-5S5nXE-$)a{Combination 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 P/var/www/html/trading/venv/lib/python3.13/site-packages/pandas_ta/utils/_math.pyr6r6?s~. tAw<T!Wq[ EAI A1u AAvsE!UB/3IeAq1uoq1K  ##xcB[S/[[U5545$)a8Consecutive 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 [U5n[USSSS9n[USS5n[U5nX-n[ XPR S9n[ XPR S9nUS:wa"UR U5nUR U5nUS:wa"UR U5nUR U5n[[U55(a[[U55(agSU;a&URUSS S 9 URUSS S 9 S US U3nS U3Ul S U3Ul S=Ul Ul URXgRU0n [XR S9n S U3U l URU l U $)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 rTr7r7swH 3-C sCU 3C-Q/M f FZF ii (BvYY/I{ XXf OOF+  XXm $OOM2  59~~#eI.//6 &"D 1)48Q}o &FVHoBGVH%IN'22BK)$ GGR 3D 4yy )BVHoBG++BK IrUc[U5n[U5nSnSnSnSnSnSnSSXp--- nSXh-U-U-U-U-U-U-U-U-[U*U-5-- n X-$)a9Error 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 :rUT)cacheweightedcUS:aUOSn[S5nSSU--SSU- -pC[U5n[SU5H n[X6S--XFS--- 5U- XV'M" U(aXUR 5- $U$)zFibonacci 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;$7 1XF 1a[#a%.3q5>9:UB  $$ MrUcURnUS:aURS$SUR5;nU(aURS5S-n[ US:5(a$UR 5SU- -nU(dU$US- $g)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<s{ A1uvvayQZZ\!I HHQK!O 1q5zzvvxAE"$t2$(2 rUvc[U[5(d [U5nURUSp2[ SU5H nXX--nM U$)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=-sK8 a ! ! !H 661Q4q 1a[ D15L HrUampc [U5n[US5n[USS5n[U5nUR 5n[ US:US:*5n[ U5(d\[U5[U5p[UXSSS9n U b'[ [U R 555(agU R 5n[X-5n U S- U S-- n [XRS9n [XRS9n US:wa"U RU5n U RU5n US:wa"U RU5n U RU5n SU;a&U RUSS S 9 U RUSS S 9 S U3nS U3U lS U3U lU R XR U 0n[#XRS9nS U3UlU$)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 izm DCAssF c!R.&99 )2 2C #a&# F67O MrUrrrrc [U5n[USS5n[USS5n[USS5n[USS5n[U5nX!- XC- pUS::dUS::agX8U- UR5U- --n [ XR S9n US:waU R U5n SU;aU RUSS S 9 S US US US U3U lU $) 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(&/F {fk 1::<(+BC CF F'' *F{f%6 fX& 58*AhZq&BFK MrUcSSKJn URURS4-nURSSURSU- S-U4-nU"XUSS9$)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]sZ&3ii199R=**G GGCRLAGGBK&014f= =E ag GGrUopen_close exclusivec F[US5nU(dUS-n[XS9SSn[XSR5SS2[4UR 5n[ XT- 5n[USS9R[5n[[XrS4S[S 9URS 9$) a<Sum 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 ! &uB3BGL$ g!!W*-|/A/A*9:M}15<[TU5$)N)r )rVrs rT_dotweights.._dots1ayrU)rrs` rTrFrFs  KrUcD[U5[R:aS$U$)zZero Zeros inputs near zero. Parameters: x (IntFloat): Value to attempt to zero Returns: (IntFloat): ```0``` or ```x``` r)rtsfltepsilonrXs rTrGrGsA%1,1,rUABplot triangularmethodc^/SQnXE;aUOUSnX- nURXS9nU(a;UR"5 XwS:R5(aUR"SS9 U(a@UR [ [ UR55R[55$U$)a'DataFrame 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"/&Yq\K 5D VVAV *F  q>     II5 !||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