code: def sigma_points(self, x, P):
          
  
          if self.n != np.size(x):
              raise ValueError("expected size(x) {}, but size is {}".format(
                  self.n, np.size(x)))
  
          n = self.n
  
          if np.isscalar(x):
              x = np.asarray([x])
  
          if  np.isscalar(P):
              P = np.eye(n)*P
          else:
              P = np.atleast_2d(P)
  
          lambda_ = self.alpha**2 * (n + self.kappa) - n
          U = self.sqrt((lambda_ + n)*P)
  
          sigmas = np.zeros((2*n+1, n))
          sigmas[0] = x
          for k in range(n):
              # pylint: disable=bad-whitespace
              sigmas[k+1]   = self.subtract(x, -U[k])
              sigmas[n+k+1] = self.subtract(x, U[k])
  
          return sigmas
docs: Computes the sigma points for an unscented Kalman filter
          given the mean (x) and covariance(P) of the filter.
          Returns tuple of the sigma points and weights.
  
          Works with both scalar and array inputs:
          sigma_points (5, 9, 2) # mean 5, covariance 9
          sigma_points ([5, 2], 9*eye(2), 2) # means 5 and 2, covariance 9I
  
          Parameters
          ----------
  
          x : An array-like object of the means of length n
              Can be a scalar if 1D.
              examples: 1, [1,2], np.array([1,2])
  
          P : scalar, or np.array
             Covariance of the filter. If scalar, is treated as eye(n)*P.
  
          Returns
          -------
  
          sigmas : np.array, of size (n, 2n+1)
              Two dimensional array of sigma points. Each column contains all of
              the sigmas for one dimension in the problem space.
  
              Ordered by Xi_0, Xi_{1..n}, Xi_{n+1..2n}