update.m

Go to the documentation of this file.

% @file @model2/update.m
% @author weaves
%
% @fn void model2::update(obj self, collector0 returner)
% Given the returns, update the volatilities.
% 
% Passed an object that gives us some returns.
function update(obj, returner)
  
  % Price change (volatility proxy) over last 30 second.
  % Because using logs: this means p(t)/p(t-30).
  function v_ = vol_phase0(idx)
    v_ = NaN;
    if ~(idx > obj.smoother.phase0) 
      return;
    end
    v_ = abs(obj.returns(idx) - obj.returns(idx-obj.smoother.phase0));
  end
  
  % Price max over a period.
  % Again the log is the ratio.
  function v_ = vol_regime0(idx)
    v_ = NaN;
    if ~(idx > obj.smoother.RegimePeriod) 
      return;
    end
    intvl = (idx-obj.smoother.RegimePeriod):idx;
    v_ = obj.smoother.fagg0(obj.returns(intvl)) - ...
         obj.smoother.fagg0(min(obj.returns(intvl)));
    v_ = abs(v_);
  end
  
  % Maximum change over a short period.
  % 
  % eg. sum of p(t)/p(t-n) n = 4 to 8 
  % There is a question of whether to scale by 5 or sqrt(5).
  % Using 5.
  function v_ = vol_local0(idx)
    v_ = NaN;
    if ~(idx > obj.smoother.localVolIndex + 1)
      return;
    end
    f3 = @(x) abs(obj.returns(idx) - obj.returns(idx - x) );
    range_ = [ obj.smoother.localVolIndex0 : obj.smoother.localVolIndex ];
    lvols = arrayfun(f3, range_);

    scle_ = obj.smoother.localVolIndex - ...
            obj.smoother.localVolIndex0 + 1;
    v_ = sum(lvols) ;
    v_ = v_ / scle_;
  end
  
  % The direction of the price changes.
  %
  % Difference in average price change in current period and
  % previous period. 30 second periods.
  function r_ = return_mean(idx)
    r_ = NaN;
    if ~(idx > 2*(obj.smoother.overN+1) )
      return;
    end
    fv0 = @(x)(obj.returns( (x - obj.smoother.overN + 1):x) );
    LateMean = obj.smoother.fagg0(fv0(idx));
    EarlyMean = obj.smoother.fagg0(fv0(idx - obj.smoother.overN));

    r_ = (LateMean - EarlyMean);
  end
  
  % An exponential average.
  % 
  function v_ = vol_hvol(idx)
    v_ = NaN;
    if ~(idx > obj.smoother.hvollag + 1)
      return;
    end
    last_ = obj.vols(end,5);
    if isnan(last_)
      last_ = 0;
    end
    intvl = (idx-obj.smoother.hvollag+1) : idx;
    v_ = obj.smoother.fagg0( abs(diff(obj.returns(intvl))) );
    % Not used
    v_ = dot( [ v_, last_ ], ...
              [ obj.smoother.hvol, 1 - obj.smoother.hvol ]);
  end
  
  % The time series might have been refreshed. We ask for all prices
  % after a mark. It returns 
  % { [count of new prices] [timeseries object of all prices] }
  returns = returner.returns2(obj.cache(1).tmark);
  if isempty(returns) || ~iscell(returns) || returns{1} <= 0
    return;
  end
  % Record the new timestamp.
  obj.cache(1).tmark = datenum(returns{2}(end).getabstime());
  
  % Takes logs of the data. Note no price difference is made. We
  % just use the prices as logs.
  obj.returns = log(returns{2}.Data);
  
  % Step through new entries and add them to our big table.
  for midx=(length(obj.returns) - returns{1} +1):length(obj.returns);
    v_ = zeros(1, size(obj.cache.vols,2));
    v_(1) = vol_phase0(midx);
    v_(2) = vol_regime0(midx);
    v_(3) = vol_local0(midx);
    v_(4) = return_mean(midx);
    v_(5) = vol_hvol(midx);
    % Filter out dead zones.
    if ~all(isnan(v_))
      obj.cache(1).vols(obj.atomic_idx(),:) = [ v_ ];
    end
  end
  
  % Update the indicators.
  obj.quantify();
end

---