docstr: Tests for `Factor.pearsonr` and `Factor.spearmanr` when passed another
  2D factor instead of a Slice.
docstr_tok: ["Tests","for","`","Factor.pearsonr","`","and","`","Factor.spearmanr","`","when","passed","another","2D","factor","instead","of","a","Slice","."]
code: def test_factor_correlation_methods_two_factors(
      self, correlation_length
  ):
      """
      Tests for `Factor.pearsonr` and `Factor.spearmanr` when passed another
      2D factor instead of a Slice.
      """
      assets = self.assets
      dates = self.dates
      start_date = self.pipeline_start_date
      end_date = self.pipeline_end_date
      start_date_index = self.start_date_index
      end_date_index = self.end_date_index
      num_days = self.num_days
      run_pipeline = self.run_pipeline
  
      # Ensure that the correlation methods cannot be called with two 2D
      # factors which have different masks.
      returns_masked_1 = Returns(
          window_length=5,
          inputs=[self.col],
          mask=AssetID().eq(1),
      )
      returns_masked_2 = Returns(
          window_length=5,
          inputs=[self.col],
          mask=AssetID().eq(2),
      )
      with self.assertRaises(IncompatibleTerms):
          returns_masked_1.pearsonr(
              target=returns_masked_2,
              correlation_length=correlation_length,
          )
      with self.assertRaises(IncompatibleTerms):
          returns_masked_1.spearmanr(
              target=returns_masked_2,
              correlation_length=correlation_length,
          )
  
      returns_5 = Returns(window_length=5, inputs=[self.col])
      returns_10 = Returns(window_length=10, inputs=[self.col])
  
      pearson_factor = returns_5.pearsonr(
          target=returns_10,
          correlation_length=correlation_length,
      )
      spearman_factor = returns_5.spearmanr(
          target=returns_10,
          correlation_length=correlation_length,
      )
  
      columns = {
          "pearson_factor": pearson_factor,
          "spearman_factor": spearman_factor,
      }
      pipeline = Pipeline(columns=columns)
  
      results = run_pipeline(pipeline, start_date, end_date)
      pearson_results = results["pearson_factor"].unstack()
      spearman_results = results["spearman_factor"].unstack()
  
      # Run a separate pipeline that calculates returns starting
      # (correlation_length - 1) days prior to our start date. This is
      # because we need (correlation_length - 1) extra days of returns to
      # compute our expected correlations.
      columns = {"returns_5": returns_5, "returns_10": returns_10}
      results = run_pipeline(
          Pipeline(columns=columns),
          dates[start_date_index - (correlation_length - 1)],
          dates[end_date_index],
      )
      returns_5_results = results["returns_5"].unstack()
      returns_10_results = results["returns_10"].unstack()
  
      # On each day, calculate the expected correlation coefficients
      # between each asset's 5 and 10 day rolling returns. Each correlation
      # is calculated over `correlation_length` days.
      expected_pearson_results = full_like(pearson_results, nan)
      expected_spearman_results = full_like(spearman_results, nan)
      for day in range(num_days):
          todays_returns_5 = returns_5_results.iloc[
              day : day + correlation_length
          ]
          todays_returns_10 = returns_10_results.iloc[
              day : day + correlation_length
          ]
          for asset, asset_returns_5 in todays_returns_5.iteritems():
              asset_column = int(asset) - 1
              asset_returns_10 = todays_returns_10[asset]
              expected_pearson_results[day, asset_column] = pearsonr(
                  asset_returns_5,
                  asset_returns_10,
              )[0]
              expected_spearman_results[day, asset_column] = spearmanr(
                  asset_returns_5,
                  asset_returns_10,
              )[0]
  
      expected_pearson_results = DataFrame(
          data=expected_pearson_results,
          index=dates[start_date_index : end_date_index + 1],
          columns=assets,
      )
      assert_frame_equal(pearson_results, expected_pearson_results)
  
      expected_spearman_results = DataFrame(
          data=expected_spearman_results,
          index=dates[start_date_index : end_date_index + 1],
          columns=assets,
      )
      assert_frame_equal(spearman_results, expected_spearman_results)
  
imports: import numpy
  from numpy import arange, full, full_like, nan, where
  from pandas import DataFrame, date_range, Int64Index, Timestamp
  from pandas.util.testing import assert_frame_equal
  from scipy.stats import linregress, pearsonr, spearmanr
  from empyrical.stats import beta_aligned
  from zipline.assets import Equity, ExchangeInfo
  from zipline.errors import IncompatibleTerms, NonExistentAssetInTimeFrame
  from zipline.pipeline import CustomFactor, Pipeline
  from zipline.pipeline.data import USEquityPricing
  from zipline.pipeline.data.testing import TestingDataSet
  from zipline.pipeline.domain import US_EQUITIES
  from zipline.pipeline.engine import SimplePipelineEngine
  from zipline.pipeline.factors import Returns, RollingLinearRegressionOfReturns, RollingPearsonOfReturns, RollingSpearmanOfReturns, SimpleBeta
  from zipline.pipeline.factors.statistical import vectorized_beta, vectorized_pearson_r
  from zipline.pipeline.loaders.frame import DataFrameLoader
  from zipline.pipeline.sentinels import NotSpecified
  from zipline.testing import AssetID, AssetIDPlusDay, check_arrays, make_alternating_boolean_array, make_cascading_boolean_array, parameter_space
  import zipline.testing.fixtures
  from zipline.testing.predicates import assert_equal
  from zipline.utils.numpy_utils import as_column, bool_dtype, datetime64ns_dtype, float64_dtype
label_desc: Use image node_id 6 for calling the StatisticalMethodsTestCase obj's underlying member method code with example usage: obj.test_factor_correlation_methods_two_factors(correlation_length) without return types