code: def beta_aligned(returns, factor_returns, risk_free=0.0, out=None):
      """Calculates beta.
  
      If they are pd.Series, expects returns and factor_returns have already
      been aligned on their labels.  If np.ndarray, these arguments should have
      the same shape.
  
      Parameters
      ----------
      returns : pd.Series or np.ndarray
          Daily returns of the strategy, noncumulative.
          - See full explanation in :func:`~empyrical.stats.cum_returns`.
      factor_returns : pd.Series or np.ndarray
           Daily noncumulative returns of the factor to which beta is
           computed. Usually a benchmark such as the market.
           - This is in the same style as returns.
      risk_free : int, float, optional
          Constant risk-free return throughout the period. For example, the
          interest rate on a three month us treasury bill.
      out : array-like, optional
          Array to use as output buffer.
          If not passed, a new array will be created.
  
      Returns
      -------
      beta : float
          Beta.
      """
      # Cache these as locals since we're going to call them multiple times.
      nan = np.nan
      isnan = np.isnan
  
      returns_1d = returns.ndim == 1
      if returns_1d:
          returns = np.asanyarray(returns)[:, np.newaxis]
  
      if factor_returns.ndim == 1:
          factor_returns = np.asanyarray(factor_returns)[:, np.newaxis]
  
      N, M = returns.shape
  
      if out is None:
          out = np.full(M, nan)
      elif out.ndim == 0:
          out = out[np.newaxis]
  
      if len(returns) < 1 or len(factor_returns) < 2:
          out[()] = nan
          if returns_1d:
              out = out.item()
          return out
  
      # Copy N times as a column vector and fill with nans to have the same
      # missing value pattern as the dependent variable.
      #
      # PERF_TODO: We could probably avoid the space blowup by doing this in
      # Cython.
  
      # shape: (N, M)
      independent = np.where(
          isnan(returns),
          nan,
          factor_returns,
      )
  
      # Calculate beta as Cov(X, Y) / Cov(X, X).
      # https://en.wikipedia.org/wiki/Simple_linear_regression#Fitting_the_regression_line  # noqa
      #
      # NOTE: The usual formula for covariance is::
      #
      #    mean((X - mean(X)) * (Y - mean(Y)))
      #
      # However, we don't actually need to take the mean of both sides of the
      # product, because of the folllowing equivalence::
      #
      # Let X_res = (X - mean(X)).
      # We have:
      #
      #     mean(X_res * (Y - mean(Y))) = mean(X_res * (Y - mean(Y)))
      #                             (1) = mean((X_res * Y) - (X_res * mean(Y)))
      #                             (2) = mean(X_res * Y) - mean(X_res * mean(Y))
      #                             (3) = mean(X_res * Y) - mean(X_res) * mean(Y)
      #                             (4) = mean(X_res * Y) - 0 * mean(Y)
      #                             (5) = mean(X_res * Y)
      #
      #
      # The tricky step in the above derivation is step (4). We know that
      # mean(X_res) is zero because, for any X:
      #
      #     mean(X - mean(X)) = mean(X) - mean(X) = 0.
      #
      # The upshot of this is that we only have to center one of `independent`
      # and `dependent` when calculating covariances. Since we need the centered
      # `independent` to calculate its variance in the next step, we choose to
      # center `independent`.
  
      ind_residual = independent - nanmean(independent, axis=0)
  
      covariances = nanmean(ind_residual * returns, axis=0)
  
      # We end up with different variances in each column here because each
      # column may have a different subset of the data dropped due to missing
      # data in the corresponding dependent column.
      # shape: (M,)
      np.square(ind_residual, out=ind_residual)
      independent_variances = nanmean(ind_residual, axis=0)
      independent_variances[independent_variances < 1.0e-30] = np.nan
  
      np.divide(covariances, independent_variances, out=out)
  
      if returns_1d:
          out = out.item()
  
      return out
  
imports: from __future__ import division
  import math
  import pandas
  import numpy
  from math import pow
  from scipy import stats, optimize
  from six import iteritems
  from sys import float_info
  from .utils import nanmean, nanstd, nanmin, up, down, roll, rolling_window
  from .periods import ANNUALIZATION_FACTORS, APPROX_BDAYS_PER_YEAR
  from .periods import DAILY, WEEKLY, MONTHLY, QUARTERLY, YEARLY
label_desc: Use image node_id 28 for calling a global function with example usage: beta_aligned(returns, factor_returns, risk_free, out) and returns: out, out