@@ -26,9 +26,9 @@ type FunctionArgs struct {
2626 Offset int64
2727 MetricAppearedTs * int64
2828
29- // Only holt-winters uses two arguments, we fall back for that.
3029 // quantile_over_time and predict_linear use one, so we only use one here.
31- ScalarPoint float64
30+ ScalarPoint float64
31+ ScalarPoint2 float64 // only for double_exponential_smoothing (trend factor)
3232}
3333
3434type FunctionCall func (f FunctionArgs ) (* float64 , * histogram.FloatHistogram , bool , error )
@@ -299,6 +299,33 @@ var rangeVectorFuncs = map[string]FunctionCall{
299299 v := predictLinear (f .Samples , f .ScalarPoint , f .StepTime )
300300 return & v , nil , true , nil
301301 },
302+ "double_exponential_smoothing" : func (f FunctionArgs ) (* float64 , * histogram.FloatHistogram , bool , error ) {
303+ if len (f .Samples ) < 2 {
304+ if len (f .Samples ) == 1 && f .Samples [0 ].V .H != nil {
305+ warnings .AddToContext (annotations .MixedFloatsHistogramsWarning , f .ctx )
306+ return nil , nil , false , nil
307+ }
308+ return nil , nil , false , nil
309+ }
310+
311+ // Annotate mix of float and histogram.
312+ for _ , s := range f .Samples {
313+ if s .V .H != nil {
314+ warnings .AddToContext (annotations .MixedFloatsHistogramsWarning , f .ctx )
315+ return nil , nil , false , nil
316+ }
317+ }
318+
319+ sf := f .ScalarPoint // smoothing factor or alpha
320+ tf := f .ScalarPoint2 // trend factor argument or beta
321+
322+ v , ok := doubleExponentialSmoothing (f .Samples , sf , tf )
323+ if ! ok {
324+ return nil , nil , false , nil
325+ }
326+
327+ return & v , nil , true , nil
328+ },
302329}
303330
304331func NewRangeVectorFunc (name string ) (FunctionCall , error ) {
@@ -735,6 +762,65 @@ func predictLinear(points []Sample, duration float64, stepTime int64) float64 {
735762 return slope * duration + intercept
736763}
737764
765+ // Based on https://github.com/prometheus/prometheus/blob/8baad1a73e471bd3cf3175a1608199e27484f179/promql/functions.go#L438
766+ // doubleExponentialSmoothing calculates the smoothed out value for the given series.
767+ // It is similar to a weighted moving average, where historical data has exponentially less influence on the current data.
768+ // It also accounts for trends in data. The smoothing factor (0 < sf < 1), aka "alpha", affects how historical data will affect the current data.
769+ // A lower smoothing factor increases the influence of historical data.
770+ // The trend factor (0 < tf < 1), aka "beta", affects how trends in historical data will affect the current data.
771+ // A higher trend factor increases the influence of trends.
772+ // Algorithm taken from https://en.wikipedia.org/wiki/Exponential_smoothing
773+ func doubleExponentialSmoothing (points []Sample , sf , tf float64 ) (float64 , bool ) {
774+ // Check that the input parameters are valid
775+ if sf <= 0 || sf >= 1 || tf <= 0 || tf >= 1 {
776+ return 0 , false
777+ }
778+
779+ // Can't do the smoothing operation with less than two points
780+ if len (points ) < 2 {
781+ return 0 , false
782+ }
783+
784+ // Check for histograms in the samples
785+ for _ , s := range points {
786+ if s .V .H != nil {
787+ return 0 , false
788+ }
789+ }
790+
791+ var s0 , s1 , b float64
792+ // Set initial values
793+ s1 = points [0 ].V .F
794+ b = points [1 ].V .F - points [0 ].V .F
795+
796+ // Run the smoothing operation
797+ for i := 1 ; i < len (points ); i ++ {
798+ // Scale the raw value against the smoothing factor
799+ x := sf * points [i ].V .F
800+ // Scale the last smoothed value with the trend at this point
801+ b = calcTrendValue (i - 1 , tf , s0 , s1 , b )
802+ y := (1 - sf ) * (s1 + b )
803+ s0 , s1 = s1 , x + y
804+ }
805+
806+ return s1 , true
807+ }
808+
809+ // calcTrendValue calculates the trend value at the given index i.
810+ // This is somewhat analogous to the slope of the trend at the given index.
811+ // The argument "tf" is the trend factor.
812+ // The argument "s0" is the previous smoothed value.
813+ // The argument "s1" is the current smoothed value.
814+ // The argument "b" is the previous trend value.
815+ func calcTrendValue (i int , tf , s0 , s1 , b float64 ) float64 {
816+ if i == 0 {
817+ return b
818+ }
819+ x := tf * (s1 - s0 )
820+ y := (1 - tf ) * b
821+ return x + y
822+ }
823+
738824func resets (points []Sample ) float64 {
739825 var histogramPoints []Sample
740826 var floatPoints []Sample
0 commit comments