Module: YfAsDataframe::PriceTechnical

Extended by:
ActiveSupport::Concern
Included in:
YfAsDataframe
Defined in:
lib/yf_as_dataframe/price_technical.rb

Instance Method Summary collapse

Instance Method Details

#ad(df) ⇒ Object 



8
9
10
11
12
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 8

def ad(df)
  inputs = ['High', 'Low','Adj Close','Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ad(inputs).first
  Polars::Series.new("Accum-Distrib Ln", [nil]*(df.rows.length - output.length)+output)
end

#adosc(df, short_window: 2, long_window: 5) ⇒ Object 



15
16
17
18
19
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 15

def adosc(df, short_window: 2, long_window: 5)
  inputs = ['High', 'Low','Adj Close','Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.adosc(inputs, short_period: short_window, long_period: long_window).first
  Polars::Series.new("#{short_window}/#{long_window} Accum-Distrib Osc", [nil]*(df.rows.length - output.length)+output)
end

#adx(df, column: 'Adj Close', window: 5) ⇒ Object Also known as: avg_dir_index 



22
23
24
25
26
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 22

def adx(df, column: 'Adj Close', window: 5)
  input = Polars::Series.new(df[column]).to_a
  output = Tulirb.adx([input], period: window).first
  Polars::Series.new("#{window}-day Avg Dir Movemt Idx for #{column}", [nil]*(df.rows.length - output.length)+output)
end

#adxr(df, column: 'Adj Close', window: 5) ⇒ Object Also known as: avg_dir_movement_rating 



30
31
32
33
34
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 30

def adxr(df, column: 'Adj Close', window: 5)
  input = Polars::Series.new(df[column]).to_a
  output = Tulirb.adxr([input], period: window).first
  Polars::Series.new("#{window}-day Avg Dir Movemt Rating for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#ao(df) ⇒ Object 



50
51
52
53
54
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 50

def ao(df)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ao(inputs).first
  Polars::Series.new("Accum-Distrib Ln", [nil]*(df.rows.length - output.length)+output) #)
end

#apo(df, column: 'Adj Close', short_window: 12, long_window: 29) ⇒ Object 



57
58
59
60
61
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 57

def apo(df, column: 'Adj Close', short_window: 12, long_window: 29)
  input = Polars::Series.new(df[column]).to_a
  output = Tulirb.ao([input], short_period: short_window, long_period: long_window).first
  Polars::Series.new("#{short_window}/#{long_window} Abs Price Osc for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#aroon(df, window: 20) ⇒ Object 



64
65
66
67
68
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 64

def aroon(df, window: 20)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.aroon(inputs, period: window).first
  Polars::Series.new("#{window} Aroon Ind", [nil]*(df.rows.length - output.length)+output) #)
end

#aroonosc(df, window: 20) ⇒ Object 



70
71
72
73
74
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 70

def aroonosc(df, window: 20)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.aroonosc(inputs, period: window).first
  Polars::Series.new("#{window} Aroon Osc Ind", [nil]*(df.rows.length - output.length)+output) #)
end

#atr(df, window: 20) ⇒ Object Also known as: avg_true_range 



85
86
87
88
89
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 85

def atr(df, window: 20)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.atr(inputs, period: window).first
  Polars::Series.new("#{window}-day Avg True Range", [nil]*(df.rows.length - output.length)+output)#)
end

#avg_daily_trading_volume(df, window: 20) ⇒ Object 



39
40
41
42
43
44
45
46
47
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 39

def avg_daily_trading_volume(df, window: 20)
  df.insert_at_idx(0, Polars::Series.new('idx', (1..df.length).to_a))
  df = df.set_sorted('idx', descending: false)

  adtv = df.group_by_rolling(index_column: 'idx', period: "#{window}i").
    agg([Polars.mean('Volume').alias("ADTV(#{window})")]).to_series(1)
  df = df.drop('idx')
  adtv
end

#avg_price(df) ⇒ Object Also known as: avgprice 



77
78
79
80
81
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 77

def avg_price(df)
  inputs = ['Open', 'High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.avgprice(inputs).first
  Polars::Series.new("Avg Price", [nil]*(df.rows.length - output.length)+output) #)
end

#bbands(df, column: 'Adj Close', window: 20, stddev: 1) ⇒ Object 



93
94
95
96
97
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 93

def bbands(df, column: 'Adj Close', window: 20, stddev: 1 )
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.bbands(inputs, period: window, stddev: stddev).first
  Polars::Series.new("#{window}-day Boll Band for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#bop(df) ⇒ Object 



100
101
102
103
104
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 100

def bop(df)
  inputs = ['Open', 'High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.bop(inputs).first
  Polars::Series.new("Bal of Power", [nil]*(df.rows.length - output.length)+output) #)
end

#cci(df, window: 20) ⇒ Object 



107
108
109
110
111
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 107

def cci(df, window: 20)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.cci(inputs, period: window).first
  Polars::Series.new("#{window}-day Comm Channel Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#cmo(df, column: 'Adj Close', window: 20) ⇒ Object 



114
115
116
117
118
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 114

def cmo(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.cmo(inputs, period: window).first
  Polars::Series.new("#{window}-day Chande Mom Osc for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#cvi(df, window: 20) ⇒ Object 



121
122
123
124
125
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 121

def cvi(df, window: 20)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.cvi(inputs, period: window).first
  Polars::Series.new("#{window}-day Chaikins Volatility", [nil]*(df.rows.length - output.length)+output) #)
end

#dema(df, column: 'Adj Close', window: 20) ⇒ Object 



128
129
130
131
132
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 128

def dema(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.dema(inputs, period: window).first
  Polars::Series.new("Dbl EMA(#{window})", [nil]*(df.rows.length - output.length)+output) #)
end

#di(df, window: 20) ⇒ Object 



135
136
137
138
139
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 135

def di(df, window: 20)
  inputs = ['High','Low','Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.di(inputs, period: window).first
  Polars::Series.new("#{window}-day Dir Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#dm(df, window: 20) ⇒ Object 



142
143
144
145
146
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 142

def dm(df, window: 20)
  inputs = ['High','Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.dm(inputs, period: window).first
  Polars::Series.new("#{window}-day Dir Movemt", [nil]*(df.rows.length - output.length)+output) #)
end

#dpo(df, column: 'Adj Close', window: 20) ⇒ Object 



149
150
151
152
153
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 149

def dpo(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.dpo(inputs, period: window).first
  Polars::Series.new("#{window}-day Detrend Price Osc of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#dx(df, window: 20) ⇒ Object 



156
157
158
159
160
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 156

def dx(df, window: 20)
  inputs = ['High','Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.dx(inputs, period: window).first
  Polars::Series.new("#{window}-day Dir Movemt Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#ema(df, column: 'Adj Close', window: 5) ⇒ Object 



163
164
165
166
167
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 163

def ema(df, column: 'Adj Close', window: 5) 
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ema(inputs, period: window).first
  Polars::Series.new("EMA(#{window}) for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#emv(df) ⇒ Object 



170
171
172
173
174
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 170

def emv(df)
  inputs = ['High', 'Low', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.emv(inputs).first
  Polars::Series.new("Ease of Mvmt", [nil]*(df.rows.length - output.length)+output) #)
end

#fisher(df, window: 20) ⇒ Object 



177
178
179
180
181
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 177

def fisher(df, window: 20) 
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.fisher(inputs, period: window).first
  Polars::Series.new("#{window}-day Fisher Xform", [nil]*(df.rows.length - output.length)+output) #)
end

#fosc(df, window: 20) ⇒ Object 



184
185
186
187
188
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 184

def fosc(df, window: 20) 
  inputs = ['Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.fosc(inputs, period: window).first
  Polars::Series.new("Fcast Osc", [nil]*(df.rows.length - output.length)+output) #)
end

#hma(df, column: 'Adj Close', window: 5) ⇒ Object 



191
192
193
194
195
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 191

def hma(df, column: 'Adj Close', window: 5) 
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ema(inputs, period: window).first
  Polars::Series.new("EMA(#{window}) for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#kama(df, column: 'Adj Close', window: 5) ⇒ Object 



198
199
200
201
202
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 198

def kama(df, column: 'Adj Close', window: 5) 
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.kama(inputs, period: window).first
  Polars::Series.new("KAMA(#{window}) for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#kvo(df, short_window: 5, long_window: 20) ⇒ Object 



205
206
207
208
209
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 205

def kvo(df, short_window: 5, long_window: 20)
  inputs = ['High', 'Low', 'Adj Close', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.kvo(inputs, short_period: short_window, long_period: long_window).first
  Polars::Series.new("#{short_window}/#{long_window} Klinger Vol Osc", [nil]*(df.rows.length - output.length)+output) #)
end

#linreg(df, column: 'Adj Close', window: 20) ⇒ Object 



212
213
214
215
216
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 212

def linreg(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.linreg(inputs, period: window).first
  Polars::Series.new("#{window}-day Lin Reg Est for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#linregintercept(df, column: 'Adj Close', window: 20) ⇒ Object 



219
220
221
222
223
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 219

def linregintercept(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.linregintercept(inputs, period: window).first
  Polars::Series.new("#{window}-day Lin Reg Int for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#linregslope(df, column: 'Adj Close', window: 20) ⇒ Object 



226
227
228
229
230
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 226

def linregslope(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.linregslope(inputs, period: window).first
  Polars::Series.new("#{window}-day Lin Reg Slope for #{column}", [nil]*(df.rows.length - output.length)+output)
end

#macd(df, column: 'Adj Close', short_window: 12, long_window: 26, signal_window: 9) ⇒ Object 



233
234
235
236
237
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 233

def macd(df, column: 'Adj Close', short_window: 12, long_window: 26, signal_window: 9)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.macd(inputs, short_period: short_window, long_period: long_window, signal_period: signal_window).first
  Polars::Series.new("#{short_window}/#{long_window}/#{signal_window} MACD for #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#marketfi(df) ⇒ Object 



240
241
242
243
244
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 240

def marketfi(df)
  inputs = ['High', 'Low', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.marketfi(inputs).first
  Polars::Series.new("Mkt Facilitation Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#mass(df, window: 20) ⇒ Object 



247
248
249
250
251
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 247

def mass(df, window: 20)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.mass(inputs, period: window).first
  Polars::Series.new("#{window}-day Mass Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#max(df, column: 'Adj Close', window: 20) ⇒ Object 



254
255
256
257
258
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 254

def max(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.max(inputs, period: window).first
  Polars::Series.new("Max of #{column} in #{window}-day pd", [nil]*(df.rows.length - output.length)+output) #)
end

#md(df, column: 'Adj Close', window: 20) ⇒ Object 



261
262
263
264
265
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 261

def md(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.md(inputs, period: window).first
  Polars::Series.new("Mean Dev of #{column} in #{window}-day pd", [nil]*(df.rows.length - output.length)+output) #)
end

#median_price(df) ⇒ Object Also known as: medprice 



268
269
270
271
272
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 268

def median_price(df)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.medprice(inputs).first
  Polars::Series.new("Med Price", [nil]*(df.rows.length - output.length)+output) #)
end

#mfi(df, window: 20) ⇒ Object 



276
277
278
279
280
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 276

def mfi(df, window: 20)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.mfi(inputs, period: window).first
  Polars::Series.new("#{window}-day Money Flow Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#min(df, column: 'Adj Close', window: 20) ⇒ Object 



283
284
285
286
287
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 283

def min(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.min(inputs, period: window).first
  Polars::Series.new("Min of #{column} in #{window}-day pd", [nil]*(df.rows.length - output.length)+output) #)
end

#mom(df, column: 'Adj Close', window: 5) ⇒ Object Also known as: momentum 



290
291
292
293
294
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 290

def mom(df, column: 'Adj Close', window: 5)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.mom(inputs, period: window).first
  Polars::Series.new("#{window}-day Momentum of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#moving_avgs(df, window: 20) ⇒ Object 



298
299
300
301
302
303
304
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 298

def moving_avgs(df, window: 20)
  df.insert_at_idx(0, Polars::Series.new('idx', (1..df.length).to_a))
  df = df.set_sorted('idx', descending: false)
  s = df.group_by_rolling(index_column: 'idx', period: "#{window}i").agg([Polars.mean('Adj Close').alias("MA(#{window})")]).to_series(1) #)
  df = df.drop('idx')
  s
end

#natr(df, window: 20) ⇒ Object Also known as: normalized_avg_true_range 



306
307
308
309
310
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 306

def natr(df, window: 20)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.natr(inputs, period: window).firs
  Polars::Series.new("#{window}-day Norm Avg True Range", [nil]*(df.rows.length - output.length)+output) #)
end

#nvi(df) ⇒ Object 



342
343
344
345
346
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 342

def nvi(df)
  inputs = ['Adj Close', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.nvi(inputs).first
  Polars::Series.new("Neg Vol Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#obv(df) ⇒ Object 



349
350
351
352
353
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 349

def obv(df)
  inputs = ['Adj Close', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.obv(inputs).first
  Polars::Series.new("On Bal Vol", [nil]*(df.rows.length - output.length)+output) #)
end

#ppo(df, column: 'Adj Close', short_window: 12, long_window: 26) ⇒ Object 



356
357
358
359
360
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 356

def ppo(df, column: 'Adj Close', short_window: 12, long_window: 26)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ppo(inputs, short_period: short_window, long_period: long_window).first
  Polars::Series.new("#{short_window}/#{long_window} Pctage Price Osc of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#psar(df, acceleration_factor_step: 0.2, acceleration_factor_maximum: 2) ⇒ Object 



363
364
365
366
367
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 363

def psar(df, acceleration_factor_step: 0.2, acceleration_factor_maximum: 2)
  inputs = ['High', 'Low'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.psar(inputs, acceleration_factor_step, acceleration_factor_maximum).first
  Polars::Series.new("Parabolic SAR w step #{acceleration_factor_step} and max #{acceleration_factor_maximum}", [nil]*(df.rows.length - output.length)+output) #)
end

#pvi(df) ⇒ Object 



370
371
372
373
374
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 370

def pvi(df)
  inputs = ['Adj Close', 'Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.pvi(inputs).first
  Polars::Series.new("Pos Vol Idx", [nil]*(df.rows.length - output.length)+output) #)
end

#qstick(df, window: 20) ⇒ Object 



377
378
379
380
381
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 377

def qstick(df, window: 20)
  inputs = ['Open', 'Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.qstick(inputs, period: window).first
  Polars::Series.new("#{window}-day Qstick", [nil]*(df.rows.length - output.length)+output) #)
end

#roc(df, column: 'Adj Close', window: 20) ⇒ Object 



384
385
386
387
388
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 384

def roc(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.roc(inputs, period: window).first
  Polars::Series.new("Rate of Chg of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#rocr(df, column: 'Adj Close', window: 20) ⇒ Object 



391
392
393
394
395
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 391

def rocr(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.rocr(inputs, period: window).first
  Polars::Series.new("Rate of Chg Ratio of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#rsi(df, window: 20) ⇒ Object 



397
398
399
400
401
402
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 397

def rsi(df, window: 20)
  return nil if w == 1
  inputs = ['Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.rsi(inputs, period: window).first
  Polars::Series.new("#{window}-day RSI", [nil]*(df.rows.length - output.length)+output) #)
end

#sma(df, column: 'Adj Close', window: 20) ⇒ Object 



404
405
406
407
408
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 404

def sma(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.sma(inputs, period: window).first
  Polars::Series.new("SMA(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#stddev(df, column: 'Adj Close', window: 20) ⇒ Object 



411
412
413
414
415
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 411

def stddev(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.stddev(inputs, period: window).first
  Polars::Series.new("Rolling Stdev(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#stderr(df, column: 'Adj Close', window: 20) ⇒ Object 



418
419
420
421
422
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 418

def stderr(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.stderr(inputs, period: window).first
  Polars::Series.new("Rolling Stderr(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#stochrsi(df, column: 'Adj Close', window: 20) ⇒ Object 



425
426
427
428
429
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 425

def stochrsi(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.stochrsi(inputs, period: window).first
  Polars::Series.new("Stochastic RSI(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#sum(df, column: 'Adj Close', window: 20) ⇒ Object 



432
433
434
435
436
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 432

def sum(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.sum(inputs, period: window).first
  Polars::Series.new("Rolling #{window}-day Sum of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#tema(df, column: 'Adj Close', window: 20) ⇒ Object 



438
439
440
441
442
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 438

def tema(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.tema(inputs, period: window).first
  Polars::Series.new("TEMA(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#tr(df, column: 'Adj Close') ⇒ Object Also known as: true_range 



445
446
447
448
449
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 445

def tr(df, column: 'Adj Close')
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.tr(inputs).first
  Polars::Series.new("True Range of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#trima(df, column: 'Adj Close', window: 20) ⇒ Object 



453
454
455
456
457
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 453

def trima(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.trima(inputs, period: window).first
  Polars::Series.new("Triang MA(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#trix(df, column: 'Adj Close', window: 20) ⇒ Object 



460
461
462
463
464
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 460

def trix(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.trix(inputs, period: window).first
  Polars::Series.new("Trix(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#tsf(df, column: 'Adj Close', window: 20) ⇒ Object 



467
468
469
470
471
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 467

def tsf(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.tsf(inputs, period: window).first
  Polars::Series.new("Time-series Fcast(#{window}) of #{window}", [nil]*(df.rows.length - output.length)+output) #)
end

#typical_price(df) ⇒ Object Also known as: typprice 



474
475
476
477
478
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 474

def typical_price(df)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.typprice(inputs).first
  Polars::Series.new("Typical Price", [nil]*(df.rows.length - output.length)+output) #)
end

#ultosc(df, short_window: 5, medium_window: 12, long_window: 26) ⇒ Object 



482
483
484
485
486
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 482

def ultosc(df, short_window: 5, medium_window: 12, long_window: 26)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.ultosc(inputs, short_period: short_window, medium_period: medium_window, long_period: long_window).first
  Polars::Series.new("Ult Osc(#{short_window}, #{medium_window}, #{long_window})", [nil]*(df.rows.length - output.length)+output) #)
end

#var(df, column: 'Adj Close', window: 20) ⇒ Object 



495
496
497
498
499
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 495

def var(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.var(inputs, period: window).first
  Polars::Series.new("Var over Per(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#vhf(df, column: 'Adj Close', window: 20) ⇒ Object 



502
503
504
505
506
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 502

def vhf(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.vhf(inputs, period: window).first
  Polars::Series.new("VHF(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#vidya(df, column: 'Adj Close', short_window: 5, long_window: 20, alpha: 0.2) ⇒ Object 



509
510
511
512
513
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 509

def vidya(df, column: 'Adj Close', short_window: 5, long_window: 20, alpha: 0.2)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.vidya(inputs, short_period: short_window, long_period: long_window, alpha: alpha).first
  Polars::Series.new("vidya(#{short_window},#{long_window},#{alpha}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#vol_weighted_moving_avg(df, window: 20) ⇒ Object Also known as: vwma 



529
530
531
532
533
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 529

def vol_weighted_moving_avg(df, window: 20)
  inputs = ['Adj Close','Volume'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.vwma(inputs, period: window).first
  Polars::Series.new("VWMA(#{window})", [nil]*(df.rows.length - output.length)+output) #)
end

#volatility(df, column: 'Adj Close', window: 20) ⇒ Object 



516
517
518
519
520
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 516

def volatility(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.volatility(inputs, period: window).first
  Polars::Series.new("#{window}-day Volatility of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#vosc(df, column: 'Adj Close', short_window: 5, long_window: 20) ⇒ Object 



523
524
525
526
527
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 523

def vosc(df, column: 'Adj Close', short_window: 5, long_window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.vosc(inputs, short_period: short_window, long_period: long_window).first
  Polars::Series.new("#{short_window}/#{long_window} Vol Osc of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#wad(df) ⇒ Object 



537
538
539
540
541
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 537

def wad(df)
  inputs = ['High','Low','Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.wad(inputs, period: window).first
  Polars::Series.new("Wms Accum/Distrib", [nil]*(df.rows.length - output.length)+output) #)
end

#wcprice(df) ⇒ Object 



544
545
546
547
548
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 544

def wcprice(df)
  inputs = ['High','Low','Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.stderr(inputs).first
  Polars::Series.new("Wtd Close Price", [nil]*(df.rows.length - output.length)+output) #)
end

#weighted_close_price(df) ⇒ Object 



488
489
490
491
492
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 488

def weighted_close_price(df)
  inputs = ['High', 'Low', 'Adj Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.wcprice(inputs).first
  Polars::Series.new("Wtd Close Price", [nil]*(df.rows.length - output.length)+output) #)
end

#wilders(df, column: 'Adj Close', window: 20) ⇒ Object 



551
552
553
554
555
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 551

def wilders(df, column: 'Adj Close', window: 20)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.wilders(inputs, period: window).first
  Polars::Series.new("#{window}-day Wilders Smoothing of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#willr(df, window: 20) ⇒ Object 



558
559
560
561
562
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 558

def willr(df, window: 20)
  inputs = ['High','Low','Close'].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.willr(inputs, period: window).first
  Polars::Series.new("#{window}-day Williams %R Ind", [nil]*(df.rows.length - output.length)+output) #)
end

#wma(df, column: 'Adj Close', window: 5) ⇒ Object 



565
566
567
568
569
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 565

def wma(df, column: 'Adj Close', window: 5)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.wma(inputs, period: window).first
  Polars::Series.new("WMA(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end

#zlema(df, column: 'Adj Close', window: 5) ⇒ Object 



572
573
574
575
576
 
# File 'lib/yf_as_dataframe/price_technical.rb', line 572

def zlema(df, column: 'Adj Close', window: 5)
  inputs = [column].map{|col| Polars::Series.new(df[col]).to_a}
  output = Tulirb.zlema(inputs, period: window).first
  Polars::Series.new("ZLEMA(#{window}) of #{column}", [nil]*(df.rows.length - output.length)+output) #)
end