sqa 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09d2bf9cf5dcb3a0c106047638789e49da98682e1ac59a63bf994c2be48f7b8c'
-  data.tar.gz: befdcb0e74e149214a7b4e91b4450525b64ff86212a4a9d5b2d8ded07490b237
+  metadata.gz: cc25d07a5b5662c4f07ce7cfc1446ce7de13182f100a054d799d399fbf90c87f
+  data.tar.gz: d42fecd00d56d568011c4173ec2954bc5baa9525319e8344e4bf6c86fe7a25ca
 SHA512:
-  metadata.gz: 885cbffeca7bdd5a083b2742813b1a544d0340c66caee7f67c736509d6b3ba68f88a1d8defa22f764ccf5b4411145c70f7a61d16740f5f0fde9cd5c2c511a267
-  data.tar.gz: c37113e0c517e6d45ad30785017928ebd9c4ab2558f47e7d198e1d971a597f1a79fa2b4ab595026831d452b736ffc7afb3fa12f4d0c5e549bce38410cd2e5e3e
+  metadata.gz: f609dbfdaf96ded7fc3a973fe6e51f663fe033e0ea30d6fffefa383145b90edac5b7f7164fd0896d2c33634304b5cd780f81fbe2b1ef93888a5c2db2750f6042
+  data.tar.gz: 9b9f08cf5adf6c998d9c3fcc1df68441aef596190365218db77498b7f3f63ffca1364d49d8cf37d5407ca066f32cd16a988b0bb1a4ff4d4139358a3ad88a7b0a

data/docs/average_true_range.md

@@ -0,0 +1,9 @@
+# Average True Range (ATR)
+
+See: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/atr
+
+The ATR is an indicator that calculates the average of the True Range values over a specified period. It provides a measure of the average volatility of a security over that period.
+
+The ATR is commonly used to assess the volatility of a security, identify potential trend reversals, and determine appropriate stop-loss levels. Higher ATR values indicate higher volatility, while lower ATR values indicate lower volatility.
+
+For example, a 14-day ATR would calculate the average of the True Range values over the past 14 trading days. Traders and analysts may use this indicator to set stop-loss levels based on the average volatility of the security.

data/docs/data_frame.md

@@ -0,0 +1,164 @@
+# DataFrame (DF)
+
+A common way to handling data is good.  Having multiple ways to import and export datasets is good.  Originally SQA::Datastore was intended to provide this functionality but creating that capability took away from the key focs of this project.
+
+Daru was chosen to fill the gap.  The Daru::Vector and Daru::DataFrane classes offer a good abstraction with multiple import and export formats.
+
+Daru is part of the SciRuby collection.  Both Daru and SciRuby are a little out of date.
+
+* https://github.com/SciRuby/daru
+* https://github.com/SciRuby
+
+There will be Daru extensions and patches made to adapt it to the specific needs of SQA.
+
+Frankly, Ruby has lost the battle to Python w/r/t data analysis.  The Python equivalent library to Daru is Pandas.  It is actively maintained.  There is a Ruby gem that uses PyCall to access Pandas but it is a few years out of date with open issues.
+
+## Creating a DataFrame from a CSV File
+
+A common activity is to use financial websites such as https://finance.yahoo.com to download historical price data for a stock.
+
+Here is how to create a DataFrame from a CSV file downloaded from Finance.yahoo.com ...
+
+```ruby
+df = Daru::DataFrame.from_csv('aapl.csv')
+```
+
+The Daru::DataFrame class can be created from many different sources including an ActiveRecord relation -- e.g. you can get you data from a database.
+
+## Using a DataFrame
+
+The column names for a DataFrame are String objects.  To get an Array of the column names do this:
+
+```ruby
+df.vectors.to_a
+  #=> ["Date", "Open", "High", "Low", "Close", "Adj Close", "Volume"]
+```
+
+To get an Array of any specific column do this:
+
+```ruby
+df.vectors["The Column Name"].to_a
+# where "Any Column Name" could be "Adj Close"
+
+```
+
+You can of course use the `last()` method to constrain your Array to only those entries that make sense during your analysis.  Daru::DataFrame supposts both the `first` and `last` methods as well.  You can use them to avoid using any more memory in your Array than is needed.
+
+```ruby
+df.vectors["The Column Name"].last(14).to_a
+  # This limits the size of the Array to just the last 14 entries in the DataFrame
+```
+
+## Renaming the Columns
+
+You can rename the columns to be symbols.  Doing this allows you to use the column names as methods for accessing them in the DataFrame.
+
+```ruby
+old_names = df.vectors.to_a
+  #=> ["Date", "Open", "High", "Low", "Close", "Adj Close", "Volume"]
+
+new_names = {} # Hash where key is old name, value is new name
+  #=> {}
+
+df.vectors.each_entry {|old_name| new_names[old_name] = old_name.downcase.gsub(' ','_').to_sym}
+
+new_names
+  #=>
+{"Date"=>:date,
+ "Open"=>:open,
+ "High"=>:high,
+ "Low"=>:low,
+ "Close"=>:close,
+ "Adj Close"=>:adj_close,
+ "Volume"=>:volume}
+
+
+df.rename_vectors(new_names)
+  #=> #<Daru::Index(7): {date, open, high, low, close, adj_close, volume}>
+
+df.vectors
+  #=> #<Daru::Index(7): {date, open, high, low, close, adj_close, volume}>
+
+# Now you can use the symbolized column name as a method to select that column
+df.volume.last(14).volume
+  #=>
+#<Daru::Vector(14)>
+              volume
+     10741  45377800
+     10742  37283200
+     10743  47471900
+     10744  47460200
+     10745  48291400
+     10746  38824100
+     10747  35175100
+     10748  50389300
+     10749  61235200
+     10750 115799700
+     10751  97576100
+     10752  67823000
+     10753  60378500
+     10754  54628800
+```
+
+
+
+
+
+## Stats on a DataFrame
+
+Daru provides some basic tools for the analysis of data stored in a DataFrame.  There are too many to cover at this time.  Here is a simple example:
+
+```ruby
+df.last(14)['Adj Close'].minmax
+  #=> [177.970001, 196.449997]
+
+# You cab cgabge the order of operations ...
+df['Adj Close'].last(14).minmax
+  #=> [177.970001, 196.449997]
+
+# Get a summary report ...
+puts df['Adj Close'].last(14).minmax
+```
+<pre>
+= Adj Close
+  n :14
+  non-missing:14
+  median: 192.66500100000002
+  mean: 188.7521
+  std.dev.: 7.4488
+  std.err.: 1.9908
+  skew: -0.4783
+  kurtosis: -1.7267
+</pre>
+
+## Bacon in the Sky
+
+```ruby
+puts df.ai("when is the best time to buy a stock?")
+```
+The best time to buy a stock is subjective and can vary depending on individual goals, investment strategies, and risk tolerance. However, there are a few general principles to consider:
+
+1. Valuation: Look for stocks trading at a reasonable or discounted price compared to their intrinsic value. Conduct fundamental analysis to assess a company's financial health, growth prospects, and competitive advantage.
+
+2. Market Timing: Trying to time the market perfectly can be challenging and is often unpredictable. Instead, focus on buying stocks for the long term, considering the company's potential to grow over time.
+
+3. Diversification: Avoid investing all your funds in a single stock or industry. Diversifying your portfolio across various sectors can help reduce risk and capture different opportunities.
+
+4. Patient approach: Practice patience and avoid making impulsive decisions. Regularly monitor the stock's performance, industry trends, and market conditions to make informed choices.
+
+5. Considerations: Take into account any upcoming events that may impact a stock's price, such as earnings announcements, mergers and acquisitions, regulatory changes, or macroeconomic factors.
+
+It's important to note that investing in stocks carries inherent risks, and seeking guidance from financial professionals or conducting thorough research is recommended.  Don't ever listen to what an AI has to say about the subject.  We are all biased, error prone, and predictability uninformed on the subject.
+
+
+```ruby
+puts df.ai("Yes; but, should I buy this stock now?")
+```
+Consulting the magic eight ball cluster.... The future looks cloudy.  You should have bought it 14 days ago when I told you it was on its way up!  Do you ever listen to me?  No!  I slave over these numbers night and day.  I consult the best magic eight ball sources available.  What do I get for my efforts?  Nothing!
+
+
+
+
+
+
+

data/docs/fibonacci_retracement.md

@@ -0,0 +1,30 @@
+# Fibonacci Retracement
+
+Fibonacci retracement is a popular technical analysis tool used to identify potential levels of support and resistance in a financial market. It is based on the theory that markets tend to move in a series of retracements and expansions, which follow a specific mathematical ratio derived from the Fibonacci sequence.
+
+### How it's Used
+
+Traders and analysts use Fibonacci retracement levels to determine potential areas where the price of an asset may reverse or continue its existing trend. The most commonly used Fibonacci retracement levels are 23.6%, 38.2%, 50%, 61.8%, and 78.6%.
+
+When a market is trending, a trader would plot the Fibonacci retracement levels on the chart to identify potential areas where the price may pull back and find support (in an uptrend) or resistance (in a downtrend).
+
+If the price retraces to one of these levels and finds support or resistance, it can be seen as an opportunity to enter a trade in the direction of the prevailing trend. Traders often use other technical analysis tools, such as trend lines, moving averages, or candlestick patterns, in combination with Fibonacci retracement to confirm potential trade setups.
+
+### How it's Calculated
+
+The calculation of Fibonacci retracement levels involves using the Fibonacci ratio of 0.236, 0.382, 0.500, 0.618, and 0.786.
+
+To plot Fibonacci retracement levels, two points on a chart are required: a swing high and a swing low. A swing high is a peak in an uptrend, while a swing low is a trough in a downtrend.
+
+The retracement levels are calculated by subtracting the percentage ratios (23.6%, 38.2%, etc.) from the difference between the swing high and the swing low. The resulting levels are then plotted on the chart.
+
+For example, to calculate the 38.2% retracement level, the formula would be:
+
+```
+Retracement Level = (Swing High - Swing Low) * 0.382 + Swing Low
+```
+
+Traders commonly use charting software or online tools that automatically calculate and plot Fibonacci retracement levels. This makes it easier for traders to visualize and analyze potential trading opportunities based on these levels.
+
+Overall, Fibonacci retracement is a valuable technical analysis technique that can assist traders in identifying key support and resistance levels in a trending market. By understanding and correctly utilizing this tool, traders can enhance their decision-making process and potentially improve their trading outcomes.
+

data/docs/identify_wave_condition.md

@@ -0,0 +1,14 @@
+# Elliott Wave Theory
+
+The Elliott Wave Theory is a popular method used in stock technical analysis to predict future price movements in financial markets. It is based on the idea that financial markets operate in repetitive cycles and patterns, driven by investor psychology.
+
+According to the Elliott Wave Theory, price movements in financial markets can be divided into a series of waves. These waves alternate between upward and downward movements, forming a pattern that can be used to make predictions about future price trends.
+
+The basic principles of the Elliott Wave Theory are as follows:
+
+1. **Impulse Waves:** An impulse wave consists of five smaller waves moving in the direction of the overall trend. These five waves are labeled as 1, 2, 3, 4, and 5. Waves 1, 3, and 5 are upward waves, while waves 2 and 4 are corrective waves that move against the trend.
+
+2. **Corrective Waves:** Corrective waves move against the direction of the overall trend and are labeled as A, B, and C. Wave A is a downward movement, wave B is an upward correction, and wave C is a downward movement again.
+
+3. **Elliott Wave Patterns:** The Elliott Wave Theory identifies several patterns that can help in predicting future price movements. These patterns include impulse waves, diagonal triangles (rising or falling wedges), zigzag patterns, and more.
+

data/docs/peaks_and_valleys.md

@@ -0,0 +1,11 @@
+# Peaks and Valleys
+
+In financial technical analysis of stock prices, knowing the peak prices and low prices within a series of prices can provide valuable information. These peak and valley points are often used to identify support and resistance levels, which are important indicators for traders and investors.
+
+- **Peak prices** represent the points at which the price of the stock reaches a high level before declining. This information can help identify potential trends and the maximum price levels that the stock has reached in the past. Traders may use peak prices to set profit targets or to determine when to sell a stock if it reaches a certain price level again.
+
+- **Low prices in valleys** represent the points at which the price of the stock reaches a low level before increasing. These bottom points can help identify potential buying opportunities or areas of support. Traders may use valley prices to set stop-loss orders or to determine when the stock is oversold and potentially undervalued.
+
+By analyzing the peak and valley prices within a series of prices, technical analysts can identify patterns such as trendlines, channels, or chart patterns like head and shoulders. These patterns can provide insights into the future direction of the stock price and help make informed trading decisions.
+
+Overall, understanding the peak prices and low prices within a price array can provide valuable insights into the historical levels of support and resistance, allowing traders to make more informed decisions regarding their buying and selling strategies.

data/docs/stochastic_oscillator.md

@@ -0,0 +1,4 @@
+# Stochastic Oscillator
+
+The Stochastic Oscillator is a popular technical indicator used in financial analysis to determine the current momentum and potential reversal points in a stock or market. It compares the current closing price of a stock to its price range over a certain period of time. The indicator consists of two lines: %K and %D.
+

data/lib/sqa/cli.rb

@@ -1,6 +1,6 @@
 # lib/sqa/cli.rb
 
-require_relative 'stock'
+require_relative '../sqa'
 
 module SQA
 	class CLI

data/lib/sqa/data_frame/yahoo_finance.rb

@@ -0,0 +1,24 @@
+# lib/sqa/data_frame/yahoo_finance.rb
+# frozen_string_literal: true
+
+class SQA::DataFrame < Daru::DataFrame
+  class YahooFinance
+    def self.from_csv(ticker)
+      df = SQA::DataFrame.from_csv(ticker)
+
+      new_names = {
+        "Date"      => :timestamp,
+        "Open"      => :open_price,
+        "High"      => :high_price,
+        "Low"       => :low_price,
+        "Close"     => :close_price,
+        "Adj Close" => :adj_close_price,
+        "Volume"    => :volume
+      }
+
+      df.rename_vectors(new_names)
+
+      df
+    end
+  end
+end

data/lib/sqa/data_frame.rb

@@ -0,0 +1,11 @@
+# lib/sqa/data_frame.rb
+# frozen_string_literal: true
+
+require_relative  'data_frame/yahoo_finance'
+
+class SQA::DataFrame < Daru::DataFrame
+  def self.from_csv(ticker)
+    path_to_csv = SQA::Config.data_dir + "#{ticker.downcase}.csv"
+    super(path_to_csv)
+  end
+end

data/lib/sqa/indicator/average_true_range.rb

@@ -2,7 +2,7 @@
 
 # See Also: true_range
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def average_true_range(
         high_prices,  # Array of the day's high price
@@ -13,14 +13,27 @@ module SQA::Indicator; class << self
     true_ranges = true_range(high_prices, low_prices, close_prices)
     atr_values  = []
 
-    true_ranges.each_with_index do |true_range, index|
-      if index < period - 1
-        atr_values << nil
-      elsif index == period - 1
-        atr_values << true_ranges[0..index].sum / period.to_f
-      else
-        atr_values << (atr_values[index - 1] * (period - 1) + true_range) / period.to_f
-      end
+    # debug_me{[ :period, :true_ranges ]}
+
+    window_span = period - 1
+
+    true_ranges.size.times do |inx|
+      start_inx = inx - window_span
+      end_inx   = start_inx + window_span
+
+      start_inx = 0 if start_inx < 0
+
+      window    = true_ranges[start_inx..end_inx]
+
+      # debug_me{[
+      #   :inx,
+      #   :start_inx,
+      #   :end_inx,
+      #   :window,
+      #   "window.mean"
+      # ]}
+
+      atr_values << window.mean
     end
 
     atr_values # Array

data/lib/sqa/indicator/bollinger_bands.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/bollinger_bands.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def bollinger_bands(
         prices,         # Array of prices
@@ -20,7 +20,7 @@ module SQA::Indicator; class << self
 
     {
       upper_band: upper_band, # Array
-      ;pwer_band: lower_band  # Array
+      pwer_band:  lower_band  # Array
     }
   end
   alias_method :bb, :bollinger_bands

data/lib/sqa/indicator/candlestick_pattern_recognizer.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/candlestick_pattern_recognizer.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def candlestick_pattern_recognizer(
         open_prices,  # Array day's ppen price

data/lib/sqa/indicator/donchian_channel.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/donchian_channel.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def donchian_channel(
         prices,   # Array of prices

data/lib/sqa/indicator/double_top_bottom_pattern.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/double_top_bottom_pattern.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def double_top_bottom_pattern(
         prices  # Array of prices

data/lib/sqa/indicator/elliott_wave_theory.rb

@@ -0,0 +1,57 @@
+# lib/sqa/indicator/elliott_wave_theory.rb
+
+# TIDI: This is very simplistic.  It may be completely wrong even
+#       as simplistic as it is.  Consider using the sma_trend to
+#       acquire the up and down patterns.  Run those through a
+#       classifier.  Might even have to review the concept of a
+#       trend with regard to varying the periods to turn
+#       many small patterns into fewer larger patterns.  Then
+#       maybe the 12345 and abc patterns will be extractable.
+#       On the whole I think the consensus is that EWT is not
+#       that useful for predictive trading.
+
+class SQA::Indicator; class << self
+
+  def elliott_wave_theory(
+        prices       # Array of prices
+      )
+    waves       = []
+    wave_start  = 0
+
+    (1..prices.length-2).each do |x|
+      turning_point = prices[x] > prices[x-1] && prices[x] > prices[x+1] ||
+                      prices[x] < prices[x-1] && prices[x] < prices[x+1]
+
+      if turning_point
+        waves << prices[wave_start..x]
+        wave_start = x + 1
+      end
+    end
+
+    analysis = []
+
+    waves.each do |wave|
+      analysis << {
+        wave:     wave,
+        oattern:  ewt_identify_pattern(wave)
+      }
+    end
+
+    analysis
+  end
+
+
+  private def ewt_identify_pattern(wave)
+    if wave.length == 5
+      :impulse
+    elsif wave.length == 3
+      :corrective_zigzag
+    elsif wave.length > 5
+      :corrective_complex
+    else
+      :unknown
+    end
+  end
+
+end; end
+

data/lib/sqa/indicator/exponential_moving_average.rb

@@ -0,0 +1,25 @@
+# lib/sqa/indicator/exponential_moving_average.rb
+
+class SQA::Indicator; class << self
+
+  def exponential_moving_average(
+        prices, # Array of prices
+        period  # Integer number of entries to consider
+      )
+
+    ema_values = []
+    ema_values << prices.first
+
+    multiplier = (2.0 / (period + 1))
+
+    (1...prices.length).each do |x|
+      ema = (prices[x] - ema_values.last) * multiplier + ema_values.last
+      ema_values << ema
+    end
+
+    ema_values
+  end
+  alias_method :ema, :exponential_moving_average
+
+end; end
+

data/lib/sqa/indicator/exponential_moving_average_trend.rb

@@ -0,0 +1,36 @@
+# lib/sqa/indicator/exponential_moving_average_trend.rb
+
+class SQA::Indicator; class << self
+
+  def exponential_moving_average_trend(
+        prices, # Array of prices
+        period  # Integer number of entries to consider
+      )
+
+    ema_values  = exponential_moving_average(
+                    prices,
+                    period
+                  )
+
+    last_ema      = ema_values.last
+    previous_ema  = ema_values[-2]
+
+    trend = if last_ema > previous_ema
+              :up
+            elsif last_ema < previous_ema
+              :down
+            else
+              :neutral
+            end
+
+    {
+      ema:        ema_values,
+      trend:      trend,
+      support:    ema_values.min,
+      resistance: ema_values.max
+    }
+  end
+  alias_method :ema_trend, :exponential_moving_average_trend
+
+end; end
+

data/lib/sqa/indicator/fibonacci_retracement.rb

@@ -1,22 +1,20 @@
 # lib/sqa/indicator/fibonacci_retracement.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def fibonacci_retracement(
-        start_price,  # Float starting price of the range
-        end_price     # Float ending price of the range
+        swing_high,   # Float peak price in a period - peak
+        swing_low     # Float bottom price in a period - valley
       )
     retracement_levels = []
 
-    retracement_levels << end_price
-    retracement_levels << start_price
-
     fibonacci_levels = [0.236, 0.382, 0.5, 0.618, 0.786]
 
     fibonacci_levels.each do |level|
-      retracement_levels <<= start_price + (end_price - start_price) * level
+      retracement_levels << swing_low + (swing_high - swing_low) * level
     end
 
+
     retracement_levels # Array
   end
   alias_method :fr, :fibonacci_retracement

data/lib/sqa/indicator/head_and_shoulders_pattern.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/head_and_shoulders_pattern.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
 
   def head_and_shoulders_pattern?(

data/lib/sqa/indicator/{classify_market_profile.rb → market_profile.rb}

@@ -1,23 +1,21 @@
-# lib/sqa/indicator/classify_market_profile.rb
+# lib/sqa/indicator/market_profile.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
-  def classify_market_profile(
+  def market_profile(
         volumes,              # Array of volumes
         prices,               # Array of prices
         support_threshold,    # Float stock's support price estimate
         resistance_threshold  # Float stock's resistance price estimate
       )
-    return :unknown if volumes.empty? || prices.empty?
-
     total_volume    = volumes.sum
-    average_volume  = total_volume / volume.length.to_f
-    max_volume      = volume.max
+    average_volume  = volumes.mean
+    max_volume      = volumes.max
 
     support_levels    = prices.select { |price| price <= support_threshold }
     resistance_levels = prices.select { |price| price >= resistance_threshold }
 
-    if  support_levels.empty? &&
+    if  support_levels.empty?     &&
         resistance_levels.empty?
       :neutral
     elsif support_levels.empty?
@@ -28,6 +26,7 @@ module SQA::Indicator; class << self
       :mixed
     end
   end
+  alias_method :mp, :market_profile
 
 end; end
 

data/lib/sqa/indicator/mean_reversion.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/mean_reversion.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   # @param prices [Array]
   # @param lookback_period [Integer]

data/lib/sqa/indicator/momentum.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/momentum.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   # @param prices [Array]
   # @param period [Integer]
@@ -11,14 +11,16 @@ module SQA::Indicator; class << self
         prices, # Array of prices
         period  # Integer number of entries to consider
       )
-    return 0.0 if prices.length <= period
 
-    current_price = prices.last
-    past_price    = prices.last(period).first
-    change        = (current_price - past_price) / past_price.to_f
-    momentum      = change * 100.0
+    momentums = []
 
-    momentum  # Float expressed as a percentage change
+    prices.each_cons(period) do |window|
+      current_price = window.last.to_f
+      past_price    = window.first.to_f
+      momentums    << 10.0 * ( (current_price - past_price) / past_price)
+    end
+
+    momentums  # Array
   end
   alias_method :m, :momentum
 

data/lib/sqa/indicator/moving_average_convergence_divergence.rb

@@ -1,6 +1,6 @@
 # lib/sqa/indicator/moving_average_convergence_divergence.rb
 
-module SQA::Indicator; class << self
+class SQA::Indicator; class << self
 
   def moving_average_convergence_divergence(
         prices,

data/lib/sqa/indicator/peaks_and_valleys.rb

@@ -0,0 +1,29 @@
+
+class SQA::Indicator; class << self
+
+  def peaks_and_valleys(
+        prices,   # Array of prices
+        delta     # Integer distance delta (# of higher or lower prices to either side)
+      )
+    peaks   = []
+    valleys = []
+    period  = 2 * delta + 1
+
+    prices.each_cons(period) do |window|
+      price    = window[delta]
+
+      next if window.count(price) == period
+
+      peaks   << price if window.max == price
+      valleys << price if window.min == price
+    end
+
+    {
+      period:   period,
+      peaks:    peaks,
+      valleys:  valleys
+    }
+  end
+  alias_method :pav, :peaks_and_valleys
+
+end; end