ecco:

//--------------------------------------------------------------------
// CONFIGURACIÓN DE USUARIO
//--------------------------------------------------------------------
// Periodo para el cálculo del ATR diario. Por defecto: 20
atrPeriod = 20
// Tipo de salida: 1 = Media (Mean), 2 = Mediana (Median). Por defecto: 2
outputType = 2
// Rango de fechas para el análisis (Formato: YYYYMMDD)
startDate = 19750101
endDate = 20501231
// Colores para el gradiente de volatilidad
// Color para baja volatilidad (R, G, B)
lowVolatilityR = 0
lowVolatilityG = 0
lowVolatilityB = 255 // Azul
// Color para alta volatilidad (R, G, B)
highVolatilityR = 255
highVolatilityG = 0
highVolatilityB = 0 // Rojo
// Parámetros de estilo de las columnas
COLUMNWIDTH = 2
COLUMNGAP = 2
//--------------------------------------------------------------------
// INICIALIZACIÓN DE VARIABLES
//--------------------------------------------------------------------
// Contadores para cada array de datos por hora
// Variables para seguimiento de la vela horaria
ONCE hourlyHigh = 0
ONCE hourlyLow = 0
ONCE hourlyPrevClose = 0
//--------------------------------------------------------------------
// LÓGICA PRINCIPAL
//--------------------------------------------------------------------
// Obtener ATR Diario
TIMEFRAME(daily, updateonclose)
dailyAtr = averagetruerange[atrPeriod](close)
TIMEFRAME(default)
// Comprobar si la vela actual está dentro del rango de fechas
isInRange = (Date >= startDate AND Date <= endDate)
// Detectar si es la primera vela de una nueva hora
isFirstBarOfHour = (Hour <> Hour[1])
// Procesar datos de la hora anterior cuando empieza una nueva
IF isFirstBarOfHour AND BarIndex > 0 THEN
   // Calcular el True Range de la hora que acaba de terminar
   hTR = max(hourlyHigh[1] - hourlyLow[1], MAX(abs(hourlyHigh[1] -hourlyPrevClose[1]), abs(hourlyLow[1] - hourlyPrevClose[1])))
   // Calcular volatilidad relativa y almacenar si está en rango
   IF dailyAtr[1] > 0 THEN
      relativeToAtr = hTR / dailyAtr[1] * 100
      IF isInRange[1] THEN
         completedHour = Hour[1]  // Almacenar el valor en el array correspondiente a la hora completada
         IF completedHour = 0 THEN
            $dataset0[count0] = relativeToAtr
            count0 = count0 + 1
         ELSIF completedHour = 1 THEN
            $dataset1[count1] = relativeToAtr
            count1 = count1 + 1
         ELSIF completedHour = 2 THEN
            $dataset2[count2] = relativeToAtr
            count2 = count2 + 1
         ELSIF completedHour = 3 THEN
            $dataset3[count3] = relativeToAtr
            count3 = count3 + 1
         ELSIF completedHour = 4 THEN
            $dataset4[count4] = relativeToAtr
            count4 = count4 + 1
         ELSIF completedHour = 5 THEN
            $dataset5[count5] = relativeToAtr
            count5 = count5 + 1
         ELSIF completedHour = 6 THEN
            $dataset6[count6] = relativeToAtr
            count6 = count6 + 1
         ELSIF completedHour = 7 THEN
            $dataset7[count7] = relativeToAtr
            count7 = count7 + 1
         ELSIF completedHour = 8 THEN
            $dataset8[count8] = relativeToAtr
            count8 = count8 + 1
         ELSIF completedHour = 9 THEN
            $dataset9[count9] = relativeToAtr
            count9 = count9 + 1
         ELSIF completedHour = 10 THEN
            $dataset10[count10] = relativeToAtr
            count10 = count10 + 1
         ELSIF completedHour = 11 THEN
            $dataset11[count11] = relativeToAtr
            count11 = count11 + 1
         ELSIF completedHour = 12 THEN
            $dataset12[count12] = relativeToAtr
            count12 = count12 + 1
         ELSIF completedHour = 13 THEN
            $dataset13[count13] = relativeToAtr
            count13 = count13 + 1
         ELSIF completedHour = 14 THEN
            $dataset14[count14] = relativeToAtr
            count14 = count14 + 1
         ELSIF completedHour = 15 THEN
            $dataset15[count15] = relativeToAtr
            count15 = count15 + 1
         ELSIF completedHour = 16 THEN
            $dataset16[count16] = relativeToAtr
            count16 = count16 + 1
         ELSIF completedHour = 17 THEN
            $dataset17[count17] = relativeToAtr
            count17 = count17 + 1
         ELSIF completedHour = 18 THEN
            $dataset18[count18] = relativeToAtr
            count18 = count18 + 1
         ELSIF completedHour = 19 THEN
            $dataset19[count19] = relativeToAtr
            count19 = count19 + 1
         ELSIF completedHour = 20 THEN
            $dataset20[count20] = relativeToAtr
            count20 = count20 + 1
         ELSIF completedHour = 21 THEN
            $dataset21[count21] = relativeToAtr
            count21 = count21 + 1
         ELSIF completedHour = 22 THEN
            $dataset22[count22] = relativeToAtr
            count22 = count22 + 1
         ELSIF completedHour = 23 THEN
            $dataset23[count23] = relativeToAtr
            count23 = count23 + 1
         ENDIF
      ENDIF
   ENDIF
ENDIF
// Actualizar los valores de la hora en curso
IF isFirstBarOfHour THEN
   hourlyHigh = high
   hourlyLow = low
   hourlyPrevClose = close[1]
ELSE
   hourlyHigh = max(hourlyHigh, high)
   hourlyLow = min(hourlyLow, low)
ENDIF

//--------------------------------------------------------------------
// CÁLCULO FINAL Y DIBUJO (SOLO EN LA ÚLTIMA VELA)
//--------------------------------------------------------------------
IF islastbarupdate THEN
   // Array para los 24 resultados finales
   UnSet($resultArray)
   // Bucle manual para las 24 horas
   // --- HORA 0 ---
   IF count0 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count0 - 1 DO
            sum = sum + $dataset0[i]
         NEXT
         $resultArray[0] = sum / count0
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count0 - 1 DO
            $temp[i] = $dataset0[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[0] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 1 ---
   IF count1 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count1 - 1 DO
            sum = sum + $dataset1[i]
         NEXT
         $resultArray[1] = sum / count1
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count1 - 1 DO
            $temp[i] = $dataset1[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[1] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 2 ---
   IF count2 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count2 - 1 DO
            sum = sum + $dataset2[i]
         NEXT
         $resultArray[2] = sum / count2
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count2 - 1 DO
            $temp[i] = $dataset2[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[2] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 3 ---
   IF count3 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count3 - 1 DO
            sum = sum + $dataset3[i]
         NEXT
         $resultArray[3] = sum / count3
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count3 - 1 DO
            $temp[i] = $dataset3[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[3] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 4 ---
   IF count4 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count4 - 1 DO
            sum = sum + $dataset4[i]
         NEXT
         $resultArray[4] = sum / count4
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count4 - 1 DO
            $temp[i] = $dataset4[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[4] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 5 ---
   IF count5 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count5 - 1 DO
            sum = sum + $dataset5[i]
         NEXT
         $resultArray[5] = sum / count5
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count5 - 1 DO
            $temp[i] = $dataset5[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[5] = median
         ENDIF
      ENDIF
   ENDIF
   // --- HORA 23 ---
   IF count23 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count23 - 1 DO
            sum = sum + $dataset23[i]
         NEXT
         $resultArray[23] = sum / count23
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count23 - 1 DO
            $temp[i] = $dataset23[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[23] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 6 ---
   IF count6 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count6 - 1 DO
            sum = sum + $dataset6[i]
         NEXT
         $resultArray[6] = sum / count6
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count6 - 1 DO
            $temp[i] = $dataset6[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[6] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 7 ---
   IF count7 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count7 - 1 DO
            sum = sum + $dataset7[i]
         NEXT
         $resultArray[7] = sum / count7
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count7 - 1 DO
            $temp[i] = $dataset7[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[7] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 8 ---
   IF count8 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count8 - 1 DO
            sum = sum + $dataset8[i]
         NEXT
         $resultArray[8] = sum / count8
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count8 - 1 DO
            $temp[i] = $dataset8[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[8] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 9 ---
   IF count9 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count9 - 1 DO
            sum = sum + $dataset9[i]
         NEXT
         $resultArray[9] = sum / count9
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count9 - 1 DO
            $temp[i] = $dataset9[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[9] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 10 ---
   IF count10 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count10 - 1 DO
            sum = sum + $dataset10[i]
         NEXT
         $resultArray[10] = sum / count10
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count10 - 1 DO
            $temp[i] = $dataset10[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[10] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 11 ---
   IF count11 > 0 THEN
      IF outputType = 1 THEN // Media
         sum = 0
         FOR i = 0 TO count11 - 1 DO
            sum = sum + $dataset11[i]
         NEXT
         $resultArray[11] = sum / count11
      ELSE // Mediana
         UnSet($temp)
         FOR i = 0 TO count11 - 1 DO
            $temp[i] = $dataset11[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[11] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 12 ---
   IF count12 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count12 - 1 DO
            sum = sum + $dataset12[i]
         NEXT
         $resultArray[12] = sum / count12
      ELSE
         UnSet($temp)
         FOR i = 0 TO count12 - 1 DO
            $temp[i] = $dataset12[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[12] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 13 ---
   IF count13 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count13 - 1 DO
            sum = sum + $dataset13[i]
         NEXT
         $resultArray[13] = sum / count13
      ELSE
         UnSet($temp)
         FOR i = 0 TO count13 - 1 DO
            $temp[i] = $dataset13[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[13] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 14 ---
   IF count14 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count14 - 1 DO
            sum = sum + $dataset14[i]
         NEXT
         $resultArray[14] = sum / count14
      ELSE
         UnSet($temp)
         FOR i = 0 TO count14 - 1 DO
            $temp[i] = $dataset14[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[14] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 15 ---
   IF count15 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count15 - 1 DO
            sum = sum + $dataset15[i]
         NEXT
         $resultArray[15] = sum / count15
      ELSE
         UnSet($temp)
         FOR i = 0 TO count15 - 1 DO
            $temp[i] = $dataset15[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[15] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 16 ---
   IF count16 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count16 - 1 DO
            sum = sum + $dataset16[i]
         NEXT
         $resultArray[16] = sum / count16
      ELSE
         UnSet($temp)
         FOR i = 0 TO count16 - 1 DO
            $temp[i] = $dataset16[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[16] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 17 ---
   IF count17 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count17 - 1 DO
            sum = sum + $dataset17[i]
         NEXT
         $resultArray[17] = sum / count17
      ELSE
         UnSet($temp)
         FOR i = 0 TO count17 - 1 DO
            $temp[i] = $dataset17[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[17] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 18 ---
   IF count18 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count18 - 1 DO
            sum = sum + $dataset18[i]
         NEXT
         $resultArray[18] = sum / count18
      ELSE
         UnSet($temp)
         FOR i = 0 TO count18 - 1 DO
            $temp[i] = $dataset18[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[18] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 19 ---
   IF count19 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count19 - 1 DO
            sum = sum + $dataset19[i]
         NEXT
         $resultArray[19] = sum / count19
      ELSE
         UnSet($temp)
         FOR i = 0 TO count19 - 1 DO
            $temp[i] = $dataset19[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[19] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 20 ---
   IF count20 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count20 - 1 DO
            sum = sum + $dataset20[i]
         NEXT
         $resultArray[20] = sum / count20
      ELSE
         UnSet($temp)
         FOR i = 0 TO count20 - 1 DO
            $temp[i] = $dataset20[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[20] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 21 ---
   IF count21 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count21 - 1 DO
            sum = sum + $dataset21[i]
         NEXT
         $resultArray[21] = sum / count21
      ELSE
         UnSet($temp)
         FOR i = 0 TO count21 - 1 DO
            $temp[i] = $dataset21[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[21] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 22 ---
   IF count22 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count22 - 1 DO
            sum = sum + $dataset22[i]
         NEXT
         $resultArray[22] = sum / count22
      ELSE
         UnSet($temp)
         FOR i = 0 TO count22 - 1 DO
            $temp[i] = $dataset22[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[22] = median
         ENDIF
      ENDIF
   ENDIF
   
   // --- HORA 23 ---
   IF count23 > 0 THEN
      IF outputType = 1 THEN
         sum = 0
         FOR i = 0 TO count23 - 1 DO
            sum = sum + $dataset23[i]
         NEXT
         $resultArray[23] = sum / count23
      ELSE
         UnSet($temp)
         FOR i = 0 TO count23 - 1 DO
            $temp[i] = $dataset23[i]
         NEXT
         ArraySort($temp, ASCEND)
         sortedSize = LastSet($temp) + 1
         IF sortedSize > 0 THEN
            IF (sortedSize MOD 2) = 1 THEN
               median = $temp[(sortedSize - 1) / 2]
            ELSE
               median = ($temp[sortedSize / 2 - 1] + $temp[sortedSize / 2]) / 2
            ENDIF
            $resultArray[23] = median
         ENDIF
      ENDIF
   ENDIF
   //--------------------------------------------------------------------
   // --- DIBUJO DE LAS COLUMNAS ---
   //--------------------------------------------------------------------
   resultMin = ArrayMin($resultArray)
   resultMax = ArrayMax($resultArray)
   irange = resultMax - resultMin
   gridMultiplier = COLUMNWIDTH + COLUMNGAP
   
   FOR i = 0 TO 23 DO
      hasValue = IsSet($resultArray[i])
      
      IF hasValue THEN
         y = round($resultArray[i],0)
      ELSE
         y = 0
      ENDIF
      
      x1 = barindex + (i - 23) * gridMultiplier
      x2 = x1 + COLUMNWIDTH
      center = x1 + COLUMNWIDTH / 2
      
      // Cálculo del gradiente de color
      IF irange > 0 THEN
         percentage = (y - resultMin) / irange
      ELSE
         percentage = 0.5
      ENDIF
      
      cR = round(lowVolatilityR + percentage * (highVolatilityR - lowVolatilityR))
      cG = round(lowVolatilityG + percentage * (highVolatilityG - lowVolatilityG))
      cB = round(lowVolatilityB + percentage * (highVolatilityB - lowVolatilityB))
      
      // Dibujar columna
      DRAWRECTANGLE(x1, 0, x2, y) COLOURED(cR, cG, cB) BORDERCOLOR(cR, cG, cB)
      
      // Dibujar leyenda (hora)
      DRAWTEXT(i, center, -1) ANCHOR(TOP, INDEX, VALUE) COLOURED("gray")
      
      // Dibujar valor
      IF hasValue THEN
         DRAWTEXT(y, center, y*1.1) ANCHOR(BOTTOM, INDEX, VALUE) COLOURED(cR, cG, cB)
      ENDIF
   NEXT
   
ENDIF

RETURN -2 coloured("black",0), ArrayMax($resultArray)*1.25