Ocena opóźnia to strategia ewaluacji, która opóźnia wartościowanie wyrażenia do czasu, aż jego wartość będzie potrzebna. W połączeniu z memoization, strategia leniwej oceny pozwala uniknąć powtarzających się ocen i może skrócić czas działania niektórych funkcji przez znaczący czynnik.

Biblioteka szeregów czasowych wykorzystuje leniwą ocenę do przetwarzania danych. Wykres wykonawczy jest konstruowany na podstawie danych szeregów czasowych, których wartościowanie jest wyzwalane tylko wtedy, gdy jego dane wyjściowe zostaną zmaterializowane. Zakładając, że obiekt przemieszcza się w jednej przestrzeni wymiarowej, której położenie jest przechwytywane przez x (t). Można określić harsh przyspieszenie/hamowanie (h(t)) tego obiektu, używając jego serii prędkości (v(t)) i przyspieszenia (a(t)) w następujący sposób:

# 1d location timeseries
x(t) = input location timeseries

# velocity - first derivative of x(t)
v(t) = x(t) - x(t-1)

# acceleration - second derivative of x(t)
a(t) = v(t) - v(t-1)

# harsh acceleration/braking using thresholds on acceleration
h(t) = +1 if a(t) > threshold_acceleration
     = -1 if a(t) < threshold_deceleration
     = 0 otherwise

Wynikiem tego jest prosty wykres wykonania formularza:

x(t) --> v(t) --> a(t) --> h(t)

Oceny są wyzwalane tylko wtedy, gdy wykonywane jest działanie, takie jak compute h(5...10), tj. compute h(5), ..., h(10). Biblioteka przechwytuje wąskie zależności czasowe między szeregami czasowymi. W tym przykładzie program h(5...10) wymaga a(5...10), który z kolei wymaga v(4...10), co wymaga x(3...10). Wartościowane są tylko odpowiednie części produktów a(t), v(t) i x(t) .

h(5...10) <-- a(5...10) <-- v(4...10) <-- x(3...10)

Ponadto oceny są zapamiętywać i mogą być ponownie wykorzystywane w kolejnych działaniach na serwerze h. Na przykład, jeśli żądanie dla h(7...12) jest zgodne z żądaniem h(5...10), wartości zapamiętanych wartości h(7...10) zostaną wydzierżawione, dalej h(11...12) będzie wartościowane za pomocą a(11...12), v(10...12) i x(9...12), co z kolei będzie wykorzystywać v(10) i x(9...10) zapamiętywać przed obliczy.

W bardziej ogólnym przykładzie można zdefiniować następujące terminale prędkości wygładzonej:

# 1d location timeseries
x(t) = input location timeseries

# velocity - first derivative of x(t)
v(t) = x(t) - x(t-1)

# smoothened velocity
# alpha is the smoothing factor
# n is a smoothing history
v_smooth(t) =  (v(t)*1.0 + v(t-1)*alpha + ... + v(t-n)*alpha^n) / (1 + alpha + ... + alpha^n)

# acceleration - second derivative of x(t)
a(t) = v_smooth(t) - v_smooth(t-1)

W tym przykładzie h(l...u) ma następującą zależność czasową. Wartościowanie produktu h(l...u) byłoby ściśle zgodne z tą zależnością czasową z memoizacją.

h(l...u) <-- a(l...u) <-- v_smooth(l-1...u) <-- v(l-n-1...u) <-- x(l-n-2...u)

import tspy
from tspy.builders.functions import transformers

x = tspy.time_series([1.0, 2.0, 4.0, 7.0, 11.0, 16.0, 22.0, 29.0, 28.0, 30.0, 29.0, 30.0, 30.0])
v = x.transform(transformers.difference())
a = v.transform(transformers.difference())
h = a.map(harsh).filter(lambda h: h != 0)

print(h[5, 10])

def harsh(a):
    threshold_acceleration = 2.0
    threshold_braking = -2.0

    if (a > threshold_acceleration):
        return +1
    elif (a < threshold_braking):
        return -1
    else:
        return 0