sqa 0.0.1

data/lib/sqa/datastore.rb

@@ -0,0 +1,6 @@
+# lib/sqa/datastore.rb
+
+require_relative 'datastore/csv'
+require_relative 'datastore/active_record'
+
+# require_relative 'datastore/sqlite'

data/lib/sqa/errors.rb

@@ -0,0 +1,5 @@
+# lib/sqa/errors.rb
+
+module SQA
+	class BadParameterError < ArgumentError; end
+end

data/lib/sqa/indicator/README.md

@@ -0,0 +1,33 @@
+# Indicators
+
+An indicator is a formula/metric on a stock's historical activity.  It is presumed to be a forecast as to what the stock activity might be in the future.  A single indicator is not necessarily an accurate predictor of future events not is any specific group of indicators.
+
+In other words the future is uncertain.  Is it a coin flip?  Heads the stock's price goes up.  Tails, the stock's price goes down.  Its one or the other right?  What if the price never changes.  Then its not a coin flip.  Also what is the time frame involved in the forecast?  Is it tomorrow, next week, next month, next year, next decade?  What is the delta change in price that can be expected?
+
+So indicators are like TV weather forecastors.  Sometimes they are right.  Sometimes they are wrong.
+
+We are dealing with uncertainity.  In uncertainity there is chaos. If it is possible to be right more times that you are wrong you can make money.  If you are always wrong then always do the opposite and you will make money.  When you are wrong more times than you are right.... you loose.
+
+Its a game.  Game theory tells us that there are winners and losers. Bookies at the track make money every day by taking a cut of the losers loses before giving them to the winners.  Bookies always win so long as they keep their books balanced.  Accounts are important.
+
+Back to indicators.  Here is a list of the current indicators:
+
+
+
+* [Average True Range](average true range.md)
+* [Bollinger Bands](bollinger bands.md)
+* [Vandlestick Pattern Recognizer](candlestick pattern recognizer.md)
+* [Vlassify Market Profile](classify market profile.md)
+* [Donchian Channel](donchian channel.md)
+* [Double Top Bottom Pattern](double top bottom pattern.md)
+* [EMA Analysis](ema analysis.md)
+* [Fibonacci Retracement](fibonacci retracement.md)
+* [Head and Shoulders Pattern](head and shoulders pattern.md)
+* [Identify Wave Condition](identify wave condition.md)
+* [MACD](macd.md)
+* [Mean Reversion](mean reversion.md)
+* [Momentum](momentum.md)
+* [RSI](rsi.md)
+* [Simple Moving Average](simple moving average.md)
+* [Stochastic Oscillator](stochastic oscillator.md)
+* [True Range](true range.md)

data/lib/sqa/indicator/average_true_range.md

@@ -0,0 +1,9 @@
+# Average True Range
+
+Calculates the Average True Range (ATR) for a given set of price data.
+
+The Average True Range 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 Average True Range 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/lib/sqa/indicator/average_true_range.rb

@@ -0,0 +1,30 @@
+# lib/sqa/indicator/average_true_range.rb
+
+# See Also: true_range
+
+module SQA::Indicator; class << self
+
+  def average_true_range(
+        high_prices,  # Array of the day's high price
+        low_prices,   # Array of the day's low price
+        close_prices, # Array of the day's closing price
+        period        # Integer the number of days to consider
+      )
+    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
+    end
+
+    atr_values # Array
+  end
+  alias_method :atr, :average_true_range
+
+end; end

data/lib/sqa/indicator/bollinger_bands.md

@@ -0,0 +1,15 @@
+
+
+# Bollinger Bands
+
+This method takes in an array of historical prices for a stock, a period (the number of days to calculate the moving average and standard deviation over), and the number of standard deviations to use for the upper and lower Bollinger Bands. It uses the `moving_averages` method to calculate the moving average for the given period, and then calculates the standard deviation of the closing prices for each window of the given period. Finally, it calculates the upper and lower Bollinger Bands based on the moving average and standard deviation, and returns an array containing the upper and lower bands.
+
+The `num_std_dev` parameter in the Bollinger Bands method specifies the number of standard deviations to use for the upper and lower bands. The default value for this parameter can depend on the specific security being analyzed and the time period being used.
+
+A common default value for `num_std_dev` is 2, which corresponds to the standard deviation of the price data over the given time period. Using a value of 2 for `num_std_dev` will result in the upper and lower bands being placed at a distance of two standard deviations from the moving average.
+
+However, the optimal value for `num_std_dev` can vary depending on the volatility of the security being analyzed. For highly volatile securities, a larger value for `num_std_dev` may be more appropriate, while for less volatile securities, a smaller value may be more appropriate.
+
+Ultimately, the best default value for `num_std_dev` will depend on the specific use case and should be chosen based on the characteristics of the security being analyzed and the preferences of the analyst.
+
+The difference between the upper and lower bands can be an indicator of how volatile the stock is.

data/lib/sqa/indicator/bollinger_bands.rb

@@ -0,0 +1,28 @@
+# lib/sqa/indicator/bollinger_bands.rb
+
+module SQA::Indicator; class << self
+
+  def bollinger_bands(
+        prices,         # Array of prices
+        period,         # Integer number of entries to consider
+        num_std_devs=2  # Integer number of standard deviations
+      )
+    moving_averages     = simple_moving_average(prices, period)
+    standard_deviations = []
+
+    prices.each_cons(period) do |window|
+      standard_deviation = Math.sqrt(window.map { |price| (price - moving_averages.last) ** 2 }.sum / period)
+      standard_deviations << standard_deviation
+    end
+
+    upper_band = moving_averages.last + (num_std_devs * standard_deviations.last)
+    lower_band = moving_averages.last - (num_std_devs * standard_deviations.last)
+
+    {
+      upper_band: upper_band, # Array
+      ;pwer_band: lower_band  # Array
+    }
+  end
+  alias_method :bb, :bollinger_bands
+
+end; end

data/lib/sqa/indicator/candlestick_pattern_recognizer.md

@@ -0,0 +1,4 @@
+# Candlestick Chart Pattern
+
+Recognizes common candlestick chart patterns in the given price data.
+

data/lib/sqa/indicator/candlestick_pattern_recognizer.rb

@@ -0,0 +1,60 @@
+# lib/sqa/indicator/candlestick_pattern_recognizer.rb
+
+module SQA::Indicator; class << self
+
+  def candlestick_pattern_recognizer(
+        open_prices,  # Array day's ppen price
+        high_prices,  # Array day's high price
+        low_prices,   # Array day's low price
+        close_prices  # Array day's closing price
+      )
+    patterns = []
+
+    close_prices.each_with_index do |close, index|
+      if index >= 2
+        previous_close  = close_prices[index  - 1]
+        previous_open   = open_prices[index   - 1]
+        previous_high   = high_prices[index   - 1]
+        previous_low    = low_prices[index    - 1]
+
+        second_previous_close = close_prices[index  - 2]
+        second_previous_open  = open_prices[index   - 2]
+        second_previous_high  = high_prices[index   - 2]
+        second_previous_low   = low_prices[index    - 2]
+
+        if  close           > previous_close  &&
+            previous_close  < previous_open   &&
+            close           < previous_open   &&
+            close           > previous_low    &&
+            close           > second_previous_close
+          patterns << :bullish_engulfing
+
+        elsif close           < previous_close  &&
+              previous_close  > previous_open   &&
+              close           > previous_open   &&
+              close           < previous_high   &&
+              close           < second_previous_close
+          patterns << :bearish_engulfing
+
+        elsif close           > previous_close  &&
+              previous_close  < previous_open   &&
+              close           < previous_open   &&
+              close           < previous_low    &&
+              close           < second_previous_close
+          patterns << :bearish_harami
+
+        elsif close           < previous_close  &&
+              previous_close  > previous_open   &&
+              close           > previous_open   &&
+              close           > previous_high   &&
+              close           > second_previous_close
+          patterns << :bullish_harami
+        end
+      end
+    end
+
+    patterns
+  end
+
+end; end
+

data/lib/sqa/indicator/classify_market_profile.md

@@ -0,0 +1,4 @@
+# Market Profile Analysis
+
+Market profile analysis involves studying the distribution of trading volume and price levels over time. It helps identify areas of support and resistance and provides insights into market sentiment.
+

data/lib/sqa/indicator/classify_market_profile.rb

@@ -0,0 +1,33 @@
+# lib/sqa/indicator/classify_market_profile.rb
+
+module SQA::Indicator; class << self
+
+  def classify_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
+
+    support_levels    = prices.select { |price| price <= support_threshold }
+    resistance_levels = prices.select { |price| price >= resistance_threshold }
+
+    if  support_levels.empty? &&
+        resistance_levels.empty?
+      :neutral
+    elsif support_levels.empty?
+      :resistance
+    elsif resistance_levels.empty?
+      :support
+    else
+      :mixed
+    end
+  end
+
+end; end
+

data/lib/sqa/indicator/donchian_channel.md

@@ -0,0 +1,5 @@
+# Donchian Channel
+
+In the domain of computer programming, a Donchian Channel is a technical analysis indicator used to identify potential breakouts and trend reversals in financial markets. It consists of three lines: the upper channel line, the lower channel line, and the middle line.
+
+The upper channel line is calculated by finding the highest high over a specified period of time, while the lower channel line is calculated by finding the lowest low over the same period. The middle line is simply the average of the upper and lower channel lines.

data/lib/sqa/indicator/donchian_channel.rb

@@ -0,0 +1,29 @@
+# lib/sqa/indicator/donchian_channel.rb
+
+module SQA::Indicator; class << self
+
+  def donchian_channel(
+        prices,   # Array of prices
+        period    # Integer number of entries to consider
+      )
+    max               = -999999999
+    min               = 999999999
+    donchian_channel  = []
+
+    prices.each_with_index do |value, index|
+      value = value.to_f
+      max   = value if value > max
+      min   = value if value < min
+
+      if index >= period - 1
+        donchian_channel << [max, min, (max + min) / 2]
+        max = -999999999
+        min = 999999999
+      end
+    end
+
+    donchian_channel
+  end
+
+end; end
+

data/lib/sqa/indicator/double_top_bottom_pattern.md

@@ -0,0 +1,3 @@
+# Double Top Double Bottom Pattern
+
+Checks if a "double top" or "double bottom" pattern is present in the given price data.

data/lib/sqa/indicator/double_top_bottom_pattern.rb

@@ -0,0 +1,34 @@
+# lib/sqa/indicator/double_top_bottom_pattern.rb
+
+module SQA::Indicator; class << self
+
+  def double_top_bottom_pattern(
+        prices  # Array of prices
+      )
+    return :no_pattern if prices.length < 5
+
+    data                = prices.last(5)
+
+    first_peak          = data[0]
+    valley              = data[1]
+    second_peak         = data[2]
+    neckline            = data[3]
+    confirmation_price  = data[4]
+
+    if  first_peak          < second_peak &&
+        valley              > first_peak  &&
+        valley              > second_peak &&
+        confirmation_price  < neckline
+      :double_top
+    elsif first_peak          > second_peak &&
+          valley              < first_peak  &&
+          valley              < second_peak &&
+          confirmation_price  > neckline
+      :double_bottom
+    else
+      :no_pattern
+    end
+  end
+
+end; end
+

data/lib/sqa/indicator/ema_analysis.md

@@ -0,0 +1,19 @@
+# Exponential Moving Average (EMA)
+
+In financial analysis, the Exponential Moving Average (EMA) is a commonly used technical indicator that helps identify trends and smooth out price data. It is a type of moving average that gives more weight to recent prices, making it more responsive to recent price changes compared to other moving averages.
+
+The EMA is calculated by applying a smoothing factor (often represented as a percentage) to the previous EMA value and adding a weighted average of the current price. The smoothing factor determines the weight given to the most recent price data, with higher values giving more weight to recent prices.
+
+The EMA is used for various purposes in financial analysis, including:
+
+1. Trend Identification: The EMA is often used to identify the direction and strength of a trend. When the current price is above the EMA, it suggests an uptrend, while a price below the EMA suggests a downtrend. Traders and investors may use the EMA crossover (when the price crosses above or below the EMA) as a signal to enter or exit positions.
+
+2. Support and Resistance Levels: The EMA can act as dynamic support or resistance levels. In an uptrend, the EMA may provide support, and in a downtrend, it may act as resistance. Traders may use the EMA as a reference point for setting stop-loss orders or profit targets.
+
+3. Price Reversals: The EMA can help identify potential price reversals. When the price deviates significantly from the EMA, it may indicate an overbought or oversold condition, suggesting a potential reversal in the near future. Traders may use this information to anticipate price reversals and adjust their trading strategies accordingly.
+
+4. Volatility Assessment: The EMA can be used to assess market volatility. When the EMA is relatively flat, it suggests low volatility, while a steeply sloping EMA indicates higher volatility. Traders may adjust their trading strategies based on the level of volatility indicated by the EMA.
+
+It's important to note that the EMA is just one of many technical indicators used in financial analysis. It is often used in combination with other indicators, such as the Simple Moving Average (SMA), to gain a more comprehensive understanding of market trends and price movements.
+
+Traders and investors should consider their own trading strategies, risk tolerance, and timeframes when using the EMA or any other technical indicator for financial analysis. It's also recommended to backtest and validate any trading strategies before applying them in real-time trading.

data/lib/sqa/indicator/ema_analysis.rb

@@ -0,0 +1,70 @@
+# lib/sqa/indicator/ema_analysis.rb
+
+module SQA::Indicator; class << self
+
+  def ema_analysis(
+        prices, # Array of prices
+        period  # Integer number of entries to consider
+      )
+    return {} if prices.empty? || period <= 0
+
+    ema_values = []
+    ema_values << prices.first
+
+    multiplier = (2.0 / (period + 1))
+
+    (1...prices.length).each do |i|
+      ema = (prices[i] - ema_values.last) * multiplier + ema_values.last
+      ema_values << ema.round(2)
+    end
+
+    analysis = {}
+
+    analysis[:ema_values] = ema_values
+    analysis[:trend]      = ema_determine_trend(ema_values)
+    analysis[:support]    = ema_determine_support(ema_values)
+    analysis[:resistance] = ema_determine_resistance(ema_values)
+
+    analysis
+  end
+
+
+  # @param ema_values [Array] An array of EMA values.
+  # @return [Symbol] The trend: :up, :down, or :sideways.
+  #
+  private def ema_determine_trend(ema_values)
+    return :sideways if ema_values.empty?
+
+    last_ema      = ema_values.last
+    previous_ema  = ema_values[-2]
+
+    if last_ema > previous_ema
+      :up
+    elsif last_ema < previous_ema
+      :down
+    else
+      :sideways
+    end
+  end
+
+
+  # @param ema_values [Array] An array of EMA values.
+  # @return [Float] The support level.
+  #
+  private def ema_determine_support(ema_values)
+    return 0.0 if ema_values.empty?
+
+    ema_values.min
+  end
+
+
+  # @param ema_values [Array] An array of EMA values.
+  # @return [Float] The resistance level.
+  private def ema_determine_resistance(ema_values)
+    return 0.0 if ema_values.empty?
+
+    ema_values.max
+  end
+
+end; end
+

data/lib/sqa/indicator/fibonacci_retracement.md

@@ -0,0 +1,3 @@
+# Fibonacci Retracement
+
+Fibonacci retracement uses Fibonacci ratios to identify potential support and resistance levels based on the price's previous significant moves.

data/lib/sqa/indicator/fibonacci_retracement.rb

@@ -0,0 +1,25 @@
+# lib/sqa/indicator/fibonacci_retracement.rb
+
+module SQA::Indicator; class << self
+
+  def fibonacci_retracement(
+        start_price,  # Float starting price of the range
+        end_price     # Float ending price of the range
+      )
+    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
+    end
+
+    retracement_levels # Array
+  end
+  alias_method :fr, :fibonacci_retracement
+
+end; end
+

data/lib/sqa/indicator/head_and_shoulders_pattern.md

@@ -0,0 +1,3 @@
+# Head and Shoulders Pattern
+
+Checks if a "head and shoulders" pattern is present in the given price data.

data/lib/sqa/indicator/head_and_shoulders_pattern.rb

@@ -0,0 +1,26 @@
+# lib/sqa/indicator/head_and_shoulders_pattern.rb
+
+module SQA::Indicator; class << self
+
+
+  def head_and_shoulders_pattern?(
+        prices  # Array of prices
+      )
+
+    return false if prices.length < 5
+
+    data            = prices.last(5)
+
+    left_shoulder   = data[0]
+    head            = data[1]
+    right_shoulder  = data[2]
+    neckline        = data[3]
+    right_peak      = data[4]
+
+    head        > left_shoulder   &&
+    head        > right_shoulder  &&
+    right_peak  < neckline
+  end
+
+end; end
+

data/lib/sqa/indicator/identify_wave_condition.md

@@ -0,0 +1,6 @@
+# Wave Theory
+
+Wave theory, such as Elliott Wave Theory, suggests that price movements follow repetitive patterns or waves. It aims to identify and predict these patterns to make trading decisions.
+
+Identifies a wave condition in a stock's price history based on a given price series.
+

data/lib/sqa/indicator/identify_wave_condition.rb

@@ -0,0 +1,40 @@
+# lib/sqa/indicator/identify_wave_condition.rb
+
+module SQA::Indicator; class << self
+
+  def identify_wave_condition?(
+        prices,       # Array of prices
+        wave_length,  # Integer expected length of a wave pattern
+        tolerance     # Float delta change in price that would indicate a wave
+      )
+    return false if prices.length < wave_length
+
+    wave_start  = 0
+    wave_end    = wave_length - 1
+
+    while wave_end < prices.length
+      wave = prices[wave_start..wave_end]
+
+      if  wave.length == wave_length    &&
+          wave_pattern?(wave, tolerance)
+        return true
+      end
+
+      wave_start  += 1
+      wave_end    += 1
+    end
+
+    false
+  end
+
+
+  private def wave_pattern?(wave, tolerance)
+    wave.each_cons(2) do |a, b|
+      return false if (b - a).abs > tolerance
+    end
+
+    true
+  end
+
+end; end
+

data/lib/sqa/indicator/mean_reversion.md

@@ -0,0 +1,8 @@
+# Mean Reversion
+
+Determines if a stock exhibits mean reversion behavior based on a given price series.
+
+Mean Reversion Strategies: Mean reversion strategies aim to capitalize on the tendency of prices to revert to their mean or average value. These strategies involve identifying overextended price movements and taking positions that anticipate a return to the mean.
+
+
+

data/lib/sqa/indicator/mean_reversion.rb

@@ -0,0 +1,37 @@
+# lib/sqa/indicator/mean_reversion.rb
+
+module SQA::Indicator; class << self
+
+  # @param prices [Array]
+  # @param lookback_period [Integer]
+  # @param deviation_threshold [Float]
+  #
+  # @return [Boolean] True if the stock exhibits mean reversion behavior,
+  #                   false otherwise.
+  #
+  def mean_reversion?(
+        prices,             # Array of prices
+        lookback_period,    # Integer number of events to consider
+        deviation_threshold # Float delta change at which a price is considered to be over extended
+      )
+
+    return false if prices.length < lookback_period
+
+    mean      = mr_mean(prices, lookback_period)
+    deviation = prices[-1] - mean
+
+    if deviation.abs > deviation_threshold
+      return true
+    else
+      return false
+    end
+  end
+
+
+  def mr_mean(prices, lookback_period)
+    prices.last(lookback_period).sum / lookback_period.to_f
+  end
+
+end; end
+
+

data/lib/sqa/indicator/momentum.md

@@ -0,0 +1,19 @@
+# Momentum
+
+Calculates the momentum of a stock based on the rate of change (ROC).
+
+The interpretation of a stock's momentum value in terms of forecasting future price depends on the specific trading strategy or approach being used. However, in general, a positive momentum value indicates that the stock's price has been increasing over the specified period, while a negative momentum value indicates that the stock's price has been decreasing.
+
+Here are some common interpretations of momentum values:
+
+1. Positive Momentum: A positive momentum value suggests that the stock's price has been trending upwards. This could indicate that the stock is in an uptrend and may continue to rise in the near future. Traders and investors may interpret this as a bullish signal and consider buying or holding the stock.
+
+2. Negative Momentum: A negative momentum value suggests that the stock's price has been trending downwards. This could indicate that the stock is in a downtrend and may continue to decline in the near future. Traders and investors may interpret this as a bearish signal and consider selling or avoiding the stock.
+
+3. High Momentum: A high positive momentum value indicates a strong upward trend in the stock's price. This could suggest that the stock has significant buying pressure and may continue to rise. Traders and investors may interpret this as a strong bullish signal and consider entering or adding to their positions.
+
+4. Low Momentum: A low positive momentum value suggests a weak upward trend or a sideways movement in the stock's price. This could indicate a lack of significant buying pressure. Traders and investors may interpret this as a neutral signal and may choose to wait for a stronger momentum signal or look for other indicators to make trading decisions.
+
+It's important to note that momentum alone may not be sufficient for accurate price forecasting. It is often used in conjunction with other technical indicators, fundamental analysis, or market conditions to make more informed trading decisions.
+
+Additionally, the interpretation of momentum values may vary depending on the time frame and the specific trading strategy being employed. Traders and investors should consider their own risk tolerance, investment goals, and trading approach when interpreting momentum values for forecasting future price movements.

data/lib/sqa/indicator/momentum.rb

@@ -0,0 +1,26 @@
+# lib/sqa/indicator/momentum.rb
+
+module SQA::Indicator; class << self
+
+  # @param prices [Array]
+  # @param period [Integer]
+  #
+  # @return [Float]
+  #
+  def momentum(
+        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
+
+    momentum  # Float expressed as a percentage change
+  end
+  alias_method :m, :momentum
+
+end; end
+

data/lib/sqa/indicator/moving_average_convergence_divergence.md

@@ -0,0 +1,23 @@
+# Moving Average Convergence Divergence (MACD)
+
+The MACD is a trend-following momentum indicator that measures the relationship between two moving averages over a specified time period. The MACD is calculated by subtracting the long-term moving average from the short-term moving average.
+
+The method takes in an array of historical prices for a stock, a short period (the number of days to calculate the short-term moving average over), a long period (the number of days to calculate the long-term moving average over), and a signal period (the number of days to calculate the signal line moving average over).
+
+The method first calculates the short-term moving average by calling the `moving_averages` method with the `prices` array and the `short_period` parameter. It then calculates the long-term moving average by calling the `moving_averages` method with the `prices` array and the `long_period` parameter.
+
+Next, the method calculates the MACD line by subtracting the long-term moving average from the short-term moving average. This is done by taking the last element of the `short_ma` array (which contains the short-term moving averages for each window) and subtracting the last element of the `long_ma` array (which contains the long-term moving averages for each window).
+
+Finally, the method calculates the signal line by taking the moving average of the MACD line over the specified `signal_period`. This is done by calling the `moving_averages` method with the `short_ma` array and the `signal_period` parameter, and taking the last element of the resulting array.
+
+The method returns an array containing the MACD line and the signal line.
+
+Note that this is just a basic implementation of the MACD indicator, and there are many variations and refinements that can be made depending on the specific requirements of your program.
+
+The Moving Average Convergence Divergence (MACD) is a technical analysis indicator that is used to identify changes in momentum, direction, and trend for a security. The MACD is calculated by subtracting the 26-period exponential moving average (EMA) from the 12-period EMA.
+
+The values 1.8231937142857078 and 164.44427957142855 that you provided are likely the MACD line and the signal line, respectively. The MACD line is the difference between the 12-period EMA and the 26-period EMA, while the signal line is a 9-period EMA of the MACD line.
+
+The MACD line crossing above the signal line is often considered a bullish signal, while the MACD line crossing below the signal line is often considered a bearish signal. The distance between the MACD line and the signal line can also provide insight into the strength of the trend.
+
+Without additional context, it's difficult to interpret the specific values of 1.8231937142857078 and 164.44427957142855 for the MACD and signal lines of a stock. However, in general, the MACD can be used to identify potential buy and sell signals for a security, as well as to provide insight into the strength of the trend.