# esda.Moran_Local_BV

class esda.Moran_Local_BV(x, y, w, transformation='r', permutations=999, geoda_quads=False, n_jobs=1, keep_simulations=True, seed=None, island_weight=0)

  Bivariate Local Moran Statistics.

  Parameters:
    x `array`

      x-axis variable

    y `array`

      (n,1), wy will be on y axis

    w `W` | `Graph`

      spatial weights instance as W or Graph aligned with y

    transformation{‘R’, ‘B’, ‘D’, ‘U’, ‘V’}

      weights transformation, default is row-standardized “r”. Other options include “B”: binary, “D”: doubly-standardized, “O”: restore original transformation (applicable only if `w` is passed as `W`), “V”: variance-stabilizing.

    permutations `int`

      number of random permutations for calculation of pseudo p_values

    geoda_quads bool

      (default=False) If True use GeoDa scheme: HH=1, LL=2, LH=3, HL=4 If False use PySAL Scheme: HH=1, LH=2, LL=3, HL=4

    njobs `int`

      number of workers to use to compute the local statistic.

    keep_simulations `Boolean`

      (default=True) If True, the entire matrix of replications under the null is stored in memory and accessible; otherwise, replications are not saved

    seed None/int

      Seed to ensure reproducibility of conditional randomizations. Must be set here, and not outside of the function, since numba does not correctly interpret external seeds nor numpy.random.RandomState instances.

    island_weight:

      value to use as a weight for the “fake” neighbor for every island. If numpy.nan, will propagate to the final local statistic depending on the stat_func. If 0, then the lag is always zero for islands.

  Attributes:
    zx `array`

      original x variable standardized by mean and std

    zy `array`

      original y variable standardized by mean and std

    w `W` | `Graph`

      original w object

    permutations `int`

      number of random permutations for calculation of pseudo p_values

    Is `float`

      value of Moran’s I

    q `array`

      (if permutations>0) values indicate quandrant location 1 HH, 2 LH, 3 LL, 4 HL

    sim `array`

      (if permutations>0) vector of I values for permuted samples

    p_sim `array`

      (if permutations>0) p-value based on permutations (one-sided) null: spatial randomness alternative: the observed Ii is further away or extreme from the median of simulated values. It is either extremelyi high or extremely low in the distribution of simulated Is.

    EI_sim `array`

      (if permutations>0) average values of local Is from permutations

    VI_sim `array`

      (if permutations>0) variance of Is from permutations

    seI_sim: array

      (if permutations>0) standard deviations of Is under permutations.

    z_sim `arrray`

      (if permutations>0) standardized Is based on permutations

    p_z_sim: array

      (if permutations>0) p-values based on standard normal approximation from permutations (one-sided) for two-sided tests, these values should be multiplied by 2

  Examples

      >>> import libpysal
      >>> import numpy as np
      >>> np.random.seed(10)
      >>> w = libpysal.io.open(libpysal.examples.get_path("sids2.gal")).read()
      >>> f = libpysal.io.open(libpysal.examples.get_path("sids2.dbf"))
      >>> x = np.array(f.by_col['SIDR79'])
      >>> y = np.array(f.by_col['SIDR74'])
      >>> from esda.moran import Moran_Local_BV
      >>> lm =Moran_Local_BV(x, y, w, transformation = "r",                                permutations = 99)
      >>> lm.q[:10]
      array([3, 4, 3, 4, 2, 1, 4, 4, 2, 4])
      >>> lm = Moran_Local_BV(x, y, w, transformation = "r",                                permutations = 99, geoda_quads=True)
      >>> lm.q[:10]
      array([2, 4, 2, 4, 3, 1, 4, 4, 3, 4])

  Note random components result is slightly different values across architectures so the results have been removed from doctests and will be moved into unittests that are conditional on architectures.

  __init__(x, y, w, transformation='r', permutations=999, geoda_quads=False, n_jobs=1, keep_simulations=True, seed=None, island_weight=0)

  Methods

  `__init__`(x, y, w[, transformation, ...]) |
  `by_col`(df, x[, y, w, inplace, pvalue, outvals]) | Function to compute a Moran_Local_BV statistic on a dataframe
  `explore`(gdf[, crit_value]) | Create interactive map of LISA indicators
  `get_cluster_labels`([crit_value]) | Return LISA cluster labels for each observation.
  `plot`(gdf[, crit_value]) | Create static map of LISA indicators
  `plot_combination`(gdf, attribute[, ...]) | Produce three-plot visualisation of Moran Scatteprlot, LISA cluster and Choropleth maps, with Local Moran region and quadrant masking
  `plot_scatter`([crit_value, ax, scatter_kwds, ...]) | Plot a Moran scatterplot with optional coloring for significant points.

  classmethod by_col(df, x, y=None, w=None, inplace=False, pvalue='sim', outvals=None, **stat_kws)

    Function to compute a Moran_Local_BV statistic on a dataframe

    Parameters:
      df `pandas.DataFrame`

        a pandas dataframe with a geometry column

      X `list` of `strings`

        column name or list of column names to use as X values to compute the bivariate statistic. If no Y is provided, pairwise comparisons among these variates are used instead.

      Y `list` of `strings`

        column name or list of column names to use as Y values to compute the bivariate statistic. if no Y is provided, pariwise comparisons among the X variates are used instead.

      w `W` | `Graph`

        spatial weights instance as W or Graph aligned with the dataframe. If not provided, this is searched for in the dataframe’s metadata

      inplace bool

        a boolean denoting whether to operate on the dataframe inplace or to return a series contaning the results of the computation. If operating inplace, the derived columns will be named ‘column_moran_local_bv’

      pvalue `str`

        a string denoting which pvalue should be returned. Refer to the the Moran_Local_BV statistic’s documentation for available p-values

      outvals `list` of `strings`

        list of arbitrary attributes to return as columns from the Moran_Local_BV statistic

      **stat_kws `dict`

        options to pass to the underlying statistic. For this, see the documentation for the Moran_Local_BV statistic.

    Returns:
      `If` `inplace`, `None`, `and` `operation` `is` `conducted` `on` `dataframe`
      `in` memory. `Otherwise`, `returns` `a` `copy` of `the` `dataframe` `with`
      `the` `relevant` `columns` attached.
  explore(gdf, crit_value=0.05, **kwargs)

    Create interactive map of LISA indicators

    Parameters:
      gdf `geopandas.GeoDataFrame`

        geodataframe used to conduct the local Moran analysis

      crit_value `float`, optional

        critical value to determine statistical significance, by default 0.05

      kwargs `dict`, optional

        additional keyword arguments passed to the geopandas explore method

    Returns:
      `Folium.Map`

        interactive map with LISA clusters

  get_cluster_labels(crit_value=0.05)

    Return LISA cluster labels for each observation.

    Parameters:
      crit_value `float`, optional

        crititical significance value for statistical inference, by default 0.05

    Returns:
      `numpy.array`

        an array of cluster labels aligned with the input data used to conduct the local Moran analysis

  plot(gdf, crit_value=0.05, **kwargs)

    Create static map of LISA indicators

    Parameters:
      gdf `geopandas.GeoDataFrame`

        geodataframe used to conduct the local Moran analysis

      crit_value `float`, optional

        critical value to determine statistical significance, by default 0.05

      kwargs `dict`, optional

        additional keyword arguments passed to the geopandas explore method

    Returns:
      `ax`

        matplotlib axis

  plot_combination(gdf, attribute, crit_value=0.05, region_column=None, mask=None, mask_color='#636363', quadrant=None, legend=True, scheme='Quantiles', cmap='YlGnBu', figsize=(15, 4), scatter_kwds=None, fitline_kwds=None, legend_kwds=None)

    Produce three-plot visualisation of Moran Scatteprlot, LISA cluster and Choropleth maps, with Local Moran region and quadrant masking

    Parameters:
      gdf `geopandas.GeoDataFrame`

        geodataframe used to conduct the local Moran analysis

      attribute `str`

        Column name of attribute which should be depicted in Choropleth map.

      crit_value `float`, optional

        critical value to determine statistical significance, by default 0.05

      region_column: string, optional

        Column name containing mask region of interest, by default None

      mask: str, float, int, optional

        Identifier or name of the region to highlight, by default None Use the same dtype to specifiy as in original dataset.

      mask_color: str, optional

        Color of mask, by default ‘#636363’.

      quadrant `int`, optional

        Quadrant 1-4 in scatterplot masking values in LISA cluster and Choropleth maps, by default None

      figsize: tuple, optional

        W, h of figure, by default (15,4)

      legend: boolean, optional

        If True, legend for maps will be depicted, by default True

      scheme: str, optional

        Name of mapclassify classifier to be used, by default ‘Quantiles’

      cmap: str, optional

        Name of matplotlib colormap used for plotting the Choropleth. By default ‘YlGnBu’.

      scatter_kwds `keyword` `arguments`, optional

        Keywords used for creating and designing the scatter points, by default None.

      fitline_kwds `keyword` `arguments`, optional

        Keywords used for creating and designing the moran fitline in the scatterplot, by default None.

      legend_kwds `dict`

        Keyword arguments passed to geopandas.GeodataFrame.plot `legend_kwds` allowing repositioning of the legend in LISA cluster plot and choropleth.

    Returns:
      axs `array` of `Matplotlib` `axes`
  plot_scatter(crit_value=0.05, ax=None, scatter_kwds=None, fitline_kwds=None)

    Plot a Moran scatterplot with optional coloring for significant points.

    Parameters:
      crit_value `float`, optional

        Critical value to determine statistical significance, by default 0.05.

      ax `matplotlib.axes.Axes`, optional

        Pre-existing axes for the plot, by default None.

      scatter_kwds `dict`, optional

        Additional keyword arguments for scatter plot, by default None.

      fitline_kwds `dict`, optional

        Additional keyword arguments for fit line, by default None.

    Returns:
      `matplotlib.axes.Axes`

        Axes object with the Moran scatterplot.