Discrepency of Chande Momemtum Indicator - QC CMO vs TA Lib vs TradingView plot charts

Response from support but I respectfully disagree that the calculation is the “same” as per the logic.
***************************************************************************************************************
Hi Lucas,
 

Here is TA-LIB implementation for the difference < 0 if-condition statement:
https://github.com/TA-Lib/ta-lib/blob/main/src/ta_func/ta_CMO.c#L287
https://github.com/TA-Lib/ta-lib/blob/main/src/ta_func/ta_CMO.c#L330

The calculation is the same.

QuantConnect/Lean validates its indicators with external data. Here is the file we use for CMO:
https://github.com/QuantConnect/Lean/blob/master/Tests/TestData/spy_cmo.txt

If you use this data (the close, 5th column) to calculate CMO with TA-LIB it should return the same results (the 7th column).

Best regards,
Alex
*********************************************************************************************************************************
QC CMO implementation:
/*
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

namespace QuantConnect.Indicators
{
   /// <summary>
   /// This indicator computes the Chande Momentum Oscillator (CMO).
   /// CMO calculation is mostly identical to RSI.
   /// The only difference is in the last step of calculation:
   /// RSI = gain / (gain+loss)
   /// CMO = (gain-loss) / (gain+loss)
   /// </summary>
   public class ChandeMomentumOscillator : WindowIndicator<IndicatorDataPoint>, IIndicatorWarmUpPeriodProvider
   {
       private decimal _prevValue;
       private decimal _prevGain;
       private decimal _prevLoss;

       /// <summary>
       /// Initializes a new instance of the <see cref="ChandeMomentumOscillator"/> class using the specified period.
       /// </summary> 
       /// <param name="period">The period of the indicator</param>
       public ChandeMomentumOscillator(int period)
           : this($"CMO({period})", period)
       {
       }

       /// <summary>
       /// Initializes a new instance of the <see cref="ChandeMomentumOscillator"/> class using the specified name and period.
       /// </summary> 
       /// <param name="name">The name of this indicator</param>
       /// <param name="period">The period of the indicator</param>
       public ChandeMomentumOscillator(string name, int period)
           : base(name, period)
       {
       }

       /// <summary>
       /// Gets a flag indicating when this indicator is ready and fully initialized
       /// </summary>
       public override bool IsReady => Samples > Period;

       /// <summary>
       /// Required period, in data points, for the indicator to be ready and fully initialized.
       /// </summary>
       public int WarmUpPeriod => 1 + Period;

       /// <summary>
       /// Computes the next value of this indicator from the given state
       /// </summary>
       /// <param name="input">The input given to the indicator</param>
       /// <param name="window">The window for the input history</param>
       /// <returns>A new value for this indicator</returns>
       protected override decimal ComputeNextValue(IReadOnlyWindow<IndicatorDataPoint> window, IndicatorDataPoint input)
       {
           if (Samples == 1)
           {
               _prevValue = input.Value;
               return 0m;
           }

           var difference = input.Value - _prevValue;

           _prevValue = input.Value;

           if (Samples > Period + 1)
           {
               _prevLoss *= (Period - 1);
               _prevGain *= (Period - 1);
           }

           if (difference < 0)
               _prevLoss -= difference;
           else
               _prevGain += difference;

           if (!IsReady)
               return 0m;

           _prevLoss /= Period;
           _prevGain /= Period;

           var sum = _prevGain + _prevLoss;
           return sum != 0 ? 100m * ((_prevGain - _prevLoss) / sum) : 0m;
       }

       /// <summary>
       /// Resets this indicator to its initial state
       /// </summary>
       public override void Reset()
       {
           _prevValue = 0;
           _prevGain = 0;
           _prevLoss = 0;
           base.Reset();
       }
   }
}

Thank you for the thoughtful comments. Can you share the TV pine script and asset you were testing with, and we can see if we can repeat the difference you see? 

Ran into same issue and ended up using GPT to port TV's Pinescript version to a QC LEAN custom indicator (Python). The custom one has a similar profile to TV's, but not a perfect match, given the way TV handles data.

Sharing the code below in case it helps others.

Also, Jared Broad  : I generated a ChatGPT thread advising on how we might update the LEAN logic to match TV's
(assuming we want to do that). Here's the link.  TLDR: we should consider implementing separate
accumulators for positive and negative changes within the period instead of adjusting _preGain and _prevLoss over
time.

Python Version

//@version=5
indicator(title="Chande Momentum Oscillator", shorttitle="ChandeMO", format=format.price, precision=2, timeframe="", timeframe_gaps=true)
length = input.int(9, minval=1)
src = input(close, "Source")
momm = ta.change(src)
f1(m) => m >= 0.0 ? m : 0.0
f2(m) => m >= 0.0 ? 0.0 : -m
m1 = f1(momm)
m2 = f2(momm)
sm1 = math.sum(m1, length)
sm2 = math.sum(m2, length)
percent(nom, div) => 100 * nom / div
chandeMO = percent(sm1-sm2, sm1+sm2)
plot(chandeMO, "Chande MO", color=#2962FF)
hline(0, color=#787B86, linestyle=hline.style_dashed, title="Zero Line")

Custom QC Version

from collections import deque
from AlgorithmImports import *

class CustomChandeMomentumOscillator(PythonIndicator):
    def __init__(self, name, period):
        super().__init__()
        self.Name = name
        self.Value = 0
        self.period = period
        self.positive_changes = deque(maxlen=period)
        self.negative_changes = deque(maxlen=period)
    
    def Update(self, input):
        if not isinstance(input, TradeBar):
            raise TypeError('CustomChandeMomentumOscillator.Update: input must be a TradeBar')
        
        # Calculate the momentum as the difference from the previous close
        if self.IsReady:
            momm = input.Close - self.previous_close
        else:
            momm = 0  # No momentum for the first data point
        
        self.positive_changes.appendleft(max(momm, 0))
        self.negative_changes.appendleft(max(-momm, 0))
        
        self.previous_close = input.Close
        
        if self.IsReady:
            sum_positive = sum(self.positive_changes)
            sum_negative = sum(self.negative_changes)
            
            # Avoid division by zero
            if sum_positive + sum_negative > 0:
                self.Value = 100 * (sum_positive - sum_negative) / (sum_positive + sum_negative)
            else:
                self.Value = 0
                
        return self.IsReady

    @property
    def IsReady(self):
        return len(self.positive_changes) == self.period and len(self.negative_changes) == self.period

Visual Comparison

imgur[dot]com/

(Cant attach image, and pasting the link seems to break the post)