code: def get_update(self, z=None):
          
  
          if z is None:
              return self.x, self.P
          z = reshape_z(z, self.dim_z, self.x.ndim)
  
          R = self.R
          H = self.H
          P = self.P
          x = self.x
  
          # error (residual) between measurement and prediction
          y = z - dot(H, x)
  
          # common subexpression for speed
          PHT = dot(P, H.T)
  
          # project system uncertainty into measurement space
          S = dot(H, PHT) + R
  
          # map system uncertainty into kalman gain
          K = dot(PHT, self.inv(S))
  
          # predict new x with residual scaled by the kalman gain
          x = x + dot(K, y)
  
          # P = (I-KH)P(I-KH)' + KRK'
          I_KH = self._I - dot(K, H)
          P = dot(dot(I_KH, P), I_KH.T) + dot(dot(K, R), K.T)
  
          return x, P
docs: Computes the new estimate based on measurement `z` and returns it
          without altering the state of the filter.
  
          Parameters
          ----------
  
          z : (dim_z, 1): array_like
              measurement for this update. z can be a scalar if dim_z is 1,
              otherwise it must be convertible to a column vector.
  
          Returns
          -------
  
          (x, P) : tuple
              State vector and covariance array of the update.