"Модифицированное скользящее среднее" это частный случай “экспоненциального скользящего среднего”. Для которого сглаживающая константа равна a=1/n

Где n-длина интервала

function RSI() --Relative Strength I("RSI") 
    local Up = {} 
    local Down = {} 
    local val_Up = {} 
    local val_Down = {} 
return function (I, Fsettings, ds) 
local Out = nil 
local Fsettings=(Fsettings or {}) 
local P = (Fsettings.Period or 14) 
local VT = (Fsettings.VType or "Close") 
local R = (Fsettings.round or "off") 
if I == 1 then 
    Up[I] = 0 
    Down[I] = 0 
end 
if I>1 then 
    local Val = Value(I,VT,ds) 
    local ValPrev = Value(I-1,VT,ds) 
    if ValPrev < Val then 
        Up[I] = Val - ValPrev 
    else 
        Up[I] = 0 
    end 
    if ValPrev > Val then 
        Down[I] = ValPrev - Val 
    else 
        Down[I] = 0 
    end 
    if (I == P) or (I == P+1) then 
        local sumU = 0 
        local sumD = 0 
        for i = I-P+1, I do 
            sumU = sumU + Up[i] 
            sumD = sumD + Down[i] 
        end 
        val_Up[I] = sumU/P 
        val_Down[I] = sumD/P 
    end 
    if I > P+1 then 
        val_Up[I] = (val_Up[I-1] * (P-1) + Up[I]) / P 
        val_Down[I] = (val_Down[I-1] * (P-1) + Down[I]) / P 
    end 
    if I >= P then 
        Out = 100 / (1 + (val_Down[I] / val_Up[I])) 
        return rounding(Out, R) 
    end 
end 
end 
end

@Override
protected void compute() {

   if (this.history.size() == this.indicatorHistory.size()) {
      return; // we are in sync
   }

   if (this.isFirstRun()) {

      this.indicatorHistory.add(null);
      double gain = 0, loss = 0;

      for (int i = 1; i < this.history.size(); i++) { // skip i = 0 as we can't get delta

         double delta = this.getDelta(i);
         UpDown upDown =  new UpDown(Math.max(delta, 0), Math.max(-delta, 0));

         if (gain == 0) { // Seed our ema
            gain = upDown.getGain();
            loss = upDown.getLoss();
         } else {
            gain = this.alpha * upDown.getGain() + (1 - this.alpha) * gain;
            loss = this.alpha * upDown.getLoss() + (1 - this.alpha) * loss;
         }

         if (i < this.length) { // this data is too inaccurate
            this.indicatorHistory.add(null);
            continue;
         }

         double RS = (loss == 0) ? 0 : gain / loss;
         this.indicatorHistory.add(this.computeInternal(i, RS));
      }
   } else {

   }
}

protected double getDelta(int i) {
   assert i > 0;
   return this.history.get(i).getClose() - this.history.get(i - 1).getClose();
}

protected IndicatorValue<Double> computeInternal(int i, double RS) {
   return new IndicatorValue<>(this.history.get(i).getTimestamp(), 100 - 100 / (1 + RS));
}