From 3ac35c64f435203a7b2c7a92fc0b84b72fe7ccc6 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 4 May 2020 18:12:24 +0100 Subject: [PATCH 01/67] start ripley in numpy-oriented style --- pointpats/ripley.py | 1038 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1038 insertions(+) create mode 100644 pointpats/ripley.py diff --git a/pointpats/ripley.py b/pointpats/ripley.py new file mode 100644 index 0000000..41b1f5a --- /dev/null +++ b/pointpats/ripley.py @@ -0,0 +1,1038 @@ +import numpy +import warnings +from scipy import spatial, interpolate +from functools import singledispatch +from collections import namedtuple +from libpysal.cg import alpha_shape_auto +from libpysal.cg.kdtree import Arc_KDTree + +### Utilities and dispatching + +TREE_TYPES = (spatial.KDTree, spatial.cKDTree, Arc_KDTree) +try: + from sklearn.neighbors import KDTree, BallTree + + TREE_TYPES = (*TREE_TYPES, KDTree, BallTree) +except ModuleNotFoundError: + pass + +## Define default dispatches and special dispatches without GEOS +@singledispatch +def _area(shape): + """ + If a shape has an area attribute, return it. + Works for: + shapely.geometry.Polygon + scipy.spatial.ConvexHull + """ + return shape.area + + +@_area.register +def _(shape: numpy.ndarray): + """ + If a shape describes a bounding box, compute length times width + """ + assert len(shape) == 4, "shape is not a bounding box!" + width, height = shape[2] - shape[0], shape[3] - shape[1] + return numpy.abs(width * height) + + +@singledispatch +def _bbox(shape): + """ + If a shape has bounds, use those. + Works for: + shapely.geometry.Polygon + """ + return shape.bounds + + +@_bbox.register +def _(shape: numpy.ndarray): + """ + If a shape is an array of points, compute the minima/maxima + or let it pass through if it's 1 dimensional & length 4 + """ + if (shape.ndim == 1) & (len(shape) == 4): + return shape + return numpy.array([*shape.min(axis=0), *shape.max(axis=0)]) + + +@_bbox.register +def _(shape: spatial.ConvexHull): + """ + For scipy.spatial.ConvexHulls, compute the bounding box from + their boundary points. + """ + return _bbox(shape.points[shape.vertices]) + + +@singledispatch +def _contains(shape, x, y): + """ + Try to use the shape's contains method directly on XY. + Does not currently work on anything. + """ + return shape.contains((x, y)) + + +@_contains.register +def _(shape: numpy.ndarray, x: float, y: float): + """ + If provided an ndarray, assume it's a bbox + and return whether the point falls inside + """ + xmin, xmax = shape[0], shape[2] + ymin, ymax = shape[1], shape[3] + in_x = (xmin <= x) and (x <= xmax) + in_y = (ymin <= y) and (y <= ymax) + return in_x & in_y + + +@_contains.register +def _(shape: spatial.Delaunay, x: float, y: float): + """ + For points and a delaunay triangulation, use the find_simplex + method to identify whether a point is inside the triangulation. + + If the returned simplex index is -1, then the point is not + within a simplex of the triangulation. + """ + return delaunay.find_simplex((x, y)) > 0 + + +@_contains.register +def _(shape: spatial.ConvexHull, x: float, y: float): + """ + For convex hulls, convert their exterior first into a Delaunay triangulation + and then use the delaunay dispatcher. + """ + exterior = shape.points[shape.vertices] + delaunay = spatial.Delaunay(exterior) + return _contains(x, y, delaunay) + + +try: + import shapely + + HAS_SHAPELY = True + + @_contains.register + def _(shape: shapely.geometry.Polygon, x: float, y: float): + """ + If we know we're working with a shapely polygon, + then use the contains method & cast input coords to a shapely point + """ + return shape.contains(shapely.geometry.Point((x, y))) + + +except ModuleNotFoundError: + HAS_SHAPELY = False + + +try: + import pygeos + + HAS_PYGEOS = True + + @_area.register + def _(shape: pygeos.Geometry): + """ + If we know we're working with a pygeos polygon, + then use pygeos.area + """ + return pygeos.area(shape) + + @_contains.register + def _(shape: pygeos.Geometry, x: float, y: float): + """ + If we know we're working with a pygeos polygon, + then use pygeos.within casting the points to a pygeos object too + """ + return pygeos.within(pygeos.points((x, y)), shape) + + @_bbox.register + def _(shape: pygeos.Geometry): + """ + If we know we're working with a pygeos polygon, + then use pygeos.bounds + """ + return pygeos.bounds(shape) + + +except ModuleNotFoundError: + HAS_PYGEOS = False + + +def _build_best_tree(coordinates, metric): + """ + Build the best query tree that can support the application. + Chooses from: + 1. sklearn.KDTree if available and metric is simple + 2. sklearn.BallTree if available and metric is complicated + 3. scipy.spatial.cKDTree if nothing else + """ + tree = spatial.cKDTree + try: + from sklearn.neighbors import KDTree, BallTree + + if metric in KDTree.valid_metrics: + tree = lambda coordinates: KDTree(coordinates, metric=metric) + elif metric in BallTree.valid_metrics: + tree = lambda coordinates: BallTree(coordinates, metric=metric) + elif callable(metric): + warnings.Warn( + "Distance metrics defined in pure Python may " + " have unacceptable performance!" + ) + tree = lambda coordinates: BallTree(coordinates, metric=metric) + except ModuleNotFoundError: + pass + return tree(coordinates) + + +def _prepare_hull(coordinates, hull): + """ + Construct a hull from the coordinates given a hull type + Will either return: + - a bounding box array of [xmin, ymin, xmax, ymax] + - a scipy.spatial.ConvexHull object from the Qhull library + - a shapely shape using alpha_shape_auto + """ + if (hull is None) or (hull == "bbox"): + return numpy.array([*coordinates.min(axis=0), *coordinates.max(axis=0)]) + if isinstance(hull, numpy.ndarray): + assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" + assert hull.ndim == 1, f"bounding box provided is not shaped correctly! {hull}" + return hull + if HAS_SHAPELY: # protect the isinstance check if import has failed + if isinstance(hull, shapely.geometry.Polygon): + return hull + if HAS_PYGEOS: + if isinstance(hull, pygeos.Geometry): + return hull + if isinstance(hull, str): + if hull.startswith("convex"): + return spatial.ConvexHull(coordinates) + elif hull.startswith("alpha") or hull.startswith("α"): + return alpha_shape_auto(coordinates) + + raise ValueError( + f"Hull type {hull} not in the set of valid options:" + f" (None, 'bbox', 'convex', 'alpha', 'α', " + f" shapely.geometry.Polygon, pygeos.Geometry)" + ) + + +def _prepare(coordinates, support, distances, metric, hull, edge_correction): + """ + prepare the arguments to convert into a standard format + 1. cast the coordinates to a numpy array + 2. precomputed metrics must have distances provided + 3. metrics must be callable or string + 4. warn if distances are specified and metric is not default + 5. make distances a numpy.ndarray + 6. construct the support, accepting: + - num_steps -> a linspace with len(support) == num_steps + from zero to a quarter of the bounding box's smallest side + - (stop, ) -> a linspace with len(support) == 20 + from zero to stop + - (start, stop) -> a linspace with len(support) == 20 + from start to stop + - (start, stop, num_steps) -> a linspace with len(support) == num_steps + from start to stop + - numpy.ndarray -> passed through + """ + # Throw early if edge correction is requested + if edge_correction is not None: + raise NotImplementedError("Edge correction is not currently implemented.") + + # cast to coordinate array + coordinates = numpy.asarray(coordinates) + hull = _prepare_hull(coordinates, hull) + + # evaluate distances + if (distances is None) and metric == "precomputed": + raise ValueError( + "If metric =`precomputed` then distances must" + " be provided as a (n,n) numpy array." + ) + if not (isinstance(metric, str) or callable(metric)): + raise TypeError( + f"`metric` argument must be callable or a string. Recieved: {metric}" + ) + if distances is not None and metric != "euclidean": + warnings.Warn( + "Distances were provided. The specified metric will be ignored." + " To use precomputed distances with a custom distance metric," + " do not specify a `metric` argument." + ) + metric = "euclidean" + + if support is None: + support = 20 + + if isinstance(support, int): # if just n_steps, use the max nnd + # this is O(n log n) for kdtrees & balltrees + tmp_tree = _build_best_tree(coordinates, metric=metric) + max_dist = tmp_tree.query(coordinates, k=2)[0].max() + support = numpy.linspace(0, max_dist, num=support) + # otherwise, we need to build it using (start, stop, step) semantics + elif isinstance(support, tuple): + if len(support) == 1: # assuming this is with zero implicit start + support = numpy.linspace(0, support[0], num=20) # default support n bins + elif len(support) == 2: + support = numpy.linspace(*support, num=20) # default support n bins + elif len(support == 3): + support = numpy.linspace(support[0], support[1], num=support[2]) + else: # try to use it as is + try: + support = numpy.asarray(support) + except: + raise TypeError( + "`support` must be a tuple (either (start, stop, step), (start, stop) or (stop,))," + " an int describing the number of breaks to use to evalute the function," + " or an iterable containing the breaks to use to evaluate the function." + " Recieved object of type {}: {}".format(type(support), support) + ) + + return coordinates, support, distances, metric, hull, edge_correction + + +def _k_neighbors(tree, coordinates, k, **kwargs): + """ + Query a kdtree for k neighbors, handling the self-neighbor case + in the case of coincident points. + """ + distances, indices = tree.query(coordinates, k=k + 1, **kwargs) + n, ks = distances.shape + assert ks == k + 1 + full_indices = numpy.arange(n) + other_index_mask = indices != full_indices.reshape(n, 1) + has_k_indices = other_index_mask.sum(axis=1) == (k + 1) + other_index_mask[has_k_indices, -1] = False + distances = distances[other_index_mask].reshape(n, k) + indices = indices[other_index_mask].reshape(n, k) + return distances, indices + + +### simulators + + +def simulate(hull, intensity=None, size=None): + """ + Simulate from the given hull with a specified intensity or size. + + Hulls can be: + - bounding boxes (numpy.ndarray with dim==1 and len == 4) + - scipy.spatial.ConvexHull + - shapely.geometry.Polygon + - pygeos.Geometry + + If intensity is specified, size must be an integer reflecting + the number of realizations. + If the size is specified as a tuple, then the intensity is + determined by the area of the hull. + """ + if size is None: + if intensity is not None: + # if intensity is provided, assume + # n_observations + n_observations = int(_area(hull) * intensity) + else: + # default to 100 points + n_observations = 100 + n_replications = 1 + size = (n_observations, n_replications) + + if isinstance(size, tuple): + if len(size) == 2 and intensity is None: + n_observations, n_replications = size + intensity = n_observations / _area(hull) + elif len(size) == 2 and intensity is not None: + raise ValueError( + "Either intensity or size as (n observations, n replications)" + " can be provided. Providing both creates statistical conflicts." + " between the requested intensity and implied intensity by" + " the number of observations and the area of the hull. If" + " you want to specify the intensity, use the intensity argument" + " and set size equal to the number of replications." + ) + else: + raise ValueError( + f"Intensity and size not understood. Provide size as a tuple" + f" containing (number of observations, number of replications)" + f" with no specified intensity, or an intensity and size equal" + f" to the number of replications." + f" Recieved: `intensity={intensity}, size={size}`" + ) + + elif intensity is not None and isinstance(size, int): + # assume int size with specified intensity means n_replications at x intensity + n_observations = intensity * _area(hull) + n_replications = size + else: + raise ValueError( + f"Intensity and size not understood. Provide size as a tuple" + f" containing (number of observations, number of replications)" + f" with no specified intensity, or an intensity and size equal" + f" to the number of replications." + f" Recieved: `intensity={intensity}, size={size}`" + ) + result = numpy.empty((n_replications, n_observations, 2)) + + bbox = _bbox(hull) + + for i_replication in range(n_replications): + generating = True + i_observation = 0 + while i_observation < n_observations: + x, y = ( + numpy.random.uniform(bbox[0], bbox[2]), + numpy.random.uniform(bbox[1], bbox[3]), + ) + if _contains(hull, x, y): + result[i_replication, i_observation] = (x, y) + i_observation += 1 + return result.squeeze() + + +def simulate_from(coordinates, hull=None, size=None): + """ + Simulate a pattern from the coordinates provided using a given assumption + about the hull of the process. + + Note: will always assume the implicit intensity of the process. + """ + n_observations = coordinates.shape[0] + hull = _prepare_hull(coordinates, hull) + return simulate(hull, intensity=None, size=(n_observations, size)) + + +### Ripley's functions + + +def f_function( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + if isinstance(coordinates, TREE_TYPES): + tree = coordinates + coordinates = tree.data + coordinates, support, distances, metric, hull, _ = _prepare( + coordinates, support, distances, metric, hull, edge_correction + ) + if distances is not None: + n_observations = coordinates.shape[0] + if distances.ndim == 2: + k, p = distances.shape + if k == p == n: + warnings.Warn( + f"A full distance matrix is not required for this function, and" + f" the intput matrix is a square {n},{n} matrix. Only the" + f" distances from p random points to their nearest neighbor within" + f" the pattern is required, as an {n},p matrix. Assuming the" + f" provided distance matrix has rows pertaining to input" + f" pattern and columns pertaining to the output points." + ) + distances = distances.min(axis=0) + elif k == n: + distances = distances.min(axis=0) + else: + raise ValueError( + f"Distance matrix should have the same rows as the input" + f" coordinates with p columns, where n may be equal to p." + f" Recieved an {k},{p} distance matrix for {n} coordinates" + ) + elif distances.ndim == 1: + p = len(distances) + else: + # Do 1000 empties. Users can control this by computing their own + # empty space distribution. + n_empty_points = 1000 + + randoms = simulate(hull=hull, size=(n_empty_points, 1)) + try: + tree + except NameError: + tree = _build_best_tree(coordinates, metric) + finally: + distances, _ = tree.query(randoms, k=1) + + counts, bins = numpy.histogram(distances, bins=support) + fracs = numpy.cumsum(counts) / counts.sum() + + return bins, numpy.asarray([0, *fracs]) + + +def g_function( + coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + + if isinstance(coordinates, (spatial.KDTree, spatial.cKDTree)): + tree = coordinates + coordinates = tree.data + coordinates, support, distances, metric, *_ = _prepare( + coordinates, support, distances, metric, None, edge_correction + ) + if distances is not None: + if distances.ndim == 2: + if distances.shape[0] == distances.shape[1] == coordinates.shape[0]: + warnings.Warn( + "The full distance matrix is not required for this function," + " only the distance to the nearest neighbor within the pattern." + " Computing this and discarding the rest." + ) + distances = distances.min(axis=1) + else: + k, p = distances.shape + n = coordinates.shape[0] + raise ValueError( + " Input distance matrix has an invalid shape: {k},{p}." + " Distances supplied can either be 2 dimensional" + " square matrices with the same number of rows" + " as `coordinates` ({n}) or 1 dimensional and contain" + " the shortest distance from each point in " + " `coordinates` to some other point in coordinates." + ) + elif distances.ndim == 1: + if distance.shape[0] != coordinates.shape[0]: + raise ValueError( + f"Distances are not aligned with coordinates! Distance" + f" matrix must be (n_coordinates, n_coordinates), but recieved" + f" {distance.shape} instead of ({coordinates.shape[0]},)" + ) + else: + raise ValueError( + "Distances supplied can either be 2 dimensional" + " square matrices with the same number of rows" + " as `coordinates` or 1 dimensional and contain" + " the shortest distance from each point in " + " `coordinates` to some other point in coordinates." + " Input matrix was {distances.ndim} dimensioanl" + ) + else: + try: + tree + except NameError: + tree = _build_best_tree(coordinates, metric) + finally: + distances, indices = _k_neighbors(tree, coordinates, k=2) + + counts, bins = numpy.histogram(distances.squeeze(), bins=support) + fracs = numpy.cumsum(counts) / counts.sum() + + return bins, numpy.asarray([0, *fracs]) + + +def j_function( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: tuple of numpy.ndarray + precomputed distances to use to evaluate the j function. + The first must be of shape (n,n) or (n,) and is used in the g function. + the second must be of shape (n,p) or (p,) (with p possibly equal to n) + used in the f function. + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern for the f function. + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + trucnate: bool (default: True) + whether or not to truncate the results when the F function reaches one. If the + F function is one but the G function is less than one, this function will return + numpy.nan values. + """ + if distances is not None: + g_distances, f_distances = distances + else: + g_distances = f_distances = None + fsupport, fstats = f_function( + coordinates, + support=support, + distances=f_distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + ) + + gsupport, gstats = g_function( + coordinates, + support=support, + distances=g_distances, + metric=metric, + edge_correction=edge_correction, + ) + + if not (numpy.allclose(gsupport, fsupport)): + ffunction = interpolate.interp1d(fsupport, fstats, fill_value=1) + fstats = ffunction(gsupport) + fsupport = gsupport + + with numpy.errstate(invalid="ignore", divide="ignore"): + hazard_ratio = (1 - gstats) / (1 - fstats) + both_zero = (gstats == 1) & (fstats == 1) + hazard_ratio[both_zero] = 1 + is_inf = numpy.isinf(hazard_ratio) + first_inf = is_inf.argmax() + if not is_inf.any(): + first_inf = len(hazard_ratio) + if first_inf < len(hazard_ratio) and isinstance(support, int): + warnings.warn( + f"requested {support} bins to evaluate the J function, but" + f"it reaches infinity at d={gsupport[first_inf]}, meaning only" + f"{first_inf} bins will be used to characterize the J function." + ) + + return (gsupport[:first_inf], hazard_ratio[:first_inf]) + + +def k_function( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + coordinates, support, distances, metric, hull, edge_correction = _prepare( + coordinates, support, distances, metric, hull, edge_correction + ) + n = coordinates.shape[0] + upper_tri_n = n * (n - 1) * 0.5 + if distances is not None: + if distances.ndim == 1: + if distances.shape[0] != upper_tri_n: + raise ValueError( + f"Shape of inputted distances is not square, nor is the upper triangular" + f" matrix matching the number of input points. The shape of the input matrix" + f" is {distance.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + ) + upper_tri_distances = distances + elif distances.shape[0] == distances.shape[1] == n: + upper_tri_distances = distances[numpy.triu_indices_from(distances, k=1)] + else: + raise ValueError( + f"Shape of inputted distances is not square, nor is the upper triangular" + f" matrix matching the number of input points. The shape of the input matrix" + f" is {distance.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + ) + else: + upper_tri_distances = spatial.distance.pdist(coordinates, metric=metric) + n_pairs_less_than_d = (upper_tri_distances < support.reshape(-1, 1)).sum(axis=1) + intensity = n / _area(hull) + k_estimate = ((n_pairs_less_than_d * 2) / n) / intensity + return support, k_estimate + + +def l_function( + coordinates, + support=None, + permutations=9999, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + linearized=False, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + linearized : bool + whether or not to subtract the expected value from l at each + distance bin. This centers the l function on zero for all distances. + Proposed by Besag (1977) #TODO: fix besag ref + """ + + support, k_estimate = k_function( + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + ) + + return support, numpy.sqrt(k_estimate / numpy.pi) - linearized * support + + +### Ripley tests + +FtestResult = namedtuple( + "FtestResult", ("support", "statistic", "pvalue", "reference_distribution") +) +GtestResult = namedtuple( + "GtestResult", ("support", "statistic", "pvalue", "reference_distribution") +) +JtestResult = namedtuple( + "JtestResult", ("support", "statistic", "pvalue", "reference_distribution") +) +KtestResult = namedtuple( + "KtestResult", ("support", "statistic", "pvalue", "reference_distribution") +) +LtestResult = namedtuple( + "LtestResult", ("support", "statistic", "pvalue", "reference_distribution") +) + +_ripley_dispatch = { + "F": (f_function, FtestResult), + "G": (g_function, GtestResult), + "J": (j_function, JtestResult), + "K": (k_function, KtestResult), + "L": (l_function, LtestResult), +} + + +def _ripley_test( + calltype, + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_replications=False, + n_replications=9999, + **kwargs, +): + stat_function, result_container = dispatch.get(calltype) + core_kwargs = dict( + support=None, metric="euclidean", hull=None, edge_correction=None, + ) + tree = _build_best_tree(coordinates, metric=metric) # amortize this + hull = _prepare_hull(tree.data, hull) # and this over replications + core_kwargs["hull"] = hull + + if calltype in ("F", "J"): + random = simulate_from(coordinates) + distances, _ = tree.query(random) + random_tree = _build_best_tree(random) + + observed_support, observed_statistic = stat_function( + tree, distances=distances, **core_kwargs + ) + core_kwargs["support"] = observed_support + + if keep_replications: + replications = numpy.empty((len(observed_support), n_replications)) + for i_replication in range(n_replications): + random_i = simulate_from(tree.coordinates) + if calltype in ("F", "J"): + distances, _ = random_tree(random_i) + core_kwargs["distance"] = distances + replications_i = stat_function(random_i, **core_kwargs)[1] + if keep_replications: + replications[i] = replications_i + return result_container( + observed_support, statistic, pvalue, replications if keep_replications else None + ) + + +def f_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_replications=False, + n_replications=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_replications: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's reference_distribution attribute + n_replications: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + + return _ripley_test( + "F", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_replications=keep_replications, + n_replications=n_replications, + ) + + +def g_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_replications=False, + n_replications=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_replications: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's reference_distribution attribute + n_replications: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "G", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_replications=keep_replications, + n_replications=n_replications, + ) + + +def j_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_replications=False, + n_replications=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_replications: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's reference_distribution attribute + n_replications: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "J", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_replications=keep_replications, + n_replications=n_replications, + ) + + +def k_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + n_replications=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_replications: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's reference_distribution attribute + n_replications: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "K", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_replications=keep_replications, + n_replications=n_replications, + ) + + +def l_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + linearized=False, + n_replications=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_replications: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's reference_distribution attribute + n_replications: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "L", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_replications=keep_replications, + n_replications=n_replications, + ) From 47d958048948be6e7efa00e9fa938ea15508d04d Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 4 May 2020 18:14:00 +0100 Subject: [PATCH 02/67] add start of rosetta stone --- .../distance_statistics-numpy-oriented.ipynb | 1157 +++++++++++++++++ 1 file changed, 1157 insertions(+) create mode 100644 notebooks/distance_statistics-numpy-oriented.ipynb diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb new file mode 100644 index 0000000..ab88b54 --- /dev/null +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -0,0 +1,1157 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Distance Based Statistical Method for Planar Point Patterns\n", + "\n", + "**Authors: Serge Rey and Wei Kang **\n", + "\n", + "## Introduction\n", + "\n", + "Distance based methods for point patterns are of three types:\n", + "\n", + "* [Mean Nearest Neighbor Distance Statistics](#Mean-Nearest-Neighbor-Distance-Statistics)\n", + "* [Nearest Neighbor Distance Functions](#Nearest-Neighbor-Distance-Functions)\n", + "* [Interevent Distance Functions](#Interevent-Distance-Functions)\n", + "\n", + "In addition, we are going to introduce a computational technique [Simulation Envelopes](#Simulation-Envelopes) to aid in making inferences about the data generating process. An [example](#CSR-Example) is used to demonstrate how to use and interprete simulation envelopes." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy import spatial\n", + "import libpysal as ps\n", + "import numpy as np\n", + "from pointpats import (PointPattern, PoissonPointProcess, as_window, \n", + " G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv)\n", + "from pointpats import ripley\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mean Nearest Neighbor Distance Statistics\n", + "\n", + "The nearest neighbor(s) for a point $u$ is the point(s) $N(u)$ which meet the condition\n", + "$$d_{u,N(u)} \\leq d_{u,j} \\forall j \\in S - u$$\n", + "\n", + "The distance between the nearest neighbor(s) $N(u)$ and the point $u$ is nearest neighbor distance for $u$. After searching for nearest neighbor(s) for all the points and calculating the corresponding distances, we are able to calculate mean nearest neighbor distance by averaging these distances.\n", + "\n", + "It was demonstrated by Clark and Evans(1954) that mean nearest neighbor distance statistics distribution is a normal distribution under null hypothesis (underlying spatial process is CSR). We can utilize the test statistics to determine whether the point pattern is the outcome of CSR. If not, is it the outcome of cluster or regular\n", + "spatial process?\n", + "\n", + "Mean nearest neighbor distance statistic\n", + "\n", + "$$\\bar{d}_{min}=\\frac{1}{n} \\sum_{i=1}^n d_{min}(s_i)$$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "points = [[66.22, 32.54], [22.52, 22.39], [31.01, 81.21],\n", + " [9.47, 31.02], [30.78, 60.10], [75.21, 58.93],\n", + " [79.26, 7.68], [8.23, 39.93], [98.73, 77.17],\n", + " [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]]\n", + "pp = PointPattern(points)\n", + "kdt = spatial.KDTree(points)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Nearest Neighbor Distance Functions\n", + "\n", + "Nearest neighbour distance distribution functions (including the nearest “event-to-event” and “point-event” distance distribution functions) of a point process are cumulative distribution functions of several kinds -- $G, F, J$. By comparing the distance function of the observed point pattern with that of the point pattern from a CSR process, we are able to infer whether the underlying spatial process of the observed point pattern is CSR or not for a given confidence level." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $G$ function - event-to-event\n", + "\n", + "The $G$ function is defined as follows: for a given distance $d$, $G(d)$ is the proportion of nearest neighbor distances that are less than $d$.\n", + "$$G(d) = \\sum_{i=1}^n \\frac{ \\phi_i^d}{n}$$\n", + "\n", + "$$ \n", + "\\phi_i^d =\n", + " \\begin{cases}\n", + " 1 & \\quad \\text{if } d_{min}(s_i)" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gp1 = G(pp, intervals=20)\n", + "gp1.plot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "support, gfunction = ripley.g_function(points, support=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3dd3hUZdrH8e+TTgglkAKkCNJ7CyCICoiAFQtIU+wIiuXVXde2a1lXXXZta8OyrNIVKYIiCLaAJRBKAgktUlIoaSQhPZl53j9OkAApkzCTMzO5P9eVK5k5Z878PJg7Z57zFKW1RgghhOvzMDuAEEII+5CCLoQQbkIKuhBCuAkp6EII4SakoAshhJvwMuuNg4KCdPv27c16eyGEcEnbtm3L1FoHV7XNtILevn17YmNjzXp7IYRwSUqpI9VtkyYXIYRwE1LQhRDCTUhBF0IINyEFXQgh3IQUdCGEcBO1FnSl1DylVLpSanc125VS6j9KqSSlVLxSaoD9YwohhKiNLVfonwDjath+NdC54msG8P6FxxJCCFFXtfZD11pHK6Xa17DLeGC+Nubh/U0p1VIp1VZrfcxOGYUQwqlsOrSfuds+Y+jFLQEN2nr+l7WK57QVtGZA20EM63Kj3XPZY2BRGJBS6XFqxXPnFXSl1AyMq3giIyPt8NZCCFGJ1mAphdICKM2v+F4AJafO/Fz5+dJ8KC+u+CoFSwmUV3xZSs88X14MlhKs5SUcLynm5dCmpHp7sSu+futJ3J25z2kLuqriuSr/K7XWHwIfAkRFRcnKGkKIqmltFNvCbCjMMr4XVfq5MMv4Ksqu2HbyTKG2ltv+Pt5NwdsPPH3Bq+LL0we8/Iyf/VpW/OzD0XwrP6fl81FQCplepfw38DIGN2sHHt7g4QkeXuDpbXw//djjnMentwd2cMhps0dBTwUiKj0OB47a4bhCCHdUXgp5qZCbCjkpkHv6KxXyM84UbktpNQdQ0CQQ/FuDfytoGQlt+oBvAPgEgE/TM9/Peu708xWPvf3Bo/bbiGk5RTy/OoEN+44R3HEpJT4lvDHyDQZHXmnf82IH9ijoq4HZSqmlwBAgV9rPhWjEinKM4pybcn7BzkmB/BOc9yE+oA20CIfA9hA24Eyx9m8NTVqd/divhXHF62BlFiv/+/kQb2w4AGiGDd7MrlPxPDX4Ka50wmIONhR0pdQSYAQQpJRKBZ4DvAG01nOBtcA1QBJQCNzlqLBCCCdSXgqZ++FEApzYXfE9AfKPn72fp49RrFtEQOfRxvcWEcZzLSOgeZjRvOFEth3J5pmVu9l7/BSju4fQq8d2/pu4ljt73snU7lPNjlctW3q5TKlluwYetFsiIYRz0RpOHT+/cGfuO9Ne7ekDwd2g4ygI6WY0g7SINIp202CbmjacQU5hKf9ct5clW1Jo18KPD28fiMV/B09Ev8O49uP4v4H/Z3bEGpk2fa4QwknlpsGhaDgWd6aAF2Wf2d48HEJ7QpexxvfQXtC6o3HDz0VprVmxPY1/rN1DblEZMy6/mEeu7EziyR3cv+EZBoYO5KXhL+GhnPsPkxR0IRq7wmw4vAkO/gSHfoKsJON576YQ0h26X28U7dCeENrDuCHpRpLST/HMyt3EHMpmQGRL/nFTb7q3bc7vOb/zyA+PENEsgrdGvoWvp3M1C1VFCroQjU1pAST/eqaAH4sHtNH746JLIepu6HAFhPRw+qaS4jILecVl9Xqt1QoLfzvCB9G/4+/jxSs392ZSVAQeHor0wnRmbZyFr6cv749+nxa+Leyc3DGkoAvh7ixlkLbtTAFP2QLWMqPdO3wwjHzaKOBhA1yq2eRwZgET5v5CZn513Rttc/OAMJ6+pjtBAcYVeEFZAQ9+9yA5JTl8Mu4T2gW0s0fcBiEFXQh3VJwHiV/CntVw5Bdj0A0K2vaFoQ8YBTxyKPj4m520XvJLyrlvfizlVs2L43vioaoa31i77m2bM/CiM01IZdYyHvvxMQ6cPMA7V75Dj9Y97BW5QUhBF8JdWC1w8AfYuQT2fmUMVw/sAH0nGwW8/XCjL7eLs1o1j322k4OZBcy/ezCXdgqyy3G11rz464v8cvQXXhz2IsPDhtvluA1JCroQru5EIsQthvhlRh9wv5bQbxr0nQLhUVDPq1dn9dZ3B/g28QR/u66H3Yo5wNy4uaxKWsXMvjO5qfNNdjtuQ5KCLoQryk+HXV9A3BI4Hm/MD9J5jHE13mWc0w3UsZd1u4/z1ncHuGVAOHdd2t5ux115YCXvxb3H+I7jeaDvA3Y7bkOTgi6Eqygrhv3fQNxSOLABtAXa9oOr50CvW6Cp/a5WndG+46d47POd9I1oyT9u6oWy0yePn9N+5oVfX2Bo26E8N+w5ux3XDFLQhXB2adtg+wJIWAHFudCsLQybbTSphHQ3O12DyCks5b75sTT19eKD2wbi5332XC6lllKs2lrn4yblJPHYj4/RqWUnXh/xOt4ertPLpypS0IVwVilb4MdX4ffvwKuJMcCn3xTjBmcDTE7lLMotVh5asoPjucUsmXEJbVr4nbV9btxc3tv5HrrqWbtr1aZpG94b/R4BPgH2iGsqKehCOJuUrfDjK0Yh928No18wBvv4NTc7mSle/WYvmw5kMueWPmd1MQT4Yv8XvLvzXUZFjKJPcJ86H9tDeTCm/RhC/EPsFddUUtCFcBYpW+GnVyFp45lCPuheY07vRmrF9lQ+3nyIO4ZexK2DIs7atil1Ey/99hKXhl3Kv0f82+WbS+xBCroQZpNCXqW4lByeXLGLSy5uxbPXnT3AJyErgcd/epwugV14/QrXb/u2FynoQphFCnm10k8Vc/+CbQQH+PLetIF4e56ZUyYtP40HNz5IoG8g741+D39v1xzt6ghS0IVoaKmxRht50kZjNZ7Rz8Og+6SQVygptzBr4XZyi8r4YtZQWjX1+WNbbkkuMzfMpMxaxryx8whq4t5dNetKCroQDSU11ui1krRBCnk1tNY8vzqBbUdO8s7U/vRsd2aWwxJLCQ9//zBp+Wl8NOYjLm55sYlJnZMUdCEcrTAb1j0F8UuNQn7lczD4PvBtZnYyp7MwJpklW1J4YERHrutzZpZDq7by9Kan2Z6+nX9d/i8Ghg40MaXzkoIuhCMlfglfPw5FJ+HyP8Olj0ghr0bMwSxeWJ3AqG4hPD6m61nbXot9jW+PfMufov7EuA7jTEro/KSgC+EI+emw9k9GQW/bF25fCW16m53KaaWeLOSBRduJbO3Pm5P74elxZvj9oj2LmJ84n6ndpjK9x3QTUzo/KehC2JPWxqRZ3zxhzEF+5XMw7GHwlF+16hSVWrh/wTZKy618ND2K5n5nuiBuPLKRf275J1dGXskTg55w6XlWGoL8XyaEveQdha8eMybQCh8E49+F4K61v64R01rzxPJ4Eo/lMe+OQXQMPnODeGf6Tp7c9CS9g3vz6mWv4tmIpjuoLynoQlworWHHQlj/DFhKYezLMGRmo5pvpb7m/nSQNXFHeWJcV0Z2OzP8/nDuYR76/iHaNG3DO6Pewc/Lr4ajiNOkoAtxIXKSYfXDxkpBFw2HG/4DrTuancol/LA3nTnr93Jdn7bMuuLMOcsqymLWxll4KA/ev/J9Av0CaziKqEwKuhD1YbVC7H9h4/PG42tfg4F3g4dHjS8ThoMZ+Ty8dAfd2jRnzoQ+f7SNF5YVMvu72WQWZTJv7DwimkfUciRRmRR0Ieoq63dY/RAc+Rk6joLr34KWkWanchl5xWXcNz8Wb08PPrx9IP4+Rhkqt5bzRPQTJGYn8uaIN+kdLL2C6koKuhC20hpi5sLGF8DTx7jp2W+a263ZCcaSbPtP7rf7cbXWbNxzgjSPIsZd0obFSdv/2HYo7xA/p/3Ms0OeZWTkSLu/d2MgBV0IW5QVw5qHIf4z6DwWrn8Tmrer/XUuKLckl+d/fR4fDx+7z2JYXG6h1GolIMiTLRkekHFmm1KKB/o9wKRuk+z6no2JFHQhanPqBHw2DVK3wshnjBGfbnhVftrPaT9j1VY+HvsxfYP72u24X8cf48HF25kUFcGrt/SWPuUOIAVdiJoci4MlU4yh+7fOhx7jzU7kcNFp0QT6BtKrdS+7HTPxaB5/WhbHgMiWvHhjTynmDiIFXYjqJH4JK2caE2rdvc4Ywu/mLFYLm9M2c3nY5XYbyJNdUMqMBbE0b+LF3NsG4usl/fMdxaY+VkqpcUqpfUqpJKXUk1Vsb6GUWqOUilNKJSil7rJ/VCEaiNbw0xz4fDqE9oT7vm8UxRwgPjOe3JJcLo+43C7HK7NYeXDRdtJPlfDB7VGENJcBQo5U6xW6UsoTeBe4CkgFtiqlVmutEyvt9iCQqLW+XikVDOxTSi3SWpc6JLUQjlJWBKsegIQV0Gey0SXRu/EUoejUaDyVJ8PaDbPL8f7x9R5+PZjFaxP70i+ipV2OKapnS5PLYCBJa30QQCm1FBgPVC7oGmimjIaxACAbKLdzViEcK+8oLJ0KR3cay8Fd+ohb3/ysSnRqNP1D+tPcp/kFH+vz2BQ++eUwd1/agVsGhtshnaiNLU0uYUBKpcepFc9V9g7QHTgK7AIe0Vpbzz2QUmqGUipWKRWbkZFx7mYhzJO2DT4cCZkHYPJiGP5ooyvmxwuOs//kfi4Pv/Dmlu3JJ3l25W4u7dSap6/pZod0wha2FPSq/q/W5zweC+wE2gH9gHeUUuf9iddaf6i1jtJaRwUHB9c5rBAOsesL+N814OUD93wL3a4xO5EpolOjAS64oJ/IK2bmgm2EtvDlnSkD8PKU6RAaii1nOhWoPKFCOMaVeGV3ASu0IQk4BMifZeHcrFb4/iVYfg+0GwD3/WDcBG2kNqVuIiwgjItb1H+tzuIyY27z/JJyPpoeRWClBZ6F49lS0LcCnZVSHZRSPsBkYPU5+yQDVwIopUKBrsBBewYVwq5KC2DZdIj+F/S/HaZ/CU0b7wryJZYSYo7HcFnYZfXuI6615tlVu9mZksPrt/alW5sLb4cXdVPrTVGtdblSajawHvAE5mmtE5RSMyu2zwX+DnyilNqF0UTzF611pgNzC1F/eUdh8a1wIgHGvgKXzGp07eXn2np8K0XlRRfU3PLJL4f5YlsqD4/qxLhebe2YTtjKpoFFWuu1wNpznptb6eejwBj7RhPCAfKOwifXQn4GTP0cOl9ldiKnEJ0ajZ+nH4PaDKrX639OyuSlr/cwunsoj47uYud0wlYyUlQ0HnnH4JPrjGJ++wqIGGx2IqegtSY6NZohbYfUa2WglOxCHly8nQ5BTXljUl88PBr3px0zye1n0TicOg6fXgf5J+C25VLMKzmUe4i0/LR6N7e8sXH/Hws8N/Oz7+yMom6koAv3d+qEcWWed8wo5pFDzE7kVH5K/QmAy8Iuq/NrcwpL+Tr+GDf1D6NDUFN7RxN1JAVduLf8dPj0eqPt/LYvIPISsxM5nejUaLoEdqFtQN1vZC7fnkZJuZVpQy5yQDJRV1LQhfvKzzCKeW4KTFsGF9lnfhJ3kleax470HfVqbtFasyjmCP0iWtKjnXRRdAZS0IV7Ksg0ivnJI0ZvlvaXmp3IKf1y9Bcs2lKvgv7bwWwOZhQwbYisp+ospKAL91OQCZ/eACcPw9TPoEPd24Ybi02pm2jh24I+QX3q/NrFW5Jp7ufFdX3ccyk+VyQFXbiXgiyYPx6yf4epS+HiK8xO5LSs2srmtM1c2u7SOi9mkZlfwrrdx7hlYDhNfGTBCmchBV24j8Jso5hnJcGUpXDxCLMTObXdmbvJLs6uV3PLsthUyixamlucjBR04R4Ks2H+DZC535j+tuNIsxM5vejUaDyUB8PDhtfpdVarZsmWZAZ3aEWnkGYOSifqQwq6cH1FJ40r84z9MGUxdLrS7EQuITo1mr7BfWnh26JOr9uclElydqFcnTshKejCtRXlwPwbIWMvTF4EnUabncglZBRmsCd7T72aWxbFHKFVUx/G9WrjgGTiQkhBF66rKAcW3GTMmjhpoUy0VQeb0jYBdR8deiKvmI170pk4MBxfL7kZ6mykoAvXVFoIiybA8V0waQF0GWt2IpcSnRpNqH8oXQLrNjPiZ1tTsFg1UwZLc4szkoIuXI/VCqtmQmosTJgHXa82O5FLKbWU8svRX7g8/PI6LWZRbrGyZEsyl3UOor3M2+KUpKAL1/PDS5D4JYz5O/S4wew0Lif2RCxF5UVcEV63Pvo/7svgWG4xU+Xq3GlJQReuZcci2PQaDLgDhs42O41L2pS6CV9PXwa3rdsUwou3JBPczJfRPUIdlExcKCnownUc3gxrHoEOV8C1rzX6ZePqKzo1mkFtBtHEq4nNr0k9WcgP+9KZPCgCb08pG85K/mWEa8j6HT67DVp1gFvng6cspFAfh3MPk3wquc7dFZduSUEBk6W5xalJQRfOrzAbFk0E5WHMnNikpdmJXFZ0ajRAnQp6mcXKZ7EpjOgaQlhL26/qRcOTNUWFcysvhc9uN+Y0v2ONcYUu6i06LZqOLToSFhBm82s2Jp4g41SJjAx1AXKFLpyX1vDVo3BkM4x/T1YbukAFZQVsO7Gtzs0ti2KSadfCjxFdQxyUTNiLFHThvDa/ATsXwRVPQp+JZqdxeb8e/ZVyazmXhds+OvRwZgGbkzKZMjgSTw+5Ce3spKAL55SwCr57AXpNgBFPmp3GLUSnRtPMuxn9QvrZ/JolW5Lx9FDcOijCgcmEvUhBF84ndRusvB8ihsD4d6V7oh1YtZVNaZsYFjYMbw/begiVlFv4PDaFq7qHEtrcz8EJhT1IQRfOJScFlkyGgFBjXnNvKST2sCd7D5lFmXVqP1+3+zgnC8uYdoncDHUV0stFOI/iPFg8CcpLjB4tTYPMTuQ2olOiUag6LWaxKCaZi1r7c2lH+XdwFXKFLpyDpRyW32PMa37rpxDSzexEbiU6NZrewb1p5dfKpv0PnDjFlkPZTBkciYfcDHUZUtCFc/j2GTjwrTGkX5aPs6vMokx2Z+3m8jDbm1sWxSTj7amYODDcgcmEvUlBF+aL+RBi5hqTbUXdZXYat7M5bTNg++jQolILy7encnWvtrQO8HVkNGFnNhV0pdQ4pdQ+pVSSUqrKPmRKqRFKqZ1KqQSl1E/2jSnc1u/fw7q/QNdr4KoXzU7jlqJTowlpEkK3VrY1Y30Vf5RTxeVMlZGhLqfWm6JKKU/gXeAqIBXYqpRarbVOrLRPS+A9YJzWOlkpJUPKRO1y02D5vRDcDW7+CDxkSTN7K7OW8evRXxnbfqzNi1ksikmmY3BThnSwrb1dOA9brtAHA0la64Na61JgKTD+nH2mAiu01skAWut0+8YUbsdSBl/cZfRouXU++AaYncgt7Tixg/yyfJtHhyYczWVnSg7ThlxUp9WMhHOwpaCHASmVHqdWPFdZFyBQKfWjUmqbUmp6VQdSSs1QSsUqpWIzMjLql1i4h43PQ0oM3PAfCOpsdhq3FZ0ajbeHN0PbDrVp/8Uxyfh6eXDLALkZ6opsKehV/ZnW5zz2AgYC1wJjgb8qpc5bfVZr/aHWOkprHRUcHFznsMJN7P0afn0HBt0HvW4xO41bi06LJio0Cn9v/1r3zS8pZ9WONK7r044W/jLfvCuyZWBRKlB5Iodw4GgV+2RqrQuAAqVUNNAX2G+XlMJ9ZB+ClbOgXX8Y+w+z07iE/NJ8soqz6vy6jMIMDuUe4tYut9q0/5c70ygotcjIUBdmS0HfCnRWSnUA0oDJGG3mlX0JvKOU8gJ8gCHAG/YMKtxAWTEsu8P4zDfxE/CSLnG10VozYc0E0vLT6n0MW7oraq1Z9Fsy3ds2p3+ELCDiqmot6FrrcqXUbGA94AnM01onKKVmVmyfq7Xeo5RaB8QDVuBjrfVuRwYXLmj9U3AsDqYshcD2ZqdxCan5qaTlpzGxy0QGhA6o8+uDmwQT2bz2K+641FwSj+Xx0o295GaoC7NpLhet9Vpg7TnPzT3n8b+Af9kvmnAr8csgdh5c+gh0vdrsNC4jPiMegEldJ9G1VVeHvc/Hmw7i7+PJ+H7tHPYewvFkpKhwvIx9sOYRiBwKo/5qdhqXEpcRRxOvJnRs2dFh77E4Jpmv4o9xz/AONPOTm6GuTAq6cKzSAvh8Ong3gQnzwFMKRl3EZ8TTK6gXXh6OmRh16+Fsnlu9myu6BPPo6PM6pgkXIwVdOI7W8NVjxhX6LR9Dc/k4XxfF5cXsy95H3+C+Djn+0ZwiZi3cRnigP/+Z0l+WmHMDMh+6cJzt8yF+KYx4SmZQrIfErETKdTl9gvrY/djFZRbuX7CN4jIrS2cMpEUT+eTkDqSgC8c4Fg9r/wwXj4TL/2x2Gpd0+oZon2D7FnStNU8uj2f30Vw+uj2KTiHN7Hp8YR5pchH2V5xrtJv7tzaaWmTSrXqJz4wnPCCc1k1a2/W4H286xKqdR3lsdBdG9wi167GFuaSgC/vSGr6cDTnJxk1QWUau3uIy4ux+df7T/gxe+WYP1/Ruw+xRnex6bGE+aXIR9hUzF/ashqv+DhfZNiGUON/xguOkF6bbtaAfzizgocXb6RLajH9N6CsDiNyQXKEL+0nZCt8+C12vhWEPmZ3GpcVlxAHQL7ifXY6XX1LOffNj8fBQfDQ9iqa+ci3njuRfVdhHYTYsuxOah8GN74Jc/V2Q+Ix4fD196RJ44X3DrVbN/322k4OZBSy4ezARrWqfeVG4Jino4sJZrbDyfihIh3u+hSaBZidyeXEZcfRo3QNvOwzEevO7A2xIPMFz1/dgWCe5p+HOpMlFXLgtH8KBb2Hsy8a0uOKClFpK2ZO1xy79z9ftPsZ/vjvAhIHh3Dms/YWHE05NCrq4MCcSYMPfoMs4GHSv2Wncwr7sfZRaS+kbcmEjRPcez+Oxz+PoF9FSZlFsJKSgi/orK4Iv7gG/FnDDO9Jubienb4heyBX6yYJS7psfS4CvFx/cPhA/bxkL0BhIG7qovw3PQcYeuG05BMiSgvYSnxFPqH8ooU3rN+in3GJl9pLtnMgtYen9lxDa3M/OCYWzkoIu6mf/t7DlA7jkAeg02uw0biU+M/6CJuR65Zu9/JyUxZwJfRgQKTeoGxNpchF1l58OXz4Aob3gyufMTuNWMosySctPq/eAouXbUvnv5kPcOaw9t0ZF1P4C4VbkCl3Ujdaw6gEoOQV3rAFv+ThvT6fbz+tzhb4zJYenVu5i6MWteeba7vaOJlyAFHRRN1s+hKQNcM2/IUSKhr3FZ8Tj5eFF99Z1O7cl5RZmLdxGSDNf3p02AG9P+fDdGElBF7Y7kQDf/hU6j5Uuig4SnxFP91bd8fX0rdPr1u0+zrHcYj69ezCtmvo4KJ1wdvJnXNimrAiW32t0URwvQ/sdodxaTkJWQr3azxf9lsxFrf25TEaCNmpS0IVtNj4P6Ylw4/vSRdFBDpw8QFF5UZ3bzw+cOMWWw9lMHRyJhywj16hJQRe1O7DBmBZ3yEzoLF0UHaW+KxQtiknGx9ODCQPDHRFLuBAp6KJm+emwahaE9ITRL5idxq3FZcTR2q817Zravph2UamF5dtTGderDa0D6tbuLtyP3BQV1dMavnwQivNg+mrpouhg8Znx9AnuU6c5V9bEH+VUcTnThkQ6MJlwFXKFLqq35SNjFsUxf4fQHmancWs5xTkcyTtS5/bzxTHJdAoJYHCHVg5KJlyJFHRRtROJxupDncfA4Blmp3F78Zl1bz/fnZbLzpQcpg2JlJkUBSAFXVSlrBiW3wN+zWH8e9JFsQHEZcThqTzp2bqnza9ZvCUZXy8Pbu4vN0OFQdrQxflOd1Gc9oV0UWwg8RnxdAnsgr+3bcvD5ZeU8+WONK7v244W/he+qpFwD3KFLs52YCPEvA+D74fOV5mdplGwWC3sytxVp+aWL3emUVBqkZuh4ixS0MUZ+RkVXRR7wFUvmp2m0TiYe5CCsgKbC7rWmoW/JdOjbXP6RbR0cDrhSmwq6EqpcUqpfUqpJKXUkzXsN0gpZVFKTbBfRNEgtIbVs6E4F275WLooNqDTA4ps7eGyMyWHPcfymCo3Q8U5ai3oSilP4F3gaqAHMEUpdV4ftor9/gmst3dI0QBi58H+dXDVCxBq+405ceHiM+Np4duCyGa2NZ8sjkmmqY8nN/YPc3Ay4WpsuUIfDCRprQ9qrUuBpcD4KvZ7CFgOpNsxn2gIGfth/TPQcZTRdi4aVFx6HH2CbBtQlFtYxpr4o4zvH0aAr/RpEGezpaCHASmVHqdWPPcHpVQYcBMwt6YDKaVmKKVilVKxGRkZdc0qHKG8FFbcC95NjC6KHnJbpSHllebxe+7vNrefr9iRSnGZlamD5WaoOJ8tv71VXTbocx6/CfxFa22p6UBa6w+11lFa66jgYOkO5xR+fBmOxcEN/4Hmbc1O0+jsztwN2NZ+rrVmUUwyfSNa0iushaOjCRdky2e2VKDy4oThwNFz9okCllZ8ZAwCrlFKlWutV9klpXCMw5th85vQ/3bofr3ZaRqluIw4FIpeQb1q3Xfr4ZMkpeczZ0L91hsV7s+Wgr4V6KyU6gCkAZOBqZV30Fp3OP2zUuoT4Csp5k6uKAdW3A+tOsC4V81O02jFZ8TTsWVHmvk0q3XfRTFHaObnxfV9bJ+NUTQutTa5aK3LgdkYvVf2AJ9rrROUUjOVUjMdHVA4yNePw6ljcPNH4BtgdppGSWtNfEa8Tc0t2QWlfLPrOLcMCKeJj2cDpBOuyKbb5FrrtcDac56r8gao1vrOC48lHCr+c9j9BYx8BsKjzE7TaB3OO0xeaZ5NN0S/2JZCqcXKVBkZKmogXRoam5NHjKvziCEw/DGz0zRqf6xQFFRzQbdaNYtjkhncvhVdQmtvmhGNlxT0xsRqgZUzjVGhN38IntKP2UzxGfEEeAdwccuLa9zvl9+zOJxVyLRL5Opc1Ex+oxuTn9+E5F/gxrkQ2N7sNI1efGY8vYN646Fqvq5aFHOEQH9vxvVq00DJhKuSK/TGIm07/PAy9LwJ+k42O02jV1hWyP6T+2ttP0/PK2ZD4gkmRkXg6yU3Q0XNpKA3BqUFsOI+CAiF696QBSucQEJWAlZtrbWHy+exKZRbNVNkZKiwgTS5NAbrnyqL/7oAABRmSURBVIGs3+GO1dAk0Ow0AmNAEUDvoN7V7mOxapZsSWF4pyA6BDVtqGjChckVurvbuxa2/Q+GzYYOl5udRlSIy4ijffP2tPSrfj7zn/ank5ZTJF0Vhc2koLuzUyeMOc7b9IZRfzU7jahwekBRbe3ni2OSCW7my1U9QhsomXB1UtDdldbw5QNG+/nNH4OXr9mJRIW0/DSyi7NrbD9Pyyni+73pTIqKwNtTfk2FbaQN3V1t+QiSNsLV/4KQbmanEZWcbj+v6Qr9sy3JaGDy4Ihq9xHiXPKn3x2l74UNf4VOV8Hg+8xOI84RnxFPE68mdGrZqcrtZRYrS7emMKJLMOGB/g2cTrgyKejupqwYlt8LPk1h/LvSRdEJxWfE0yuoF14eVX9A/m5POumnSpg25KIGTiZcnRR0d7P+aTixy1h9qJncTHM2xeXF7M3eW+P8LYtijtCuhR8ju4U0YDLhDqSgu5OElRD7Xxg6G7qOMzuNqMKe7D2U6/Jq28+PZBWw6UAmkwZF4ukhn65E3UhBdxfZB2H1wxAWBaOfNzuNqMYfMyxWU9CXbEnB00MxaZDcDBV1JwXdHZSXwLK7jPbyCfPA09vsRKIacRlxhAWEEdQk6LxtJeUWlsWmMLp7CG1a+JmQTrg6KejuYMPf4NhOo908UG6kObO4jLhqr87f2niArIJSbrtE/g1F/UhBd3V7voKYuTBkJnS/zuw0ogbHC46TXphe5YCiNXFHee/H35kyOJLhnc6/ehfCFlLQXdnJI8Zo0Lb94KoXzU4janG6/fzcgp5wNJc/fxFH1EWBvHBDT5R0NRX1JAXdVZWXwhd3G0P8J/5Phva7gLiMOHw8fOga2PWP57LyS5gxfxuB/j68f9tAfLzkV1LUnwz9d1XfvwhpsTDxE2hV8xJmwjnEZ8TTo3UPvCtuWpdZrDywaDuZ+SUsmzmU4GbyR1lcGLkccEX718Mvb0PUPcYKRMLplVnKSMxKPKu55aWvEok5lM2rt/SmT3j10+gKYSu5Qnc1uamw8n5jStyxL5udxiVZrBZ2Ze6izFrWYO+ZciqFUmvpHz1cPtuazKe/HuG+yzpwU//wBssh3JsUdFdiKYMv7jG+T/gEvKWvcl1ZtZWnNj/FN4e+afD39lSe9Avpx7Yj2Ty7ajeXdQ7iL+NkJkxhP1LQXckPL0PKb8b85kFVz9QnavbW9rf45tA33Nv7Xoa1G9ag7x3oG4i1rDkzF26mXcsmvD2lP14y17mwIynoriJpI2x+HQZMhz4TzU7jkj7b+xnzds/j1i638nD/hxu8e2BxmYVJH/xKYUk5i+4dQkt/nwZ9f+H+pKC7grxjsOJ+COkB4/5pdhqX9EPyD7y85WWuCL+Cp4Y81eDFXGvN0yt3EZeaywe3D6RLaLMGfX/ROMjnPWdnKTfmNy8rNLoo+siCB3UVnxHPE9FP0KNVD+ZcPqfaecgdad7Ph1mxPY1HR3dmbM82Df7+onGQK3RnFz0HjmyGG9+H4K617y/OkpKXwkPfP0RQkyDevvJt/L0b/g/i5gOZ/OPrRMb2DOXhUZ0b/P1F4yFX6M7s4I/w0xzoOxX6TTU7jcs5WXySWd/NwqqtvD/6/SpnOHS0I1kFPLh4O51CAnjt1n54yBznwoFsKuhKqXFKqX1KqSSl1JNVbJ+mlIqv+PpFKVX9cubCNqdOwPL7IKgLXPtvs9O4nOLyYh76/iGOFxzn7VFv075F+wbPUFBSzoz52wD4aHoUAb7ygVg4Vq3/hymlPIF3gauAVGCrUmq11jqx0m6HgCu01ieVUlcDHwJDHBG4USgrgqVToOQUTP/SWB9U2MxitfDkpieJz4jn9RGv0y+kX4NnsFo1j32+kwPpp5h/9xAuai3/hsLxbLlCHwwkaa0Paq1LgaXA+Mo7aK1/0VqfrHj4GyBD3+rLaoWVMyFtO9zyMYT2MDuRS9FaM2frHL5L/o6/DP4Loy8abUqOt79PYn3CCZ6+pjvDO8t0uKJh2FLQw4CUSo9TK56rzj1AlcPwlFIzlFKxSqnYjIwM21M2Jj+8BImrjOlwZX7zOpufOJ/Fexczvcd0pnWfZkqGbxOO88bG/dzcP4x7hncwJYNonGxp1KvqLo6uckelRmIU9OFVbddaf4jRHENUVFSVx2jUdiyCTa/BgDtg2ENmp3E56w6v49+x/2bMRWPo6DmZt7870OAZLFrzUfRB+oS34OWbe8vc5qJB2VLQU4HKK9aGA0fP3Ukp1Qf4GLhaa51ln3iNyOHNsOYR6HAFXPuasT6osFns8Vie3vQ0A0IG0NVjBo99Hm9alshW/nxw+0D8vD1NyyAaJ1sK+lags1KqA5AGTAbO6kOnlIoEVgC3a6332z2lu8tMgqXToFUHuHW+LPJcRwdzDvLwDw8T3iycae2fY9aCvYzpEco7UwdgRi9BD6Wke6IwRa0FXWtdrpSaDawHPIF5WusEpdTMiu1zgb8BrYH3Kj5ilmutoxwX240UZsPiW8HDE6Z+Dk1kXuy6yCjMYNbGWfh4+PDXga9z3/+S6BjclNcn9ZPVf0SjY1PHWK31WmDtOc/NrfTzvcC99o3WCJSXwme3GXOc37HGuEIXNissK+TB7x7kZMlJ3h/1MU8vPYrW0udbNF7yf71ZtDbazI/8DLf8FyLN77a/L3sfL8e8TLkuNzuKTbKLsjlWcIy3Rv6Hj78r40D6KT69e7D0+RaNlhR0s2x6DeIWw4inofcEs9MA8H7c++zN3mvKQJz6aObdjEcHPkrc/rZ8s3s/z17bncs6B5sdSwjTSEE3w+4V8P3foc8kuOIJs9MAxhJp3yd/zz297+GRAY+YHcdm3yYc5/UN27hJ+nwLIZNzNbjUWFg1CyKHwg1vO033xMV7FuOpPJncdbLZUWx24MQp/u+znfQJb8Er0udbCCnoDerkEVgyGZq1gUmLwMvX7EQA5JfmszJpJWPajyG0aajZcWySW1jGffNjaeLjJX2+haggTS4NpTgXFk8yerbcuRaatjY70R9WJq2koKyA6T2mmx3FJharZvaS7aTlFLHkvkto26KJ2ZGEcApS0BuCpRyW3QVZB+C25RDcxexEf7BYLSzas4j+If3pGdTT7Dg2mbNuL5sOZPLKzb2Jat/K7DhCOA1pcnE0reGbJ+D37+Da1+HiEWYnOsuPKT+Slp/G7T1uNzuKTVbtSOOD6IPcdkkkUwZHmh1HCKciBd3RfnsPYv8Llz4CA+8wO8155ifOJywgjFERo8yOUqtdqbn8ZXk8gzu04m/XucanCSEakhR0R9EaNr0O65+G7jfAlc+bneg8CVkJbE/fzpRuU/D0cO6bihmnSpixIJbWTX14b9oAGdYvRBWkDd0RrFb49ln47V3oPdFY4NnD+QrQwsSF+Hv5c3Pnm82OUqPScisPLNrGycJSvpg5jKAA5+gdJISzkYJub5Yy+HI2xC+FITNh7CtOWczTC9NZd2gdk7pNoplPM7Pj1Oj5NQlsPXyStyb3o1dYC7PjCOG0pKDbU2khLLsTDqyHkc/C5X9ymoFD51q6dykWbWFaN3NW9bHVwt+OsDgmmZlXdGR8v5oWyhJCSEG3l6KTsHgypMTAdW9A1N1mJ6pWcXkxy/YvY2TESCKaR9T+ApNsOZTN86sTGNE1mD+P7Wp2HCGcnhR0e8g7BgtvhqwkmPgJ9LzR7ER/KCm38Pq3+0nNKfrjuWPWH8ix5JB5dAgPLt5uYrqa/fp7FhGt/Hlrcn88ZcEIIWolBf1CZf0OC240FqqYtsyp+plrrXl+dQJLtqRwcXBTFKDRZLdchxfhHMtsy3HyzI5Zrfat/ZkzoQ8tmsgKTkLYQgr6hTgWBwtvAW01FqgIG2B2orMsjElmyZYUHhjRkSfGdQPg57SfmbnxOC8Pf5nrO440OaEQwp6cr/uFqzi0Cf53LXj5wd3rna6YxxzM4oXVCYzqFsLjY860Py/Ys4CgJkGMaz/OxHRCCEeQgl4fe9YYbeYtwuCebyGos9mJzpJ6spAHFm0nsrU/b07u90f788Gcg/yc9jOTu07GWxaiFsLtSEGvq22fwufToW1fuOsbaN7O7ERnKSq1cP+CbZSWW/loehTN/c4U7gV7FuDj4cPErhNNTCiEcBQp6LY6PZR/zcPQcRRM/xL8nWumP601TyyPJ/FYHv+Z0p+OwQF/bMspzmHN72u4vuP1tPJzrtxCCPuQm6K2sFphw1/h13eMofzj3wMvH7NTneeD6IOsiTvKE+O6MrJbyFnblu1fRomlhNu632ZSOiGEo0lBr03qNvjmz5C2zamH8v+wL51/rtvLdX3aMuuKjmdtK7OUsXTvUoa2HUqnwE4mJRRCOJrzVSZnceoErHoAPh4Fualw41wY96pTFvODGfk8vGQH3ds0Z86EPuetrbn+yHrSi9JdZs5zIUT9yBX6ucpLIWYu/DQHyouNecwv/zP4OucEVqeKjbU1vT09+HD6QPx9zv4n1VqzIHEBHVp04NKwS01KKYRoCFLQK9v/Lax/yhjC32UcjH0ZWnes/XUmsVo1jy7dyeGsQhbeM4TwQP/z9tmRvoPErET+eslf8VDO9+lCCGE/UtDBGL6/7iljlsTWnWDaF9D5KrNT1er1Dfv5bm86L47vydCOVS86vSBxAc19mnN9x+sbOJ0QoqE17oJenAfR/4Lf3jdGfI55CQbf75Q9WM71dfwx3vkhiUlREdx+yUVV7pN6KpXvU77nrp530cSrSQMnFEI0tMZZ0K1WYwGKjc9D/gnodxtc+TdoFmp2MpskHs3jT8viGBDZkhdv7HneTdDTFu9djAceTOk2pYETCiHM0PgKeuVuiGFRMHkJhA80O5XNsgtKmbEgluZNvJh720B8vapeCzS/NJ8VB1Ywpv0YQpu6xh8qIcSFcf+CXpgNR3fAsZ2QsgX2r4OAUKMbYp9JTtkNsTplFisPLtpO+qkSPr9/KCHN/ardd1XSKgrKCqSrohCNiE0FXSk1DngL8AQ+1lq/es52VbH9GqAQuFNr3fArJ1Qu3kcrvnKTz2wP7ADD/w8ue9xpuyHW5B9f7+HXg1m8NrEv/SJaVrufxWph4Z6F9A/pT6+gXg2YUAhhploLulLKE3gXuApIBbYqpVZrrRMr7XY10LniawjwfsV3xynMrlS4K4p4zjnFO3wgDL4X2vYzJtNqUn0RdHafx6bwyS+HuWd4B24ZGF7jvj+m/EhafhqPRz3eQOmEEM7Aliv0wUCS1voggFJqKTAeqFzQxwPztdYa+E0p1VIp1VZrfczegReufYWlaQvxovyP58rwojTAh9KAbpQqH0rxwYoH5KUZX3u/sneMBldqsRLUzYvYcj9uXFXzcmwZRRm0a9qOkRGygIUQjYktBT0MSKn0OJXzr76r2icMOKugK6VmADMAIiMj65oVgGbN2hKsAyjyaEahZzMKPQKwKOM/wwPwq/hyN95+HnQNbYa3V+1t/he3vJgbO92Il4f73yIRQpxhy298VZeDuh77oLX+EPgQICoq6rztthh/2Z2Mv+zO+rxUCCHcmi1dPFKBiEqPw4Gj9dhHCCGEA9lS0LcCnZVSHZRSPsBkYPU5+6wGpivDJUCuI9rPhRBCVK/WJhetdblSajawHqPb4jytdYJSambF9rnAWowui0kY3RbvclxkIYQQVbHprpnWei1G0a783NxKP2vgQftGE0IIUReuM0xSCCFEjaSgCyGEm5CCLoQQbkIKuhBCuAll3M804Y2VygCO1PPlQUCmHeM4iuS0L8lpX5LTfhoy40Va6+CqNphW0C+EUipWax1ldo7aSE77kpz2JTntx1kySpOLEEK4CSnoQgjhJly1oH9odgAbSU77kpz2JTntxykyumQbuhBCiPO56hW6EEKIc0hBF0IIN+FyBV0pNU4ptU8plaSUetLsPNVRSh1WSu1SSu1USsWanec0pdQ8pVS6Ump3pedaKaU2KKUOVHwPNDNjRaaqcj6vlEqrOKc7lVLXmJwxQin1g1Jqj1IqQSn1SMXzTnU+a8jpbOfTTym1RSkVV5HzhYrnne18VpfT9PPpUm3oFQtW76fSgtXAlHMWrHYKSqnDQJTW2qkGRCilLgfyMdaA7VXx3BwgW2v9asUfyUCt9V+cMOfzQL7W+t9mZjtNKdUWaKu13q6UagZsA24E7sSJzmcNOW/Fuc6nAppqrfOVUt7AZuAR4Gac63xWl3McJp9PV7tC/2PBaq11KXB6wWphI611NJB9ztPjgU8rfv4U45fdVNXkdCpa62Na6+0VP58C9mCspetU57OGnE5FG/IrHnpXfGmc73xWl9N0rlbQq1uM2hlp4Ful1LaKxbGdWejpFaYqvoeYnKcms5VS8RVNMqY3DZ2mlGoP9AdicOLzeU5OcLLzqZTyVErtBNKBDVprpzyf1eQEk8+nqxV0mxajdhKXaq0HAFcDD1Y0IYgL8z7QEegHHANeMzeOQSkVACwHHtVa55mdpzpV5HS686m1tmit+2GsSzxYKdXL7ExVqSan6efT1Qq6yyxGrbU+WvE9HViJ0VzkrE5UtLOebm9NNzlPlbTWJyp+kazARzjBOa1oQ10OLNJar6h42unOZ1U5nfF8nqa1zgF+xGiXdrrzeVrlnM5wPl2toNuyYLXplFJNK24+oZRqCowBdtf8KlOtBu6o+PkO4EsTs1Tr9C91hZsw+ZxW3Bz7L7BHa/16pU1OdT6ry+mE5zNYKdWy4ucmwGhgL853PqvM6Qzn06V6uQBUdAV6kzMLVv/D5EjnUUpdjHFVDsa6rYudJadSagkwAmO6zxPAc8Aq4HMgEkgGJmqtTb0hWU3OERgfZzVwGLj/dNuqGZRSw4FNwC7AWvH00xjt005zPmvIOQXnOp99MG56emJcbH6utX5RKdUa5zqf1eVcgMnn0+UKuhBCiKq5WpOLEEKIakhBF0IINyEFXQgh3IQUdCGEcBNS0IUQwk1IQRdCCDchBV0IIdzE/wONGAQw8h6NXgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*ripley.g_function(points, support=20))\n", + "plt.plot(gp1.d, gp1.ev)\n", + "plt.plot(gp1.d, gp1.G)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "in the q-q plot the csr function is now a diagonal line which serves to make accessment of departures from csr visually easier." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is obvious that the above $G$ increases very slowly at small distances and the line is below the expected value for a CSR process (green line). We might think that the underlying spatial process is regular point process. However, this visual inspection is not enough for a final conclusion. In [Simulation Envelopes](#Simulation-Envelopes), we are going to demonstrate how to simulate data under CSR many times and construct the $95\\%$ simulation envelope for $G$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $F$ function - \"point-event\" \n", + "\n", + "When the number of events in a point pattern is small, $G$ function is rough (see the $G$ function plot for the 12 size point pattern above). One way to get around this is to turn to $F$ funtion where a given number of randomly distributed points are generated in the domain and the nearest event neighbor distance is calculated for each point. The cumulative distribution of all nearest event neighbor distances is called $F$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fp1 = F(pp, intervals=20) # The default is to randomly generate 100 points.\n", + "fp1.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3de3yPdR/H8dd3v53sYGa2Oc15zmdDdKCYuFWiEsn5VFK6dS6Vyl3q7nSLsIjIIUQkEhVROQxzGMYcxmy2MTY72eH3vf+4FsMw/Lbrt+3zfDz22H7Xde23z6773ruv7/U9KK01Qgghij8HswsQQghhGxLoQghRQkigCyFECSGBLoQQJYQEuhBClBCOZv3gChUq6Bo1apj144UQoljavn37aa21b37nTAv0GjVqEBoaataPF0KIYkkpFXWtc9LlIoQQJYQEuhBClBAS6EIIUUJIoAshRAkhgS6EECXEDQNdKfW1UipeKbX3GueVUmqSUipSKbVbKdXS9mUKIYS4kYK00GcDXa9zvhsQmPsxAph6+2UJIYS4WTcch661/kMpVeM6l/QA5mhjHd7NSqlySqlKWutYG9UohLhJ5zPPs/XUViISI8i25pCZbSUzx0pmtpWsHCuZ2ZrMHCtZucezsq3kyFLaN611jfJYlAZtvfrDms8xbQWtaVmpNe3rPmzzemwxsagKcCLP6+jcY1cFulJqBEYrnmrVqtngRwshcqya3w+e4tsdm4hKCyNZhZNpOQrKCoDWyuQKi57i5v/jdP27lP/77d5z0z8GgCGnI+w20PO7D/n+9lrrECAEICgoSJoDQtyGbdGRfLVtNVvjNpPtfBBlyQBHhbuqQWXLA1RxaUZVtwaUdXXFw8URDxdH3F0c8XB1xMPFYnyd57iTxY7GSGgNmSmQlghpZ4zP6Xm+TjtjfKQn5p47a1yfmQrW7IL/HCd3cHIFiws45n5YnMHR9Yqvna++xuIMFidwcAIHCzg45r52vPTa4YrX/5z3rlkot80WgR4NBOR5XRWIscH7CiHyOJ95nj+jN7Nk/+/sTNhCpooHwMm1PG0qdKRXg/u4q0o7yrmWM7nSG8jOhORoSIqGcycg6Z+PaEhJuBTcOZnXeAMFZbzBzQfcykO5alCxKbh4gLMHOLtf+nzZsX+O5752cgMHO/qPmA3YItBXAKOVUguBtkCS9J8LYRvp2eksiljEj5G/cPDcXjRWtNUZp8xA2lV8kKEtu9Kmaj2UsqNulfRzRjgnnbg6sM+dgJQ4rvpHvEdF8KoK3jWgSstLYe3mA2XKX/7a1cto8Yqr3DDQlVILgI5ABaVUNPA24ASgtZ4GrAL+BUQCacDgwipWiNIi25rNogPL+GLnZFKyE8lJr4JO60grv7YMu+Ne7gmsiIODySGenQmnD0JcOMTtzf0cDimnLr/O4myEtVcABHY2PnsFGMfKBUDZKkY3hrhtBRnl0vcG5zXwjM0qEqIUs1qtzNyxipn7JpOqT5KTVg2/7IEMaHEvPVtUwdvdueiL0hrOn7o6uE9HXOqvtjiDb32ofR/41Te6QbyqGaHt7lviujbslWnL5wohLkm9kM0Xf/7GoiNTyXKKRGdWIKjs84y5txfNA8oVbZdK0kk4+gfE7roU4OmJl86XrQr+jaDu/cZn/8bgU9t44CdMJYEuhIlOnktn8sbNrDw+Ezx24WDxpFulUYy7ZxBlXcsUTRFpiXBsIxzZAEc3wJlI47iTO/g1gAYPGqHt3wj8GxoPJIVdkkAXwgQ7jp9l6sZdbExYgGO5zVg8HHmw+kBeu/Np3J3cC/eHZ6bC8b8vBXjsbkAboz+q3wlBQ6BmB/BrKF0lxYwEuhBFJDvHyuq9p/hqUwQH0n7CpcJ6nL0z6Vr9YV5q8yy+bvnuKnb7crLg5PZLAX5iK1izjH7vqm3g3teNAK/SUrpNijkJdCEKWVJ6Fgu3Hmf2X4c5zV+U8V+Hi0cS91TpyAtB/6ZWuVq2/6EZybBvOexfAVF/GZNuUFCpGbQbZQR4tXbg7Gb7ny1MI4EuRCE5ejqVWX8eZcn2aDIcjlG++jJcHWJoUqEpLwS9QEt/Gy9Mas2BI79D2AI4sBKyM4wZic36GAFe4y5jLLcosSTQhbAhrTV/HznD15uO8uuBeBwdFEGNjhCRM4vyZXx4qfWndK7W2bajVuL2wa75sHuxMQbctRw07wfN+kLVILCnSUeiUEmgC2EjWTlWXly8i+VhMZR3d+aZjjVJ9/yRRYe+pU3FNnzc4WO8XW00QiQlHvYsgV0L4NRuY32QwC5Ga7xuV5moU0pJoAthA+mZOTwzfwe/HYjn+c6B9Gvny5t/v8afh/6kT70+vNzmZZwcbvOBY1YGHFwNuxbCobWgc6BSc+j2ETR+BNwr2OaXEcWWBLoQtyk5I4ths0PZFpXIf3o2pn19K0N+GUD0+WjeavcWj9V97PZ+wMntsGMuhC+FjCTwrATtRxtdKn4NbPNLiBJBAl2I23Am5QIDZ23lQOx5JvVpQTmfw/T76RUcHRz5qstXBFUMuvU3P7EV1k+Ew7+CYxljgk/zvsYDTlmcSuRDAl2IWxRzLp0nZ24h5lw6IQNacTx7NeN++4zAcoFMum8SlT0q39obn9gG6z8wgtzNBzq/Y0z2cS1r219AlDgS6ELcgiMJKfSfuZXk9CxmDmrOypjPWXlkJcHVg5lw5wTcnG5hfPeJbbBhIkSuuxTkrYcZa3oLUQAS6ELcpPCYJAZ+vRWtYcrAOkzZ/wJ7Tu/hmebPMLLpyJsfkihBLmxEAl2Im7DtWCJDZm3D09WRNx/1YHzocFKyUvi84+d0qt7p5t5MglzYmAS6EAX0e0Q8T3+7ncpeZRjY5TTjNr+Mr5sv3wZ/S13vugV/o+hQo488cp2xG0/n8dB6uAS5uG0S6EIUwI+7Yvj3d2HUrehOu6DNfLzzFiYLRYcao1Yi10qQi0IhgS7EDSzYepzXl+2hVXVPKtReyKJDG29uslBaIvz8GuxeaAR5p7ehzXBw8Sz84kWpIoEuxHVM23CYiasP0LGeD941FrPu+EZeb/s6fetfd2fGS/Yth59egPSzcM9LcOcYCXJRaCTQhciH1pqP1kQwdf1hHmhaCb8aq1h86BfGthpbsDBPiYdVLxqBXqkZ9F8GFZsUfuGiVJNAF+IKOVbNm8v3Mn/Lcfq1rUalGn8wffd3DG40mMGNB1//m7U2Fs1a/bKxBnmnt6H9c2CRPzVR+OT/ZULkYbVqXlq8i6U7TzKqY20Cqu/k/a3T6FG7B/9u9e/rf3NyDKwcayygVbU19JgCvvWKpnAhkEAX4jIfrYlg6c6TjA2uS2CtSF754wM6BnRkfPvx154wpDXs/BbWvAE5mXD/+9D2KVlvRRQ5CXQhcs3dHMW0DYfp17YarerHM/q312nh14L/3vNfHB2u8ady7jiseM7YKaj6XfDQJPCpXbSFC5FLAl0IYN2+ON5evpdO9f14tH0OI9f9m9petfmi0xe4Orpe/Q1WK4TOhHXjjdfdP4FWQ8DBoUjrFiIvCXRR6u06cY5nF+ykUWUvxnb3YuSvQ/Bx9WFa8DTKOuezwuGZw7DiWYj6E2rfBw/+D8pVK/rChbiCBLoo1Y6fSWPoN9vw8XDm/d5VGbN+GI7KkZDgECqUuWIHIK1hyzRY9w5YnI2Hns37yZ6dwm5IoItS62xqJoNmbSUrRxMyqC5v/D2K1KxUZnWdRUDZgMsvzsqAH5+D3d9B4P3w4OdQ9hbXOxeikEigi1IpIyuH4XNCiT6XzszBTfh418ucPH+S6cHTqV++/uUXn4+D7/pB9Da49w1jxqe0yoUdkkAXpY7Vqnlh0S5Co87yeZ/GzD38LuFnwvms42dXbxkXuwsW9DWm7veeAw17mFO0EAUggS5KnQ9W7+enPbG81q0ufyZN5u/Yv3m3/bvcV+2+yy/ctxyWPWUsqDXkZ2MKvxB2rEBjrJRSXZVSEUqpSKXUq/mc91JK/aiU2qWUCldK3WB+tBDmmP3nUb7aeJQBd1QjweU7fj72M2NbjaVnYM9LF2kNGz6CRQPAvxEM/03CXBQLN2yhK6UswBQgGIgGtimlVmit9+W57Blgn9b6QaWULxChlJqntc4slKqFuAVrwk/xzsp9BDf0x7/6Rqbt/o5BjQZdvj5LVjr8MArCl0LTPsaQRKd8xqELYYcK0kJvA0RqrY/kBvRC4MqORA14KmNutAeQCGTbtFIhbsOO42d5bsFOmlUtxwPt4pi2eyo9avdgbKuxly5KjoFZ3SB8mbEdXM9pEuaiWClIH3oV4ESe19FA2yuumQysAGIAT+BxrbX1yjdSSo0ARgBUqyYTMUTROHY6lWHfhFLRy5XP+9Zj4NpHaFKhyeXrs5zcDgueMFZI7DMf6v/L3KKFuAUFaaHnNz5LX/H6fiAMqAw0ByYrpa6aYqe1DtFaB2mtg3x9fW+6WCFu1pmUCwyatRWtNbMHt2Hewemcu3COcXeMu7Q+y54lMOtf4OgMQ3+RMBfFVkECPRrIO8uiKkZLPK/BwFJtiASOAlcM5hWiaGVk5TBsTiixSRnMGNiaNI7xXcR39KnXh4Y+DY31WH6bAN8PhcotYfjvxkNQIYqpgnS5bAMClVI1gZNAH+CJK645DnQCNiql/IF6wBFbFirEzcixasYs3EnYiXNM7deS5gFl6bfqaXzK+DC6xWjITIVlI2H/j9CiP3T/1GihC1GM3TDQtdbZSqnRwBrAAnyttQ5XSj2Ve34a8B4wWym1B6OL5hWt9elCrFuI65rw0z7WhMfx1gMN6dq4EgsPLCT8TDgf3v0hnhnnYX5viAuH+z+AO56WmZ+iRCjQxCKt9Spg1RXHpuX5OgboYtvShLg1P+w8yaw/jzH4zhoMuasmp9NPM2nHJNpWaks3n2YwuzukJMATiyAw2OxyhbAZmSkqSpQjCSm8sWwPQdW9eeNfDQD4NPRT0nPSeaPRCNQ3Dxph3n8pBLQxuVohbEtW4xclRkZWDqPn78TJ0YFJfVvgaHFg26lt/HjkRwYH9qbm0qchJQ6e/F7CXJRI0kIXJcb7q/azLzaZGQOCqFyuDFk5WUzYPIEqbhUZsW0JJMcaLfNqV06jEKJkkEAXJcLqPbHM+TuKYXfVpHNDfwC+2fcNR5KOMCXNGdfkWHhyCVS7w+RKhSg8Euii2DuRmMbL3++mWVUvXu5qTH+ISYlh+q5pdMq2cE9iDPRbAtXbm1ypEIVLAl0Ua5nZVkYv2AnA5Cda4uxoPBaa+Pe7qOwLvBJ/xhjNUuNOM8sUokjIQ1FRrH38SwS7Tpzjw0eaElDeDYD1h1bwe8yfPJ2UQqXHF0DNu02uUoiiIS10UWz9diCOkD+O0P+O6vyrSSUA0pNO8sGmcdTOyebJ7jOgVgeTqxSi6Eigi2IpNimdFxbtokGlsrzR3RhvTloiIYt7EOOkmdVsLE51OplbpBBFTLpcRLGTnWNlzIIwLmRbmfJEC1ydLJCWyJG53ZntmMFDfq0Jajnc7DKFKHIS6KLY+d+vh9h6LJH3ezahlq8HpJ9Fz3mICSTi5uTO2I7/NbtEIUwhgS6KlU2HTjP590h6B1Xl4RZVIP0czHmYn1Kj2ObqzJigF/Ap42N2mUKYQgJdFBvx5zN4/rsw6vh6MP6hRkaYz+1Jcvw+Pq4UQJMKTXgk8BGzyxTCNBLooljIsWr+/V0YKReymNKvJW5kwrxH4dQevmjdi7PZqYy7YxwWB4vZpQphGgl0USxMXR/Jn5FneOehRtT1dYcfnoLoUMK7vcd3cX9f2oVIiFJMAl3Yva1HE/l07UF6NK9M76AA+H0C7FtOTvA7vBe34dIuREKUchLowq4lpmby3IKdVCvvxn96NkGFzYeNn0DLgSzx8Sf8TDgvBb2Ep7On2aUKYToJdGG3rFbNi4t3kZiayeQnWuIRuxl+HAM1O3D4zmf4dPtntK3Ylm41u5ldqhB2QQJd2K2Zm47y24F4xj3QgMaup+G7J6F8TZJ6TObZDf+mjGMZJtw1ASX7gQoByNR/Yaf2nkziw58P0LVRRfo3KwszOoNyILvPAl7aOoFTqaf4+v6vqehe0exShbAbEujC7litmnE/7KWcmxMfPlwf9V1vSDoBA3/k06NL+Tv2b95t/y7N/ZqbXaoQdkW6XITdWbz9BGEnzvFa1/p4/foSRG2CHl+yPDOOufvm0q9BP3oG9jS7TCHsjrTQhV05l5bJhz9HEFTdm17piyFsHnR4ld2V6vHOz4NoW7EtLwS9YHaZQtglCXRhVz755SDn0jL5rMlp1Lp3oPGjxLcZwvM/9cXfzZ+PO3yMk4OT2WUKYZck0IXd2HsyiXlboni1SSoB65+HgLZceOBTnv/1aVKyUpgePJ1yruXMLlMIuyWBLuyC1ap5a/leGpRJYtjJt8HDH/34PN4N/Yg9p/fwecfPCfQONLtMIeyaBLqwC9/viObg8Rg2+X6KQ+YFGPgjc6NWs+LwCkY1H0Wn6rL7kBA3IoEuTJeUnsV/V4XzTdnpeKUcgSe/56+sRD7Z/gnB1YMZ2XSk2SUKUSxIoAvTffpLBE9nfk0r6zZ44HOifGvx4k99qV2uNhPunICDktG1QhSEBLowVXhMEmwNYbDTGmg3mpSmj/Hcqn5YlIVJ907CzcnN7BKFKDYK1PRRSnVVSkUopSKVUq9e45qOSqkwpVS4UmqDbcsUJZHWmu8XzeUtp7lk1emKtfN4Xtv4GlHJUXzS4ROqelY1u0QhipUbttCVUhZgChAMRAPblFIrtNb78lxTDvgS6Kq1Pq6U8iusgkXJsfrP7TxzdiLny9ai3GMzmbRrKuuj1/Nam9doU6mN2eUJUewUpIXeBojUWh/RWmcCC4EeV1zzBLBUa30cQGsdb9syRUmTnJpGlXWjcHPIpmz/Bfwcu4mv9nzFI4GP0Ld+X7PLE6JYKkigVwFO5HkdnXssr7qAt1JqvVJqu1JqQH5vpJQaoZQKVUqFJiQk3FrFokTYO2cszYggoeN/ibDk8OamN2nh14I32r4hy+EKcYsKEuj5/XXpK147Aq2A7sD9wJtKqbpXfZPWIVrrIK11kK+v700XK0qGE38vpn3cAjb79MKtTTfG/D4GLxcvPu34KU4WmdYvxK0qyCiXaCAgz+uqQEw+15zWWqcCqUqpP4BmwEGbVClKDJ14lPK/jCGc2vj0fpMha4ZwNuMss7vNpkKZCmaXJ0SxVpAW+jYgUClVUynlDPQBVlxxzXLgbqWUo1LKDWgL7LdtqaLYy8rg3DdPkG3VbLtzPM9uGkV8WjzTgqfRyKeR2dUJUezdsIWutc5WSo0G1gAW4GutdbhS6qnc89O01vuVUj8DuwErMENrvbcwCxfFT+aqV/BO2sfL3mPYcW4S6dnpzOgyg8YVGptdmhAlgtL6yu7wohEUFKRDQ0NN+dnCBLsXw9JhTHDozOo6CThaFCHBIdQrX8/syoQoVpRS27XWQfmdkznVovAlRGBd8RyLnAJZWv0krk5OzO46W8JcCBuTqf+icGWmohcNYJOTKxP8NBXdy/H1/TNkFqgQhUBa6KLwaA0rx/L3+WOM9vOivKsfc7t9I2EuRCGRQBeFZ8ccfo9cztMV/XHUlVj80Fz83f3NrkqIEksCXRSO2N2sXj+O5/18ycqoyqQO0/F1l3HmQhQmCXRhexlJLPvhSV7x8YL0anTzeZu7alczuyohSjwJdGFbWjP/+8d5y03jl1MDnfA0r3drbnZVQpQKEujCpmauGsEH2ScJslQhMnI4L3dpgo+Hi9llCVEqSKALm9Ba88WG1/j89Ga6KS/2HnueplV86NtGulqEKCoS6MIm/rf1Q0KOreSRC1DB8yNOp+bwXo/GWBxkKVwhiopMLBK3LeL0fmYemEevlDQG3D2b4IXn6NO6Gs0CypldmhCligS6uG2T17+MZ46VsS3GMPwvR8q6OvLy/TKtX4iiJl0u4raEHVjG+tRjDHGqyG+uPdl6LJFXutbH293Z7NKEKHWkhS5umc5MY9Kf4ynvoHnw/q/oPiOC5gHl6B0UcONvFkLYnLTQxS37e9VotjlaGVG7F1O3pnMm9QITHm6MgzwIFcIUEujiluiINUyK30QlhzI0qvUsc/4+xpNtq9O4ipfZpQlRakmgi5uXEs9vPz9LuIsLT7V+kfd+PIS3mzMvdpEHoUKYSQJd3BytyVn2NF+4W6jhXpms823YHnWWV7vVx8vNyezqhCjVJNDFzdkawqq4vzjs5MiQJmP46OdDtKruzSMtZY1zIcwmgS4KLi6crF/eZIpvJRqUr8/2fVU5m5bJuz0ayYNQIeyABLoomKx0+H4YS73Lc5IsHgwYyrytJxjQrgaNKsuDUCHsgQS6KJh140lP2M/08j608GvBkj898HF3YWyXumZXJoTIJYEubuzQWtgyjYWNgknISqZxmT7sOpHEG93rU9ZVHoQKYS9kpqi4vpR4+OFpzvs1ZGZWLG3927PgD0fa1PDk4eZVzK5OCJGHtNDFtWkNy5+BjGTmNL2fpMwknM93Jzkjm3cfboRS8iBUCHsigS6ubetXcOgXEu97nTlRq2njdy+rd1gY3L4G9SuWNbs6IcQVJNBF/uL2wS/jILALM52zyMjJIPrIPfh6uDCmc6DZ1Qkh8iGBLq6WlQHfDwXXspwKfoeFBxbSyPM+Ik6U4Y3uDfCUB6FC2CV5KCqutm48xO+DfkuYfngxVm1lb3hb2tXy4aFmlc2uTghxDdJCF5c7tA62TIU2IznuX49lh5ZRxXIfaWllebeHPAgVwp5JoItLUhLgh6fBryEEv8uUsClYlBPh+1oz9K6aBPp7ml2hEOI6ChToSqmuSqkIpVSkUurV61zXWimVo5R61HYliiKhNawYDRlJ8MgMIs5HsfroalzSOuDv7stzneRBqBD27oaBrpSyAFOAbkBDoK9SquE1rvsQWGPrIkURCP0aDv4Mwe+AfyMm75yMk4MbMVFtefvBhri7yOMWIexdQVrobYBIrfURrXUmsBDokc91zwLfA/E2rE8UhYSDsOYNqH0ftBlJWHwY66PXk5FwN53q1qBr44pmVyiEKICCBHoV4ESe19G5xy5SSlUBegLTrvdGSqkRSqlQpVRoQkLCzdYqCkN2JiwdBk5loMeXaKWYtHMSjpTFeu4u3pEHoUIUGwUJ9Pz+mvUVrz8HXtFa51zvjbTWIVrrIK11kK+vb0FrFIVp/fsQuwsemgRlK7E5djPbTm0j5VQHnu/UmKrebmZXKIQooIJ0jEYDAXleVwVirrgmCFiY25KrAPxLKZWttf7BJlWKwnFsE2z6HFr0hwYPorXms+3/Q2V7U8ulE0Puqml2hUKIm1CQQN8GBCqlagIngT7AE3kv0Fpf/MtXSs0GVkqY27n0c7B0JJSvCV0nAvD7id/ZnxhORsKjfPBES5wsMqpViOLkhoGutc5WSo3GGL1iAb7WWocrpZ7KPX/dfnNhp356Ac7HwtBfwMUDrTWfh07BmunDo3V70LKat9kVCiFuUoHGommtVwGrrjiWb5BrrQfdflmiUO1eBHuXwL1vQNUgADZEb+To+YM4p/Th1ScbmVygEOJWyL+pS5uzUUbrPKAt3DUWAK017/85CWtmOd66tz9eZWTxLSGKIwn00sSaA8ueMmaF9goBi/EPtNWRfxB7IYJqlgd4uFnADd5ECGGvZPpfafLn53D8L3h4GnjXuHj4P39NQmd58cVDI2TMuRDFmLTQS4uTO+D396FRT2jW5+LhkK2/kMxB7vJ7jDp+8iBUiOJMAr00yEyFpcPBwx8e+AxyW+Fpmdl8GTYdB6snH3UZbnKRQojbJYFeGqx5A84chp7ToMylVvi4n38ix+Ugj9bpT1lXmREqRHEngV7SHVgF22dB+9FQ855Lh08l8/OJuTjjyQt3DDSxQCGErUigl2Tn44w1zis2gfvevHjYatX8+4eVWDwiGNR4AG5O0joXoiSQQC+ptIblo4z+814zwNHl4qkF245zNPsHXC0eDG7ypIlFCiFsSQK9pNr6FUSug+D3wK/+xcPx5zOY+OtvOHnuZ3Dj/ng4e5hYpBDCliTQS6L4A7D2TagTDG0uH70yYeV+csquxc3RnX4N+plUoBCiMEiglzRZGfD9MHB2hx5TLg5RBPjjYAIr9+/E4rmXfg2ewMvFy8RChRC2JjNFS5o1r0PcHuj7HXj6XzyckZXDm8v3Ur7KRhwcXenfsL+JRQohCoO00EuS8GUQOhPajYZ6XS87Nfm3SI6fjyLTdQd96vXB21VmhQpR0kiglxSJR2DFc1AlCDqPv+xUZPx5pv9xmMDALbhYnBnQaIApJQohCpcEekmQfQEWDzb6yx/9GiyXlr/NsWpeX7oXN/ck4vTfPFr3USqUqWBisUKIwiKBXhKsfQtiw6DHl+Bd/bJTH6zaz9ZjiTRvvAOLcmBQo0Hm1CiEKHQS6MXd/pWwZRq0fQoaPHDZqXlbopix6Si97/Bgd9I6egX2wt/d/xpvJIQo7iTQi7OzUcZs0ErNIfjdy05tPJTAW8vDubeeL2UrbgJgaOOhZlQphCgiEujFVXYmLBliTPF/bNZlU/sj488zat4OAv08eLtnAMsOLaVH7R5U8qhkYsFCiMImgV5c/fYunAyFhyZB+VoXD59JucDg2dtwcbQwc1BrFh2aS47OYWgTaZ0LUdJJoBdHB9fAX19A0FBjB6JcF7JzGDl3O/HJF5gxMAhXlzQWRyyme63uBHjKXqFClHQS6MVNUjQsG2ksiXv/+xcPa615ZcluQqPO8mnv5jQPKMc3+77hQs4FhjUZZmLBQoiiIoFenORkwZKhxudHZ4OT68VTk36N5IewGF7sUpfuTStxLuMcCw8spGuNrtT0qmlezUKIIiNruRQnv78PJzYb65tXqHPx8IpdMXy27iC9WlbhmXuN43P3zyU9O53hTWWvUCFKC2mhFxeR62DTp9ByADR97OLh7VFneXHxLtrUKM8HvZqglCI5M5n5++cTXD2YQO9AE4sWQhQlCfTiIDkWlo4Ev4bQ9cOLh08kpjFiTiiVvFyZ1r8VLo4WAObvn09KVgojmo4wq2IhhAkk0O1dTraxvnlWGjw2G5yN/WW4mqsAABASSURBVD+TM7IY+s02snKsfD2oNeXdnQEIiw9j5p6ZdAzoSP3y9a/zxkKIkkb60O3dHx9B1CZ4eCr41gMgO8fK6Pk7OZKQypwhbajta2wjd+jsIUb9Ogo/Nz/GtxtvYtFCCDNIoNuzI+thw0fQ7Alo/gRgDE9858d9/HEwgYm9mtC+jrFy4smUkzy19ilcLa6EdAnBp4yPiYULIcxQoC4XpVRXpVSEUipSKfVqPuf7KaV25378pZRqZvtSS5nzcfD9cKhQF7p/fPHw7L+OMXdzFCPuqUWfNtUAOJN+hpFrR5Kek8604GlU8ahiVtVCCBPdsIWulLIAU4BgIBrYppRaobXel+eyo0AHrfVZpVQ3IARoWxgFlwpZ6bCwL1w4DwOWG/uDAr8diOO9lfsIbujPK12N/vHUrFRG/TqKuNQ4QrqEUNe7rpmVCyFMVJAWehsgUmt9RGudCSwEeuS9QGv9l9b6bO7LzUBV25ZZilitsOwpOLkDHpkB/g0B2B+bzLPzd9KgUln+16c5FgdFZk4mY34bQ0RiBJ90/IQWfi1MLl4IYaaCBHoV4ESe19G5x65lKLA6vxNKqRFKqVClVGhCQkLBqyxNfp8A+34wlsPNXd88/nwGw74JxcPVkZkDW+Pm7EiONYdXN77KllNbeO/O97in6j0mFy6EMFtBAl3lc0zne6FS92IE+iv5nddah2itg7TWQb6+vgWvsrTYOQ82fgItB0L7ZwFIz8xh2DehJKZmMnNgayp6uaK1ZsKWCayNWstLQS/xYO0HTS5cCGEPCjLKJRrIu1RfVSDmyouUUk2BGUA3rfUZ25RXihzbBD+OgZodoPsnoBRWq+b573ay52QSIf2DaFzFC4DJYZNZcnAJw5oMkw2fhRAXFaSFvg0IVErVVEo5A32AFXkvUEpVA5YC/bXWB21fZgl3OhIW9oPyNaH3nIubPE/8+QBrwuMY170hwQ2NrePm7Z9HyO4QHgl8hOdaPGdm1UIIO3PDFrrWOlspNRpYA1iAr7XW4Uqpp3LPTwPeAnyAL5VSANla66DCK7sESUuE+b3BwQJPLIIy5QBjP9CQP44woF11htxZA4CVR1YycetEOlXrxLg7xpF7r4UQAgCldb7d4YUuKChIh4aGmvKz7UZ2Jsx9GKJDYeCPUM0Y6bnhYAJDZm/j7sAKzBgQhKPFgY3RG3nut+do4d+CqZ2n4mJxucGbCyFKIqXU9ms1mGWmqFm0NvrMo/6ER2ZeDPMDp5J5Jnc/0MlPtMTR4kBYfBhj148l0DuQSfdOkjAXQuRLFucyy8ZPYNd86Pg6NHkUgPjkDIbODsXN2cKswa3xcHEk8mwkz/z6DH5ufnzZ+Us8nD1MLlwIYa+khW6GvUvht/eg6ePQ4WUA0jKzGTbHGJ64+Kl2VPIqQ0xKDCPXjcTF4sL04OlUKFPB5MKFEPZMAr2oRYfCD09DtXbw0BegFDlWzb+/C7tseGJiRqKxPkt2OrO7zqaqp0y+FUJcnwR6UTobBQv6gGdFeHweOBp94RNX72dNeBxvPWAMT0zNSmXUulHEpsYSEizrswghCkYCvahkJMH8x42RLYNWgbuxvO23m6P4auNRBrSrzuA7a1xcn+VA4gH+d+//aOnf0uTChRDFhQR6UcjJhsWD4cwhePJ78DVa3BsOJvD2inDurefLWw80xKqtF9dn+c9d/6FDQAeTCxdCFCcyyqWwaQ2rX4bDv0L3T6FWR+DS8MS6/p588URLLA6K/2z5D2uj1vJi0Is8VPshU8sWQhQ/EuiFbfOXEDoT7hwDrQYCxvDEIbO24e5i4etBQXi4ODIlbAqLDy5maOOhDGw00OSihRDFkXS5FBatYdNn8Os70OAh6DQeuDQ88Wxa1sXhifP2z2P67un0CuzFmJZjzK1bCFFsSaAXBqsVfhkHm6dAk8eMDZ4dHMixasYsNIYnfpU7PPGnIz8xcetE7gu4jzfveFPWZxFC3DIJdFvLyYLlo2H3Qmj7FNz/ATgYPVsfrNrP2n1xvP1gQzo39GfTyU2M2zSOIP8gPurwEY4O8j+HEOLWSYLYUmYaLB4Eh9bAvePgnhdBKbTWTN1wmBmbjjKwXXUG31nz4vosdbzrMOk+WZ9FCHH7JNBtJf0szO8DJ7bAA59B0BAAMrJyeH3pHpbuPMkDTSvx5gMNL67PUqFMBaZ2noqns6fJxQshSgIJdFtIjoVve8GZSHhsNjR6GIC45AxGzN3OrhPnGBtcl2fvq0Nsaiwj143E2eIs67MIIWxKAv12nTlsrGmelgj9Fl8cZ77z+FlGzt1O6oVspvdvxf2NKl5anyUrnVldZxHgGXDdtxZCiJshgX47YnfBt4+AthobVFQxpul/vz2a15btwb+sC3OH3km9ip5Xrc9Sr3w9k4sXQpQ0Eui36uhGWNDX2DKu/zKoEEh2jpWJqw8wY9NR2tf2YcoTLfF2dzbWZ/ld1mcRQhQuCfRbsf9HWDIEytcywrxsZZLSshi9YAcbD51mUPsavNG9AU4WB3KsOcb6LLGyPosQonBJoN+s7d/AyuehSitjU2e38kTGn2f4nO1En03jw0ea8HjragCczTjLh9s+lPVZhBBFQgK9oPJO5a/TGXrPAWd3ft0fx5iFYbg6ObBg+B0E1ShPRnYG3+7/lpl7ZpKWncaoZqNkfRYhRKGTQC8IqxXWvgl/Tzam8vf4Em1xYur6SP67JoJGlcsS0j8I/7LOLDu0jMlhk4lPi6dj1Y483+p5aperbfZvIIQoBSTQbyR6O6x+CU5uvziVPz1b88riMFbsiuHBZpX5sFcTQhP+4pkNnxF5LpImFZrw4d0fElQxyOzqhRCliAT6tZyPM7pXwuaBhz88PA2a9SEmKYMRc0MJj0nm5a71uKdRBs+uH8nWU1sJ8Azg4w4f06V6F1lkSwhR5CTQr5SdCVumwYaPIDvDWMf8npfAxZO/Dp/muQU7yciyMrF3ZbYnhzB11Wq8Xbx5rc1rPFb3MZwsTmb/BkKIUkoCPa+Dv8Ca14wp/HW7wv3vo8vXYsPBBKau38uWo4lUq2Cly927mLj3exyVI8ObDGdI4yF4OHuYXb0QopSTQAdj+v7PrxmrJPrUgX5LyK7ViZ/2xDLt203sj03Gv6wD998Zzq7zy/gpKo2edXoyqvko/Nz8zK5eCCGA0h7oGcnwx39h81RwdIUuE8hoOYzFO+MIWbaeE4np1PTT9Ox4iD3nf+KvxDgZuSKEsFulM9CtVmMDinXjISUOmj9JcvvXmLM3nVn/3cSZ1AvUr3GGDg12sufcH6yLy6KVfys+uPsDWldsbXb1QgiRr9IX6HmHIVYJ4vSDs5h2yJsFk/eSmp1Go8BD+Hr8xcm0IySd9+DRuo/Su25v6njXMbtyIYS4rpIf6GmJELMTYsPgxFY4+DN4+BN33+d8cqo5y+bEop33UydwN2fUZo7npNPAtQHDm42nW81uuDm5mf0bCCFEgRQo0JVSXYH/ARZghtZ64hXnVe75fwFpwCCt9Q4b13pjecM7Jvcj6fjF09leNTjV6Ck+TO3Oj6sTKeP9E5Ub7CAx5xCnlQtda3Tl8XqP07hCYxlHLoQodm4Y6EopCzAFCAaigW1KqRVa6315LusGBOZ+tAWm5n4uPGmJZJ7YQXrUdnTMTlwS9lAmNfri6QSnyhyy1GGPy71svVCdbRkBJGe4oxJP4+G7iAoNtnNBp1DWvQbD6r3MQ7UfwsvFq1BLFkKIwlSQFnobIFJrfQRAKbUQ6AHkDfQewByttQY2K6XKKaUqaa1jbV3wtz+9z4KYeTiRffFYFo5keDlzwaseGTiTpZxRDhYsDhdwdIjA4nCQcg4OeDtoEjOjsShHOlS7j8frPU7riq2lNS6EKBEKEuhVgBN5Xkdzdes7v2uqAJcFulJqBDACoFq1ajdbKwCeZSvjf9KDTMeyZDt7oV298HB2xcXRAWcnB1wsDjg4XDug65fvSc86PfF1872lny+EEPaqIIGeXzrqW7gGrXUIEAIQFBR01fmC6HH3IHrcPehWvlUIIUo0hwJcEw3k3c24KhBzC9cIIYQoRAUJ9G1AoFKqplLKGegDrLjimhXAAGW4A0gqjP5zIYQQ13bDLhetdbZSajSwBmPY4tda63Cl1FO556cBqzCGLEZiDFscXHglCyGEyE+BxqFrrVdhhHbeY9PyfK2BZ2xbmhBCiJtRkC4XIYQQxYAEuhBClBAS6EIIUUJIoAshRAmhjOeZJvxgpRKAqFv89grAaRuWU1ikTtuSOm1L6rSdoqyxutY636nupgX67VBKhWqtg8yu40akTtuSOm1L6rQde6lRulyEEKKEkEAXQogSorgGeojZBRSQ1GlbUqdtSZ22Yxc1Fss+dCGEEFcrri10IYQQV5BAF0KIEqLYBbpSqqtSKkIpFamUetXseq5FKXVMKbVHKRWmlAo1u55/KKW+VkrFK6X25jlWXim1Vil1KPezt5k15taUX53jlVInc+9pmFLqXybXGKCU+l0ptV8pFa6UGpN73K7u53XqtLf76aqU2qqU2pVb5zu5x+3tfl6rTtPvZ7HqQ8/dsPogeTasBvpesWG1XVBKHQOCtNZ2NSFCKXUPkIKxB2zj3GMfAYla64m5/5H01lq/Yod1jgdStNYfm1nbP5RSlYBKWusdSilPYDvwMDAIO7qf16mzN/Z1PxXgrrVOUUo5AZuAMUAv7Ot+XqvOrph8P4tbC/3ihtVa60zgnw2rRQFprf8AEq843AP4JvfrbzD+2E11jTrtitY6Vmu9I/fr88B+jL107ep+XqdOu6INKbkvnXI/NPZ3P69Vp+mKW6BfazNqe6SBX5RS23M3x7Zn/v/sMJX72c/keq5ntFJqd26XjOldQ/9QStUAWgBbsOP7eUWdYGf3UyllUUqFAfHAWq21Xd7Pa9QJJt/P4hboBdqM2k7cqbVuCXQDnsntQhC3ZypQG2gOxAKfmFuOQSnlAXwPPK+1Tja7nmvJp067u59a6xytdXOMfYnbKKUam11Tfq5Rp+n3s7gFerHZjFprHZP7OR5YhtFdZK/icvtZ/+lvjTe5nnxpreNy/5CswFfYwT3N7UP9HpintV6ae9ju7md+ddrj/fyH1vocsB6jX9ru7uc/8tZpD/ezuAV6QTasNp1Syj334RNKKXegC7D3+t9lqhXAwNyvBwLLTazlmv75o87VE5Pvae7DsZnAfq31p3lO2dX9vFaddng/fZVS5XK/LgN0Bg5gf/cz3zrt4X4Wq1EuALlDgT7n0obV/zG5pKsopWphtMrB2Ld1vr3UqZRaAHTEWO4zDngb+AFYBFQDjgOPaa1NfSB5jTo7YvxzVgPHgJH/9K2aQSl1F7AR2ANYcw+/jtE/bTf38zp19sW+7mdTjIeeFozG5iKt9btKKR/s635eq865mHw/i12gCyGEyF9x63IRQghxDRLoQghRQkigCyFECSGBLoQQJYQEuhBClBAS6EIIUUJIoAshRAnxf/yMInqm2Ky9AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*ripley.f_function(points, support=20))\n", + "plt.plot(fp1.d, fp1.ev)\n", + "plt.plot(fp1.d, fp1.F)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fp1.plot(qq=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can increase the number of intervals to make $F$ more smooth." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fp1 = F(pp, intervals=50)\n", + "fp1.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fp1.plot(qq=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$F$ function is more smooth than $G$ function. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $J$ function - a combination of \"event-event\" and \"point-event\"\n", + "\n", + "$J$ function is defined as follows:\n", + "\n", + "$$J(d) = \\frac{1-G(d)}{1-F(d)}$$\n", + "\n", + "If $J(d)<1$, the underlying point process is a cluster point process; if $J(d)=1$, the underlying point process is a random point process; otherwise, it is a regular point process." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "jp1 = J(pp, intervals=20)\n", + "jp1.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:631: UserWarning: requested 20 bins to evaluate the J function, butit reaches infinity at d=23.695060093892685, meaning only13 bins will be used to characterize the J function.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*ripley.j_function(points, support=20), marker='x')\n", + "plt.plot(jp1.d, jp1.ev)\n", + "plt.plot(jp1.d, jp1.j, marker='+')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the above figure, we can observe that $J$ function is obviously above the $J(d)=1$ horizontal line. It is approaching infinity with nearest neighbor distance increasing. We might tend to conclude that the underlying point process is a regular one." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interevent Distance Functions\n", + "\n", + "Nearest neighbor distance functions consider only the nearest neighbor distances, \"event-event\", \"point-event\" or the combination. Thus, distances to higer order neighbors are ignored, which might reveal important information regarding the point process. Interevent distance functions, including $K$ and $L$ functions, are proposed to consider distances between all pairs of event points. Similar to $G$, $F$ and $J$ functions, $K$ and $L$ functions are also cumulative distribution function.\n", + "\n", + "#### $K$ function - \"interevent\"\n", + "\n", + "Given distance $d$, $K(d)$ is defined as:\n", + "$$K(d) = \\frac{\\sum_{i=1}^n \\sum_{j=1}^n \\psi_{ij}(d)}{n \\hat{\\lambda}}$$\n", + "\n", + "where\n", + "$$ \n", + "\\psi_{ij}(d) =\n", + " \\begin{cases}\n", + " 1 & \\quad \\text{if } d_{ij}\\pi d^2$ indicates that the underlying point process is a cluster point process. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kp1 = K(pp)\n", + "kp1.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*ripley.k_function(points, support=20))\n", + "plt.plot(kp1.d, kp1.ev)\n", + "plt.plot(kp1.d, kp1.k)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $L$ function - \"interevent\"\n", + "\n", + "$L$ function is a scaled version of $K$ function, defined as:\n", + "$$L(d) = \\sqrt{\\frac{K(d)}{\\pi}}-d$$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lp1 = L(pp)\n", + "lp1.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*ripley.l_function(points, support=20, linearized=True))\n", + "plt.plot(lp1.d, lp1.l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulation Envelopes\n", + "\n", + "A [Simulation envelope](http://www.esajournals.org/doi/pdf/10.1890/13-2042.1) is a computer intensive technique for inferring whether an observed pattern significantly deviates from what would be expected under a specific process. Here, we always use CSR as the benchmark. In order to construct a simulation envelope for a given function, we need to simulate CSR a lot of times, say $1000$ times. Then, we can calculate the function for each simulated point pattern. For every distance $d$, we sort the function values of the $1000$ simulated point patterns. Given a confidence level, say $95\\%$, we can acquire the $25$th and $975$th value for every distance $d$. Thus, a simulation envelope is constructed. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Envelope for G function\n", + "\n", + "**Genv** class in pysal." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "realizations = PoissonPointProcess(pp.window, pp.n, 100, asPP=True) # simulate CSR 100 times\n", + "genv = Genv(pp, intervals=20, realizations=realizations) # call Genv to generate simulation envelope\n", + "genv" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. ],\n", + " [ 1.73156208, 0. ],\n", + " [ 3.46312417, 0. ],\n", + " [ 5.19468625, 0. ],\n", + " [ 6.92624834, 0. ],\n", + " [ 8.65781042, 0. ],\n", + " [10.3893725 , 0.16666667],\n", + " [12.12093459, 0.16666667],\n", + " [13.85249667, 0.16666667],\n", + " [15.58405875, 0.16666667],\n", + " [17.31562084, 0.25 ],\n", + " [19.04718292, 0.25 ],\n", + " [20.77874501, 0.25 ],\n", + " [22.51030709, 0.58333333],\n", + " [24.24186917, 0.58333333],\n", + " [25.97343126, 0.83333333],\n", + " [27.70499334, 0.83333333],\n", + " [29.43655542, 0.83333333],\n", + " [31.16811751, 0.91666667],\n", + " [32.89967959, 0.91666667],\n", + " [34.63124168, 1. ],\n", + " [36.36280376, 1. ]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genv.observed " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "genv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above figure, **LB** and **UB** comprise the simulation envelope. **CSR** is the mean function calculated from the simulated data. **G** is the function estimated from the observed point pattern. It is well below the simulation envelope. We can infer that the underlying point process is a regular one." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Envelope for F function\n", + "\n", + "**Fenv** class in pysal." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fenv = Fenv(pp, intervals=20, realizations=realizations)\n", + "fenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Envelope for J function\n", + "\n", + "**Jenv** class in pysal." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "jenv = Jenv(pp, intervals=20, realizations=realizations)\n", + "jenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Envelope for K function\n", + "\n", + "**Kenv** class in pysal." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kenv = Kenv(pp, intervals=20, realizations=realizations)\n", + "kenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Envelope for L function\n", + "\n", + "**Lenv** class in pysal." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lenv = Lenv(pp, intervals=20, realizations=realizations)\n", + "lenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CSR Example\n", + "In this example, we are going to generate a point pattern as the \"observed\" point pattern. The data generating process is CSR. Then, we will simulate CSR in the same domain for 100 times and construct a simulation envelope for each function." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "from libpysal.cg import shapely_ext\n", + "from pointpats import Window\n", + "import libpysal as ps\n", + "va = ps.io.open(ps.examples.get_path(\"vautm17n.shp\"))\n", + "polys = [shp for shp in va]\n", + "state = shapely_ext.cascaded_union(polys)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate the point pattern **pp** (size 100) from CSR as the \"observed\" point pattern." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([list([1]), list([1, 2])], dtype=object)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = [[1],[1,2]]\n", + "np.asarray(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 100\n", + "samples = 1\n", + "pp = PoissonPointProcess(Window(state.parts), n, samples, asPP=True)\n", + "pp.realizations[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pp.n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Simulate CSR in the same domian for 100 times which would be used for constructing simulation envelope under the null hypothesis of CSR." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)\n", + "csrs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct the simulation envelope for $G$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "genv = Genv(pp.realizations[0], realizations=csrs)\n", + "genv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the \"observed\" $G$ is well contained by the simulation envelope, we infer that the underlying point process is a random process." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0. , 0.1 , 0.32, 0.52, 0.68, 0.81, 0.87, 0.92, 0.95, 0.96,\n", + " 0.97])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genv.low # lower bound of the simulation envelope for G" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.14, 0.35, 0.54, 0.72, 0.85, 0.92, 0.97, 0.99, 1. , 1. ,\n", + " 1. ])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genv.high # higher bound of the simulation envelope for G" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct the simulation envelope for $F$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fenv = Fenv(pp.realizations[0], realizations=csrs)\n", + "fenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct the simulation envelope for $J$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "jenv = Jenv(pp.realizations[0], realizations=csrs)\n", + "jenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct the simulation envelope for $K$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kenv = Kenv(pp.realizations[0], realizations=csrs)\n", + "kenv.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct the simulation envelope for $L$ function." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lenv = Lenv(pp.realizations[0], realizations=csrs)\n", + "lenv.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:analysis]", + "language": "python", + "name": "conda-env-analysis-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 9dea068eb6ca51153b22ad717ad30065a8bb06e1 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 14:35:03 +0100 Subject: [PATCH 03/67] fix printing for j function --- pointpats/ripley.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 41b1f5a..02ed5f1 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -630,8 +630,9 @@ def j_function( if first_inf < len(hazard_ratio) and isinstance(support, int): warnings.warn( f"requested {support} bins to evaluate the J function, but" - f"it reaches infinity at d={gsupport[first_inf]}, meaning only" - f"{first_inf} bins will be used to characterize the J function." + f" it reaches infinity at d={gsupport[first_inf]:.4f}, meaning only" + f" {first_inf} bins will be used to characterize the J function.", + stacklevel=1, ) return (gsupport[:first_inf], hazard_ratio[:first_inf]) From 5b39a8eeb0ef478b0ab560619eeedfd6db46f63c Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 14:35:28 +0100 Subject: [PATCH 04/67] actually compute two-sided p-values for tests --- pointpats/ripley.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 02ed5f1..2104978 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -796,16 +796,23 @@ def _ripley_test( if keep_replications: replications = numpy.empty((len(observed_support), n_replications)) + pvalues = numpy.ones_like(observed_support) for i_replication in range(n_replications): - random_i = simulate_from(tree.coordinates) + random_i = simulate_from(tree.data) if calltype in ("F", "J"): distances, _ = random_tree(random_i) core_kwargs["distance"] = distances - replications_i = stat_function(random_i, **core_kwargs)[1] + rep_support, replications_i = stat_function(random_i, **core_kwargs)[1] + pvalues += replications_i >= observed_statistic if keep_replications: replications[i] = replications_i + pvalues /= n_replications + 1 + pvalues = numpy.minimum(pvalues, 1 - pvalues) return result_container( - observed_support, statistic, pvalue, replications if keep_replications else None + observed_support, + statistic, + pvalues, + replications if keep_replications else None, ) From 04da4a7134734a4dab613e59b01a1a40846d55c5 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 14:35:44 +0100 Subject: [PATCH 05/67] support keep replication option --- pointpats/ripley.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 2104978..73e35f7 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -962,6 +962,7 @@ def k_test( metric="euclidean", hull=None, edge_correction=None, + keep_replications=False, n_replications=9999, ): """ @@ -1008,6 +1009,7 @@ def l_test( hull=None, edge_correction=None, linearized=False, + keep_replications=False, n_replications=9999, ): """ From cce634651a1c705209619eb00619d59806b998ad Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 16:58:03 +0100 Subject: [PATCH 06/67] force the unimplemented dispatch to error --- pointpats/ripley.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 73e35f7..6edb595 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -74,6 +74,7 @@ def _contains(shape, x, y): Try to use the shape's contains method directly on XY. Does not currently work on anything. """ + raise NotImplementedError() return shape.contains((x, y)) From 4ad5ecea47ad2ff20954164570151488daf50c9e Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 16:59:38 +0100 Subject: [PATCH 07/67] fix shapely dispatching for multipolygons --- pointpats/ripley.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 6edb595..f923838 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -115,17 +115,20 @@ def _(shape: spatial.ConvexHull, x: float, y: float): try: - import shapely + from shapely.geometry.base import BaseGeometry as _BaseGeometry + from shapely.geometry import Point as _ShapelyPoint HAS_SHAPELY = True @_contains.register - def _(shape: shapely.geometry.Polygon, x: float, y: float): + def _( + shape: _BaseGeometry, x: float, y: float, + ): """ If we know we're working with a shapely polygon, then use the contains method & cast input coords to a shapely point """ - return shape.contains(shapely.geometry.Point((x, y))) + return shape.contains(_ShapelyPoint((x, y))) except ModuleNotFoundError: From 93a42c30a2038cc1071d386cc31e8a46e1f6334e Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:01:29 +0100 Subject: [PATCH 08/67] code hygene and force arrays where needed --- pointpats/ripley.py | 70 ++++++++++++++++++++++++--------------------- 1 file changed, 37 insertions(+), 33 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index f923838..12d025a 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -177,6 +177,7 @@ def _build_best_tree(coordinates, metric): 2. sklearn.BallTree if available and metric is complicated 3. scipy.spatial.cKDTree if nothing else """ + coordinates = numpy.asarray(coordinates) tree = spatial.cKDTree try: from sklearn.neighbors import KDTree, BallTree @@ -205,7 +206,9 @@ def _prepare_hull(coordinates, hull): - a shapely shape using alpha_shape_auto """ if (hull is None) or (hull == "bbox"): - return numpy.array([*coordinates.min(axis=0), *coordinates.max(axis=0)]) + return numpy.array( + [*numpy.min(coordinates, axis=0), *numpy.max(coordinates, axis=0)] + ) if isinstance(hull, numpy.ndarray): assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" assert hull.ndim == 1, f"bounding box provided is not shaped correctly! {hull}" @@ -253,7 +256,11 @@ def _prepare(coordinates, support, distances, metric, hull, edge_correction): raise NotImplementedError("Edge correction is not currently implemented.") # cast to coordinate array - coordinates = numpy.asarray(coordinates) + if isinstance(coordinates, TREE_TYPES): + tree = coordinates + coordinates = tree.data + else: + coordinates = numpy.asarray(coordinates) hull = _prepare_hull(coordinates, hull) # evaluate distances @@ -442,9 +449,6 @@ def f_function( edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. """ - if isinstance(coordinates, TREE_TYPES): - tree = coordinates - coordinates = tree.data coordinates, support, distances, metric, hull, _ = _prepare( coordinates, support, distances, metric, hull, edge_correction ) @@ -510,9 +514,6 @@ def g_function( whether or not to conduct edge correction. Not yet implemented. """ - if isinstance(coordinates, (spatial.KDTree, spatial.cKDTree)): - tree = coordinates - coordinates = tree.data coordinates, support, distances, metric, *_ = _prepare( coordinates, support, distances, metric, None, edge_correction ) @@ -537,11 +538,11 @@ def g_function( " `coordinates` to some other point in coordinates." ) elif distances.ndim == 1: - if distance.shape[0] != coordinates.shape[0]: + if distances.shape[0] != coordinates.shape[0]: raise ValueError( f"Distances are not aligned with coordinates! Distance" f" matrix must be (n_coordinates, n_coordinates), but recieved" - f" {distance.shape} instead of ({coordinates.shape[0]},)" + f" {distances.shape} instead of ({coordinates.shape[0]},)" ) else: raise ValueError( @@ -618,6 +619,11 @@ def j_function( edge_correction=edge_correction, ) + if isinstance(support, numpy.ndarray): + if not numpy.allclose(gsupport, support): + gfunction = interpolate.interp1d(gsupport, gstats, fill_value=1) + gstats = gfunction(support) + gsupport = support if not (numpy.allclose(gsupport, fsupport)): ffunction = interpolate.interp1d(fsupport, fstats, fill_value=1) fstats = ffunction(gsupport) @@ -625,30 +631,27 @@ def j_function( with numpy.errstate(invalid="ignore", divide="ignore"): hazard_ratio = (1 - gstats) / (1 - fstats) - both_zero = (gstats == 1) & (fstats == 1) - hazard_ratio[both_zero] = 1 - is_inf = numpy.isinf(hazard_ratio) - first_inf = is_inf.argmax() - if not is_inf.any(): - first_inf = len(hazard_ratio) - if first_inf < len(hazard_ratio) and isinstance(support, int): - warnings.warn( - f"requested {support} bins to evaluate the J function, but" - f" it reaches infinity at d={gsupport[first_inf]:.4f}, meaning only" - f" {first_inf} bins will be used to characterize the J function.", - stacklevel=1, - ) - + if truncate: + both_zero = (gstats == 1) & (fstats == 1) + hazard_ratio[both_zero] = 1 + is_inf = numpy.isinf(hazard_ratio) + first_inf = is_inf.argmax() + if not is_inf.any(): + first_inf = len(hazard_ratio) + if first_inf < len(hazard_ratio) and isinstance(support, int): + warnings.warn( + f"requested {support} bins to evaluate the J function, but" + f" it reaches infinity at d={gsupport[first_inf]:.4f}, meaning only" + f" {first_inf} bins will be used to characterize the J function.", + stacklevel=1, + ) + else: + first_inf = len(gsupport) + 1 return (gsupport[:first_inf], hazard_ratio[:first_inf]) def k_function( - coordinates, - support=None, - distances=None, - metric="euclidean", - hull=None, - edge_correction=None, + coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, ): """ coordinates : numpy.ndarray, (n,2) @@ -668,7 +671,7 @@ def k_function( whether or not to conduct edge correction. Not yet implemented. """ coordinates, support, distances, metric, hull, edge_correction = _prepare( - coordinates, support, distances, metric, hull, edge_correction + coordinates, support, distances, metric, None, edge_correction ) n = coordinates.shape[0] upper_tri_n = n * (n - 1) * 0.5 @@ -678,7 +681,7 @@ def k_function( raise ValueError( f"Shape of inputted distances is not square, nor is the upper triangular" f" matrix matching the number of input points. The shape of the input matrix" - f" is {distance.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + f" is {distances.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" ) upper_tri_distances = distances elif distances.shape[0] == distances.shape[1] == n: @@ -687,7 +690,7 @@ def k_function( raise ValueError( f"Shape of inputted distances is not square, nor is the upper triangular" f" matrix matching the number of input points. The shape of the input matrix" - f" is {distance.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + f" is {distances.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" ) else: upper_tri_distances = spatial.distance.pdist(coordinates, metric=metric) @@ -1047,6 +1050,7 @@ def l_test( metric=metric, hull=hull, edge_correction=edge_correction, + linearized=linearized, keep_replications=keep_replications, n_replications=n_replications, ) From b433b3dad077872f781c54ef2a372923a6c22a7b Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:03:05 +0100 Subject: [PATCH 09/67] move to k_neighbors where possible --- pointpats/ripley.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 12d025a..2458c42 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -287,7 +287,7 @@ def _prepare(coordinates, support, distances, metric, hull, edge_correction): if isinstance(support, int): # if just n_steps, use the max nnd # this is O(n log n) for kdtrees & balltrees tmp_tree = _build_best_tree(coordinates, metric=metric) - max_dist = tmp_tree.query(coordinates, k=2)[0].max() + max_dist = _k_neighbors(tmp_tree, coordinates, 1)[0].max() support = numpy.linspace(0, max_dist, num=support) # otherwise, we need to build it using (start, stop, step) semantics elif isinstance(support, tuple): From 371369a07ba6f4d05ff72d4961d3e232bc1b873f Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:03:30 +0100 Subject: [PATCH 10/67] force integer n_observations --- pointpats/ripley.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 2458c42..af382a1 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -378,10 +378,9 @@ def simulate(hull, intensity=None, size=None): f" to the number of replications." f" Recieved: `intensity={intensity}, size={size}`" ) - elif intensity is not None and isinstance(size, int): # assume int size with specified intensity means n_replications at x intensity - n_observations = intensity * _area(hull) + n_observations = int(intensity * _area(hull)) n_replications = size else: raise ValueError( From bd7a135f19cfaefd1f36fc9d982aed421d00e4d2 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:04:04 +0100 Subject: [PATCH 11/67] fix bugs in simulate and argpassing --- pointpats/ripley.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index af382a1..919e11e 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -404,7 +404,7 @@ def simulate(hull, intensity=None, size=None): ) if _contains(hull, x, y): result[i_replication, i_observation] = (x, y) - i_observation += 1 + i_observation += 1 return result.squeeze() @@ -415,9 +415,22 @@ def simulate_from(coordinates, hull=None, size=None): Note: will always assume the implicit intensity of the process. """ - n_observations = coordinates.shape[0] + if isinstance(size, int): + n_observations = coordinates.shape[0] + n_replications = size + elif isinstance(size, tuple): + assert len(size) == 2, ( + f"`size` argument must be either an integer denoting the number" + f" of replications or a tuple containing " + f" (n_simulated_observations, n_replications). Instead, recieved" + f" a tuple of length {len(size)}: {size}" + ) + n_observations, n_replications = size + elif size is None: + n_observations = coordinates.shape[0] + n_replications = 1 hull = _prepare_hull(coordinates, hull) - return simulate(hull, intensity=None, size=(n_observations, size)) + return simulate(hull, intensity=None, size=(n_observations, n_replications)) ### Ripley's functions @@ -452,7 +465,7 @@ def f_function( coordinates, support, distances, metric, hull, edge_correction ) if distances is not None: - n_observations = coordinates.shape[0] + n = coordinates.shape[0] if distances.ndim == 2: k, p = distances.shape if k == p == n: @@ -487,6 +500,7 @@ def f_function( tree = _build_best_tree(coordinates, metric) finally: distances, _ = tree.query(randoms, k=1) + distances = distances.squeeze() counts, bins = numpy.histogram(distances, bins=support) fracs = numpy.cumsum(counts) / counts.sum() @@ -573,6 +587,7 @@ def j_function( metric="euclidean", hull=None, edge_correction=None, + truncate=True, ): """ coordinates : numpy.ndarray, (n,2) @@ -592,7 +607,7 @@ def j_function( the hull used to construct a random sample pattern for the f function. edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - trucnate: bool (default: True) + truncate: bool (default: True) whether or not to truncate the results when the F function reaches one. If the F function is one but the G function is less than one, this function will return numpy.nan values. @@ -705,7 +720,6 @@ def l_function( permutations=9999, distances=None, metric="euclidean", - hull=None, edge_correction=None, linearized=False, ): @@ -736,7 +750,6 @@ def l_function( support=support, distances=distances, metric=metric, - hull=hull, edge_correction=edge_correction, ) From c40fd0485cc9698f84a802df57f96f065dec5402 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:04:24 +0100 Subject: [PATCH 12/67] finalize internal logic/changes for ripley_test --- pointpats/ripley.py | 49 +++++++++++++++++++++++++++------------------ 1 file changed, 30 insertions(+), 19 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 919e11e..3cd4359 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -795,18 +795,21 @@ def _ripley_test( n_replications=9999, **kwargs, ): - stat_function, result_container = dispatch.get(calltype) - core_kwargs = dict( - support=None, metric="euclidean", hull=None, edge_correction=None, - ) - tree = _build_best_tree(coordinates, metric=metric) # amortize this - hull = _prepare_hull(tree.data, hull) # and this over replications - core_kwargs["hull"] = hull - - if calltype in ("F", "J"): - random = simulate_from(coordinates) - distances, _ = tree.query(random) - random_tree = _build_best_tree(random) + stat_function, result_container = _ripley_dispatch.get(calltype) + core_kwargs = dict(support=None, metric="euclidean", edge_correction=None,) + tree = _build_best_tree(coordinates, metric=metric) + + if calltype in ("F", "J"): # these require simulations + core_kwargs["hull"] = hull + # amortize to avoid doing this every time + empty_space_points = simulate_from(coordinates, size=(1000, 1)) + empty_space_distances, _ = _k_neighbors(tree, empty_space_points, k=1) + if calltype == "F": + distances = empty_space_distances.squeeze() + else: # calltype == 'J': + n_distances, _ = _k_neighbors(tree, coordinates, k=1) + distances = (n_distances.squeeze(), empty_space_distances.squeeze()) + core_kwargs.update(**kwargs) observed_support, observed_statistic = stat_function( tree, distances=distances, **core_kwargs @@ -814,24 +817,32 @@ def _ripley_test( core_kwargs["support"] = observed_support if keep_replications: - replications = numpy.empty((len(observed_support), n_replications)) + replications = numpy.empty((len(observed_support), n_replications)).T pvalues = numpy.ones_like(observed_support) for i_replication in range(n_replications): random_i = simulate_from(tree.data) if calltype in ("F", "J"): - distances, _ = random_tree(random_i) - core_kwargs["distance"] = distances - rep_support, replications_i = stat_function(random_i, **core_kwargs)[1] + random_tree = _build_best_tree(random_i, metric) + empty_distances, _ = random_tree.query(empty_space_points, k=1) + if calltype == "F": + core_kwargs["distances"] = empty_distances.squeeze() + else: # calltype == 'J': + n_distances, _ = _k_neighbors(random_tree, random_i, k=1) + core_kwargs["distances"] = ( + n_distances.squeeze(), + empty_distances.squeeze(), + ) + rep_support, replications_i = stat_function(random_i, **core_kwargs) pvalues += replications_i >= observed_statistic if keep_replications: - replications[i] = replications_i + replications[i_replication] = replications_i pvalues /= n_replications + 1 pvalues = numpy.minimum(pvalues, 1 - pvalues) return result_container( observed_support, - statistic, + observed_statistic, pvalues, - replications if keep_replications else None, + replications.T if keep_replications else None, ) From 1723baee798eb21d4110127a940a2a8e9aeb59f6 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sun, 10 May 2020 17:05:04 +0100 Subject: [PATCH 13/67] add further update of notebook --- .../distance_statistics-numpy-oriented.ipynb | 701 +++++++++++++----- 1 file changed, 510 insertions(+), 191 deletions(-) diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb index ab88b54..e6a4112 100644 --- a/notebooks/distance_statistics-numpy-oriented.ipynb +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -60,10 +60,10 @@ "metadata": {}, "outputs": [], "source": [ - "points = [[66.22, 32.54], [22.52, 22.39], [31.01, 81.21],\n", - " [9.47, 31.02], [30.78, 60.10], [75.21, 58.93],\n", - " [79.26, 7.68], [8.23, 39.93], [98.73, 77.17],\n", - " [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]]\n", + "points = np.array([[66.22, 32.54], [22.52, 22.39], [31.01, 81.21],\n", + " [9.47, 31.02], [30.78, 60.10], [75.21, 58.93],\n", + " [79.26, 7.68], [8.23, 39.93], [98.73, 77.17],\n", + " [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]])\n", "pp = PointPattern(points)\n", "kdt = spatial.KDTree(points)" ] @@ -141,7 +141,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 5, @@ -150,7 +150,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -162,9 +162,9 @@ } ], "source": [ - "plt.plot(*ripley.g_function(points, support=20))\n", + "plt.plot(*ripley.g_function(points, support=20), marker='x')\n", "plt.plot(gp1.d, gp1.ev)\n", - "plt.plot(gp1.d, gp1.G)" + "plt.plot(gp1.d, gp1.G, marker='+')" ] }, { @@ -194,23 +194,9 @@ "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fp1 = F(pp, intervals=20) # The default is to randomly generate 100 points.\n", - "fp1.plot()" + "fp1 = F(pp, intervals=20) # The default is to randomly generate 100 points." ] }, { @@ -221,7 +207,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 7, @@ -230,7 +216,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -242,90 +228,9 @@ } ], "source": [ - "plt.plot(*ripley.f_function(points, support=20))\n", + "plt.plot(*ripley.f_function(points, support=20), marker='x')\n", "plt.plot(fp1.d, fp1.ev)\n", - "plt.plot(fp1.d, fp1.F)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fp1.plot(qq=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can increase the number of intervals to make $F$ more smooth." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fp1 = F(pp, intervals=50)\n", - "fp1.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fp1.plot(qq=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$F$ function is more smooth than $G$ function. " + "plt.plot(fp1.d, fp1.F, marker='+')" ] }, { @@ -343,53 +248,39 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "jp1 = J(pp, intervals=20)\n", - "jp1.plot()" + "jp1 = J(pp, intervals=20)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:631: UserWarning: requested 20 bins to evaluate the J function, butit reaches infinity at d=23.695060093892685, meaning only13 bins will be used to characterize the J function.\n", + "/Users/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:656: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -442,12 +333,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -459,28 +350,28 @@ } ], "source": [ - "kp1 = K(pp)\n", + "kp1 = K(pp, intervals=20)\n", "kp1.plot()" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 17, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -509,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -532,16 +423,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 23, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -583,16 +474,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -605,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -635,7 +526,7 @@ " [36.36280376, 1. ]])" ] }, - "execution_count": 24, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -646,12 +537,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -673,6 +564,75 @@ "In the above figure, **LB** and **UB** comprise the simulation envelope. **CSR** is the mean function calculated from the simulated data. **G** is the function estimated from the observed point pattern. It is well below the simulation envelope. We can infer that the underlying point process is a regular one." ] }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0. , 0. , 0. , 0. ,\n", + " 0.0952381 , 0.0952381 , 0.0952381 , 0.0952381 , 0.19047619,\n", + " 0.19047619, 0.19047619, 0.28571429, 0.47619048, 0.57142857,\n", + " 0.76190476, 0.85714286, 0.95238095, 0.95238095, 1. ]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3179, 0.1553, 0.0608,\n", + " 0.0189, 0.0252, 0.0058, 0.002 , 0.0014, 0.0084, 0.0102, 0.075 ,\n", + " 0.1346, 0.3083, 0.1204, 0. ]), reference_distribution=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0.2 , 0. , ..., 0. , 0.10526316,\n", + " 0. ],\n", + " ...,\n", + " [0.95833333, 0.95 , 1. , ..., 0.85714286, 1. ,\n", + " 0.95238095],\n", + " [1. , 1. , 1. , ..., 0.95238095, 1. ,\n", + " 0.95238095],\n", + " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ]]))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g_test = ripley.g_test(points, keep_replications=True)\n", + "g_test" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.fill_between(g_test.support, \n", + " *np.percentile(g_test.reference_distribution, \n", + " q=(2.5, 97.5), axis=1),\n", + " color='grey', alpha=.2, label='95% CI')\n", + "plt.plot(g_test.support, g_test.statistic, color='orangered', label='Observed')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -684,12 +644,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -705,6 +665,75 @@ "fenv.plot()" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0.01 , 0.045, 0.103, 0.193, 0.297, 0.41 , 0.521, 0.646,\n", + " 0.775, 0.869, 0.931, 0.971, 0.997, 1. , 1. , 1. , 1. ,\n", + " 1. , 1. ]), pvalue=array([0. , 0.0409, 0.013 , 0.0082, 0.0718, 0.1941, 0.3569, 0.4831,\n", + " 0.2651, 0.0693, 0.0267, 0.0136, 0.008 , 0.002 , 0.0042, 0.0211,\n", + " 0.0604, 0.1262, 0.2283, 0. ]), reference_distribution=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0.01003009, 0.01484624, 0.015 , ..., 0.01778243, 0.0167364 ,\n", + " 0.0079096 ],\n", + " [0.05616851, 0.05408271, 0.068 , ..., 0.07217573, 0.06276151,\n", + " 0.0519774 ],\n", + " ...,\n", + " [0.98996991, 0.95015907, 0.998 , ..., 0.95711297, 0.96025105,\n", + " 0.96497175],\n", + " [0.99498495, 0.97348887, 1. , ..., 0.9832636 , 0.98221757,\n", + " 0.98418079],\n", + " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ]]))" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f_test = ripley.f_test(points, keep_replications=True)\n", + "f_test" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.fill_between(f_test.support, \n", + " *np.percentile(f_test.reference_distribution, \n", + " q=(2.5, 97.5), axis=1),\n", + " color='grey', alpha=.2, label='95% CI')\n", + "plt.plot(f_test.support, f_test.statistic, color='orangered',\n", + " label='Observed')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -716,12 +745,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -737,6 +766,75 @@ "jenv.plot()" ] }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "JtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009]), statistic=array([ 1. , 1.00908174, 1.05374078, 1.14810563,\n", + " 1.27226463, 1.27420999, 1.53186275, 1.97472354,\n", + " 2.85388128, 3.86597938, 6.30252101, 12.29508197,\n", + " 26.51515152, 208.33333333]), pvalue=array([0.000e+00, 9.720e-02, 3.000e-01, 4.309e-01, 2.423e-01, 2.479e-01,\n", + " 1.459e-01, 6.450e-02, 1.790e-02, 1.160e-02, 4.300e-03, 1.500e-03,\n", + " 1.000e-03, 1.000e-04]), reference_distribution=array([[1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [1.01425439, 1.01754386, 1.01853871, ..., 1.02073171, 1.01914414,\n", + " 1.01380898],\n", + " [0.74425287, 1.06879607, 1.06864989, ..., 1.08279431, 1.09167672,\n", + " 1.05635492],\n", + " ...,\n", + " [1.15625 , 1.02112676, 2.55890411, ..., 0. , 1.86213992,\n", + " 0. ],\n", + " [2.5 , 2.68518519, 5.49411765, ..., 0. , 4.18981481,\n", + " 0. ],\n", + " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ]]))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "j_test = ripley.j_test(points, keep_replications=True)\n", + "j_test" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.fill_between(j_test.support, \n", + " *np.percentile(j_test.reference_distribution, \n", + " q=(2.5, 97.5), axis=1),\n", + " color='grey', alpha=.2, label='95% CI')\n", + "plt.plot(j_test.support, j_test.statistic, color='orangered',\n", + " label='Observed')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -748,12 +846,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3deZzNZfvA8c81C4Oxb9kNRnZjTZLIWumRSiFbKZEov/I8pKR4qKe9tCHbE8JjrSRLMiqVfSeyjmXsu2GW+/fHfYaDMTOYc77nzLner9e8zjn3ub/ne51jnGvu+3svYoxBKaWUSk2Q0wEopZTyfZoslFJKpUmThVJKqTRpslBKKZUmTRZKKaXSpMlCKaVUmjRZKL8gIj+ISBcPvbYRkXI3eewTIjI/o2NyioiME5GhTsehfI8mC+UxIrJLRJq6PW4nIsdF5J7r1H9FRHaKyBkRiRGRKcnPGWPuM8aM90bc1yMipV2JJcQtronGmOYeOFcjEUlyfRbuP3dm9LmUSo+QtKsodetcrYL3gQeMMb9d5/lOQFNjzN8ichvwDy+H6Wv2G2OKOx2EUqAtC+UFItIdeA9okVKicKkD/GiM+RvAGHPQGDPS7TV+FpGnXfe7isivIvKBiJwQkR0iUt9VvldEDrl3Wbkf63b8L9eJ9QERWS0ip1yvNdjt6WjX7Ynkv/Kvfi1XHMtF5KTrtv5VcQxxxX5aROaLSIF0foxXx3nd1xKReSLy/FX114rIw677FURkgYgcE5GtIvJYKud5RkS2u+rOEZGibs8ZEenj+vyPiMg7IhLk9vxTIrLZ1Zr8UURKucrF9W93yPU5rRORKjfzOSjv0WShPK0nMARoYoxZkUq934HOItJPRGqLSHAar3sHsA7ID0wCvsEmnHJAR2CEiITfRLxngc5AHuABoKeIPOR6rqHrNo8xJtwYs8z9QBHJB3wPfOyK633gexHJ71atA/AkUAjIArx8EzGm9VqTgPZucVUCSrliyQEscNUp5Kr3mYhUvvrFReReYDjwGFAE2I39nN21AWoDNYHWwFOuYx8CXgEeBgoCS4HJrmOaYz/L8tjP+XHg6M19BMpbNFkoT2uGTQTrU6tkjPka6A20AJYAh0SkfyqH7DTGjDXGJAJTgBLAm8aYC8aY+cBFbOK4IcaYn40x640xScaYddgvuBSvsaTgAWCbMea/xpgEY8xkYAvwoFudscaYv4wx54GpQFQqr1fU1XJy/8mRjteaCUQl/yUPPAHMMMZcAFoBu1yfXYIxZhUwHXg0hfM/AYwxxqxyHTsAuFNESrvVedsYc8wYswf4kMtJ6llguDFmszEmARjmFlM8kBOoAIirzoFUPgflAzRZKE/rgf0LcrSISGoVXReLm2L/2uwBvCkiLa5TPdbt/nnX8VeX3XDLQkTuEJHFInJYRE664khvV1FR7F/f7nYDxdweH3S7fy6NGPcbY/Jc9XM2rdcyxpzGtnDauZ5rB0x03S8F3OGegLBJ4ba03o8x5gy2BeD+fvZe9V6Tu6lKAR+5neMYIEAxY8xPwAjgUyBWREaKSK5UPgflAzRZKE87BDQB7gY+S88Bxph4Y8w0bDdTRvRlnwWyuz1O6Ysx2SRgDlDCGJMb+AL7JQeQ1hLN+7Ffku5KAvvSH2qGmQy0d42eygYsdpXvBZZclYDCjTE9U3iNK96Pq1WTnyvfTwm3+yVdxySf59mrzpMt+ZqVMeZjY0wtoDL2j4l+t/yOlUdpslAeZ4zZD9wLtBSRD1Kq47pQ/ICI5BSRIBG5D/tF8kcGhLAGeFhEsoudT9Etlbo5gWPGmDgRqYu9LpDsMJAElLnOsXOB8iLSQURCRORxoBLw3a2/hRs2F/tF/yYwxRiT5Cr/zhVjJxEJdf3UEZGKKbzGJOBJEYkSkazYrqQ/jDG73Or0E5G8IlICeAHbJQg2yQ5IvhYiIrlFpK3rfh1XCy4Um8jjgMSMfPMq42myUF5hjNmLTRiPisjwFKqcwl4Q3QOcAP4D9DTGpDhq6QZ9gL2GEQuM53KXTEqew3Z/nQYGYa8FJL+Hc8C/gV9d3Sv13A80xhzFXhN4Cdtd80+glTHmyE3GXVSunWfxSHoOdF1jmAE0xX7pJ5efxl5gbodtBRwE3gaypvAai4DXsNc0DgBludy1lWw2sBKbkL8HvnIdO9P1ut+IyClgA3Cf65hcwCjgOLbr6ijwbnrel3KO6OZHSqmbISIGiDTGbHc6FuV52rJQSimVJk0WSiml0qTdUEoppdKkLQullFJpyrQLCRYoUMCULl3a6TCUUsqvrFy58ogxpuDV5Zk2WZQuXZoVK1JbikgppdTVROTqVQgA7YZSSimVDposlFJKpUmThVJKqTRl2msWKYmPjycmJoa4uDinQ8lwYWFhFC9enNDQUKdDUUplQgGVLGJiYsiZMyelS5cmjdWy/YoxhqNHjxITE0NERITT4SilMqGA6oaKi4sjf/78mSpRAIgI+fPnz5QtJqWUbwioZAFkukSRLLO+L6WUbwi4ZKGUUpnWzp2QlJR2vZugycLLwsMv76I5d+5cIiMj2bNnj4MRKaUyhUmToGpV+CDF/cVumSYLhyxatIjevXszb948SpYs6XQ4Sil/FRcHPXrAE09AjRrQ7ur9qTKGJgsHLF26lGeeeYbvv/+esmXLOh2OUspfbd8Od94JX34J//oXLF4MxYp55FQBNXTW3RvfbmTT/lMZ+pqViubi9Qcrp1rnwoULtG7dmp9//pkKFSpk6PmVUgFk+nR46ikIDoZvv4VWrTx6Om1ZeFloaCj169fnq6++cjoUpZQ/ungRXnwRHn0UKlSA1as9nijAgy0LESkBTABuA5KAkcaYj0QkHzAFKA3sAh4zxhx3HTMA6AYkAn2MMT+6ymsB44BswFzgBXOLuzal1QLwlKCgIKZOnUrTpk0ZNmwYr7zyiiNxKKX81KBB8NFHNmG8/TZkyeKV03qyZZEAvGSMqQjUA3qJSCWgP7DIGBMJLHI9xvVcO6Ay0BL4TESCXa/1OdAdiHT9tPRg3B6XPXt2vvvuOyZOnKgtDKVU+ly8aG//9S+YPduOevJSogAPJgtjzAFjzCrX/dPAZqAY0BoY76o2HnjIdb818I0x5oIxZiewHagrIkWAXMaYZa7WxAS3Y/xWvnz5mDdvHkOHDmX27NlOh6OU8mVDhkDDhjZh5M0L//iH10PwygVuESkN1AD+AAobYw6ATSgiUshVrRjwu9thMa6yeNf9q8tTOk93bAvEZ4ejnjlz5tL9EiVKsHPnTgejUUr5hcqVISbGYxPu0sPjF7hFJByYDrxojElt+FFK61WYVMqvLTRmpDGmtjGmdsGC1+wKqJRS/mPBAkjupn74YTs8NizMsXA8mixEJBSbKCYaY2a4imNdXUu4bg+5ymOAEm6HFwf2u8qLp1CulFKZ07Bh0KIFfPopJCQ4HQ3gwWQhdmW7r4DNxpj33Z6aA3Rx3e8CzHYrbyciWUUkAnsh+09Xl9VpEannes3ObscopVTm8v33MHCgnYm9dCmE+MZ0OE9GcRfQCVgvImtcZa8AbwFTRaQbsAdoC2CM2SgiU4FN2JFUvYwxia7jenJ56OwPrh+llMpcTpyA7t2hShUYN86ro53S4rFkYYz5hZSvNwA0uc4x/wb+nUL5CqBKxkWnlFI+6KWXIDbWDo31oUQBOoNbKaV8w48/wpgx0K8f1K7tdDTX0GThZQcPHqRdu3aULVuWSpUqcf/99/PXX3/Rp08fqlSpQtWqValTp86lIbWlS5ematWqVKtWjXvuuYfdu3c7/A6UUhnu1Cl45hmoWBFef93paFLkG1dOAoQxhjZt2tClSxe++eYbANasWcOUKVPYv38/69atIygoiJiYGHLkyHHpuMWLF1OgQAFef/11hg4dyqhRo5x6C0opTxg4EPbtg19/dXR4bGq0ZeFFixcvJjQ0lB49elwqi4qKIkeOHBQpUoSgIPvPUbx4cfLmzXvN8XfeeSf79u3zWrxKKS/p29fOo6hXz+lIriugWxaNxjVKs06r8q14uf7Ll+p3jepK16iuHDl3hEenPnpF3Z+7/pzqa23YsIFatWpdU/7YY4/RoEEDli5dSpMmTejYsSM1atS4pt68efN46CG/X+lEKZUsPt4OjS1Txv74MG1Z+IDixYuzdetWhg8fTlBQEE2aNGHRokWXnm/cuDGFChVi4cKFdOjQwcFIlVIZ6v/+D1q3hsTEtOs6LKBbFmm1BFKrXyB7gRs+vnLlyvzvf/9L8bmsWbNy3333cd9991G4cGFmzZpFkyZ2hPHixYvJkSMHXbt2ZdCgQbz//vspvoZSys9ERkJ4uN3AyMdpy8KL7r33Xi5cuHDFBerly5ezZMkS9u+3K5gkJSWxbt06SpUqdcWx2bJl48MPP2TChAkcO3bMq3ErpTykTx8YPtzpKNJFk4UXiQgzZ85kwYIFlC1blsqVKzN48GDWrVvHgw8+SJUqVahWrRohISE8//zz1xxfpEgR2rdvz6effupA9EqpDPPmmzB5stNR3BC5xQ3nfFbt2rXNihUrrijbvHkzFStWdCgiz8vs70+pTOG336BBA+jRAz77zOloriEiK40x18wK1JaFUkp5y/nz8NRTULKk3RLVjwT0BW6llPKqwYNh61aYPx9y5nQ6mhuiLQullPKGP/+Ed9+Fp5+GZs2cjuaGabJQSilPu3ABnnwSihSxCcMPaTeUUkp52tChsGmT3dgod26no7kp2rJQSilPWr3azqXo3Bnuv9/paG6aJgsvCw8Pv6Zs8ODBFCtWjKioKCpUqEDPnj1JSkpyIDqllEc0bgwffOB0FLdEk4WP6Nu3L2vWrGHTpk2sX7+eJUuWOB2SUioj1KgBCxZAvnxOR3JLNFn4mIsXLxIXF5fiEuVKKT/yxx/w3HNw+rTTkWSIwL7A3ahR2nVatYKXX75cv2tX+3PkCDx65RLl/PzzTYfywQcf8PXXX7N7927uu+8+oqKibvq1lFI+YN06+O47u7SHn82pSIm2LHxEcjfUoUOHOHv27KWd9JRSfuTMGfjlF3v/6adhwwYoUMDZmDJIYLcsbrQl4F6/QIFbaklcT2hoKC1btiQ6Opp27dpl+OsrpTxk40Zo2xZiYmD3bsibF3LlcjqqDKMtCx9jjOG3336jbNmyToeilEqvCROgbl04dgxmzbKJIpPRZOFl586do3jx4pd+kjcy+uCDD4iKiqJKlSokJCTw3HPPORypUipN58/b7qYuXaBOHTun4t57nY7KIwK7G8oB15s/MXjwYO8GopS6NX/9Zbud1q2DgQPtIoEhmfcrNfO+M6WU8pSpU6FbN8iaFebOhfvuczoij9NkoZRSN2L/ftvtVKMGTJkCJUo4HZFXaLJQSqn0OHLEjoIsWhQWL4ZatSA01OmovEYvcCulVFo2bIBy5WDiRPu4Xr2AShSgyUIppdJWoQJ07Aj16zsdiWM0WSilVEr27oVHHoFDh+wopxEjICLC6agco8nCy3bt2kWVKlWuKBs8eDDvvvsuXbt2JSIi4tJS5W+88YZDUSoV4ObNsxew58+3XVBKk4Wveeedd1izZg1r1qxh/Pjx7Ny50+mQlAocCQnw6qt2KGzRorByZaadZHejdDSUj4qLiwMgR44cDkeiVIA4cAA6dLBrvnXrBp98AtmyOR2VzwjsZOFDS5Qn69evH0OHDmX79u306dOHQoUK3fJrKqXSsHgxtG8Pp07BuHF2HoW6gnZDeZmIpFqe3A118OBBFi1axG+//ebN8JQKPMOHQ9OmdvG/P//URHEdgd2ycGCJ8vz583P8+PEryo4dO0bEVaMswsPDadSoEb/88gv1A3i4nlIed+YMtGsHX34J4eFOR+OztGXhZeHh4RQpUoRFixYBNlHMmzePBg0aXFEvISGBP/74Q5cqV8oTfv318iZFQ4bA119rokiDx5KFiIwRkUMissGtbLCI7BORNa6f+92eGyAi20Vkq4i0cCuvJSLrXc99LNfrx/EjEyZMYOjQoURFRXHvvffy+uuvX0oK/fr1IyoqimrVqlG1alUefvhhh6NVKpNJTIRnn4UBA8AYCAoC//9a8ThPdkONA0YAE64q/8AY8657gYhUAtoBlYGiwEIRKW+MSQQ+B7oDvwNzgZbADx6M2+MqVarE4sWLrykfN26c94NRKlAcPw5hYXaE06xZULCgJokb4LGWhTEmGjiWzuqtgW+MMReMMTuB7UBdESkC5DLGLDPGGGziecgzESulMq3ly6FmTXjxRfu4XDnIndvZmPyME9csnheRda5uquS9B4sBe93qxLjKirnuX12ulFJpM8Yu03HXXZCUBE895XREfsvbyeJzoCwQBRwA3nOVp9QWNKmUp0hEuovIChFZcfjw4RTr2AZK5pNZ35dSN+3UKXj8cejdG1q0sFue3nGH01H5La8mC2NMrDEm0RiTBIwC6rqeigHcdxApDux3lRdPofx6rz/SGFPbGFO7YMGC1zwfFhbG0aNHM90XqzGGo0ePEhYW5nQoSvmGtWvtfhMzZsDbb8Ps2ZAvn9NR+TWvzrMQkSLGmAOuh22A5JFSc4BJIvI+9gJ3JPCnMSZRRE6LSD3gD6Az8MnNnr948eLExMRwvVaHPwsLC6N48eJpV1QqMzMGRo+2rYn8+e1cqKuGpaub47FkISKTgUZAARGJAV4HGolIFLYraRfwLIAxZqOITAU2AQlAL9dIKICe2JFV2bCjoG56JFRoaOg1k9+UUpnIyJHQowc0a2bnTuhyORlGMluXTLLatWubFStWOB2GUsobkpLsfInTp2HsWOjVC4KDnY7KL4nISmNM7avLdQa3Usq/TZtmRzudOwc5c0KfPpooPECThVLKv+XKZSfbnT3rdCSZmiYLpZT/2bYNxoyx91u0gJ9+sjOylcdoslBK+Zdp0+yw2P794eRJW6bLdnicJgullH+4cMEOiX3sMahcGVas0CU7vEiThVLK9+3aBXffbZfu6NsXliyBkiWdjiqgBPbmR0op3zdnjt29zhg7I7tNG6cjCkjaslBK+ab4ePjnP6F1ayhTBlat0kThIE0WSinfdOQIjBsHzz1nd7YrU8bpiAKadkMppXzLH39AnTpQpAhs2KBLdvgIbVkopXzHihVw553wxRf2sSYKn6EtC6WU8xIT7RIdtWrZxQA7dHA6InUVbVkopZz1889QoQJs2WIn1z39NGTP7nRU6iqaLJRSzkhKgmHDoEkT26pISnI6IpUK7YZSSnnfkSPQqRPMmwft29uup/Bwp6NSqdBkoZS6cRcu2O1Kt2+/srxTJ7vx0J498Oqrdrnw2rVh/Xp4553L9RYvhkOH7IXs7t11bSc/oMlCKXVjdu6Etm1h5UooXfrKL/qmTe3tuXPwyy+XL1QfP24fJytWzO6LXbOm18JWt0aThVIq/WbPtktviMCsWXZ2dUoqVIAdOy4/btjwysfK7+gFbqVU+kyaBA89BJGRdumN6yUKlSlpslBKpc4Ye/vgg/DGG7Y7KSLC2ZiU12myUEpd34IFdmhr8v7WgwZB1qxOR6WuIyEpwWOvrclCKXV9iYlw7BgcPep0JCodRq4cydxtcz3y2poslFJXOnDAXp8AaNnSjnoqUcLZmNR1GWPYc3IPAM/WepYC2Qt45DyaLJRSl/30E9SoAT162IlzYGdXK5907PwxHpn6CLVH1ubw2cMEBwVTt1hdj5xLk4VSyi61MWSInVCXLx8sWwYFPPMXqsoY0bujqf5Fdb776zv6N+hP/uz5PXo+nWehVKA7fBg6doT58+GJJ+ysal16w2clJCUwNHooQ6KHUCZvGZZ1W0atorU8fl5NFkoFsl9+gXbtbJfTyJF2xVddesNn7Tm5h44zOrJ0z1I6V+/MiPtGkDNrTq+cW5OFUoEoKQneew8GDLBLdvz+O0RFOR2VSsWMzTN4es7TxCfF8982/6VjtY5ePb8mC6UC0ZEj8J//QJs2MHo05M7tdEQqFduPbafttLbULFKTyY9Mply+cl6PQZOFUoFk40aoWNFuV7piBZQsqd1OPuzw2cMUzFGQcvnK8cMTP9CodCOyBGdxJBYdDaVUoNi40Q6L/fhj+7hUKU0UPmzJriWU/qg0C3csBKB52eaOJQpIZ8tCRIoD7YC7gaLAeWAD8D3wgzFGt7hSylcZY5NCpUp2T4lOnZyOSKUiPjGe0OBQ6hSrQ9fqXalaqKrTIQHpaFmIyFhgDHAReBtoDzwHLARaAr+ISENPBqmUuklr1tg9I5L3t37hBTuPQvmcUxdOMWDhAKp+XpW4hDiyh2bn0wc+pXB4YadDA9LXsnjPGLMhhfINwAwRyQKUzNiwlFK3xBh74bp3b8ifH06edDoidR2JSYmMXTOWV396ldizsXSq1olz8ecICwlzOrQrpJksrpMo3J+/CGxPrY5SyovOnIGePeHrr+2M7IkToWBBp6NSKVi8czF9f+zL2ti11C9Rnznt53hsuY5blWayEJH1gLne88aYahkakVLq5m3caLc83bIF3nwTXnlF13byQduObqPfgn7M3jqbUrlLMeXRKbSt1Bbx4QEH6emGauW67eW6/a/r9gngXIZHpJS6ORMm2BZFePjlfSiUz/lg2Qf8a+G/yBqSlWH3DqPvnX19rsspJenphtoNICJ3GWPucnuqv4j8CrzpqeCUUunUuzeMGAH33AOTJ0ORIk5HpNwkJCWQkJRAWEgYkfkj6Vy9M0PvHcpt4bc5HVq63cg8ixwi0iD5gYjUB3JkfEhKqRtWvbpdumPhQk0UPubsxbPU+LIG/47+NwCtyrdi9D9G+1WigBtLFt2AT0Vkl4jsBD4DnrpeZREZIyKHRGSDW1k+EVkgIttct3ndnhsgIttFZKuItHArryUi613PfSy+3KmnlDdNnQrffGPvP/00DBsGIboog684fPYwADmy5OD+cvdTp1gdhyO6NelOFsaYlcaY6kA1IMoYE2WMWZXKIeOw8zDc9QcWGWMigUWux4hIJeykv8quYz4TkeSrcp8D3YFI18/Vr6lU4ElKgk8/ha++ssNklc84eu4ofX7oQ4kPSrA+dj0Abzd7m3/c/g+HI7s16ZmU11FELtUzxpwyxpx0e76se/eUW71o4NhVxa2B8a7744GH3Mq/McZcMMbsxA7FrSsiRYBcxphlxhgDTHA7RqnAs3MnHDoEQUEwYwbMnatLdviI+MR4Pvr9IyI/ieTT5Z/yZNSTftfVlJr0tFnzA6tFZCWwEjgMhAHlgHuAI7haCOlQ2BhzAMAYc0BECrnKiwG/u9WLcZXFu+5fXZ4iEemObYVQsqTOE1SZzOzZ0LUrNG0K06bZyXbKccYYvt/2PS/Pf5mtR7fSrEwz3m/xPlUKVXE6tAyVZsvCGPMRUBOYDBQEmrge7wM6GWMeMcZsu8U4UvrTyKRSfr1YRxpjahtjahfUSUgqs4iPh5dfhocegrJl4e23nY5IuWw4tIEWX7fgwckPAvBd++/4seOPmS5RQPom5RU3xsQAC1w/7s89COy5gfPFikgRV6uiCHDIVR4DlHCrVxzY7yovnkK5UoFh7154/HG7J3avXnbDoqxZnY5KARPXTaTzrM7kzpqbj1p+RM/aPQkNDnU6LI9JzwXuRSJS+upCEXkK+PAGzzcH6OK63wWY7VbeTkSyikgE9kL2n64uq9MiUs81Cqqz2zFKZW7z5tklxdevt6OeRozQROGwCwkXiDlle8ablGnCi3e8yPY+2+lzR59MnSggfcmiL7BARCKTC0RkgKv8nusdJCKTgWXA7SISIyLdgLeAZiKyDWjmeowxZiMwFdgEzAN6GWMSXS/VExiNvej9N/DDDb1DpfxNQgK8+ircfz8ULQorV9rWhXKUMYYmE5rw+P8exxjDbeG38V6L98iXLTBW8RWTjmF3ItIE+BI7EulpoA7Qyhhz3LPh3bzatWubFStWOB2GUjdu1Cjo3h26dYNPPoFs2ZyOKKCti11HxQIVCQ0OZebmmeTIkoPmZZs7HZbHiMhKY0ztq8vTNc/CGLMI6Ar8DJQBmvhyolDKL509a2+ffBK++84uMa6JwjHHzh+j53c9ifoiitGrRgPQpmKbTJ0oUpOeeRanReQUtvsnF3Y01CG3cqXUrRo5EipUgNhYOwv7gQecjihgJZkkRq8aTflPyjNy1Uh61+1N+6rtnQ7LcelZSDCnNwJRKqDVq2f3nsihy605acX+FfSa24s/9/1Jg5INGHHfCKrfVt3psHzCjawNpZTKSL/+CgMH2vvVqsGYMXZ5ceV1R88dpcd3Pag7qi67T+xmwkMTiO4arYnCja46ppS3GWPnS/TvD6VL2wl3efOmeZjyjO3HtlNvdD1OxJ3ghTteYHCjweQOy+10WD5Hk4VS3nT8uF2yY84ceOQRuxBgbv1icsKx88fIly0fZfOWpWO1jnSr0Y2qhas6HZbP0m4opbxl+XKoWRN++AE++siu76SJwhGfLf+Msh+X5eCZg4gIH7b8UBNFGrRloZSnGWOXE/+//7MbEy1dCnfc4XRUAScxKZHTF0+TJywPzco0Y8fxHWQPze50WH5DWxZKedLp03b2de/e0KIFrF6ticIBqw6s4o7Rd9B1VlcAIvNH8m7zd8mVNZezgfkRTRZKedrGjXal2NmzIV9gLA3hKy4mXuS1n16j7qi67Du9j8cr26U61I3TbiilMpoxdsvTBx+EnDltayJLFqejCjirDqyi66yurD+0ns7VO/Nhiw/Jm01Hnd0sbVkoldHWr4d27eCLL+xjTRRe5d6aOHLuCN+2/5bxD43XRHGLtGWhVEY5cQLy5LET7BYtgnuuuyiz8hBtTXiOtiyUyghffw2lSsHPP9vH994LwcGOhhSIZm2Zpa0JD9FkodStOH/eLifeqRNERUH58k5HFHBW7l9J9O5oAF5t+Cobn9tIq/KtHI4q89FuKKVu1rZt0LYtrF0LAwbAm2/aFWOV1ySZJJ6a8xTZQrKxrNsysgRnIUs2vUbkCfqbrdTNmDbNbk4UGgrff293tVNes/rAasrlK0fOrDmZ8ugUCucojN15WXmKdkMpdSMuXIA+feCxx6ByZTssVhOF1ySPdKozqjvr4OYAAB2eSURBVA5Do4cCUKFABb024QXaslDqRjzyiG1J9O0Lb72lw2K9xBjDrC2zGPjTQDYf2Uzn6p3p36C/02EFFE0WSt2IF16w3U9t2jgdSUAwxvDD9h94bfFrrDqwitvz38637b/VC9gO0GShVGoSE+3F6zx54JVX7G52yit+2vkTr/70KstilhGRJ4JxrcfxRLUnCAnSry0n6KeuVGqCgmDfPjtE1hjQi6hesfXIVppMaELxXMX54oEveLLGk2QJ1i4/J2myUCol8+dDyZJQoQJMmKAT7Lxg5f6VLN2zlBfrvcjtBWx3U9MyTQkLCXM6NIWOhlLqSomJMGgQtGwJgwfbMk0UXjFl4xSGLR3GqQunAGhVvpUmCh+iyUKpZAcP2msSQ4bYrU/HjHE6okztr6N/0WF6B+b/PR+AgXcPZHuf7brHhI/SbiilwK7p1L49nDxpk8STTzodUaa19+ReXv/5dcavHU9YSBiNSjcCIHeYbjHryzRZqMCWlGTnS7z2GkRG2msVVXUvZk84H3+ed397l+G/DCfJJPHCHS/Qv0F/CuUo5HRoKh00WajAdeSIXQBw3jzbqvjyS7tZkcpQxhhmbpnJS/NfYteJXbSt1JZ3mr1DqTylnA5N3QBNFipwff89/PST3aSoe3cdFusBMadi6DKrCz/t/ImqhaqyuMviS91Oyr9oslCBxRjYsgUqVoTOnaFhQ4iIcDqqTMcYg4iQJywPh88eZsR9I3i29rM6oc6P6WgoFVgGD4Y6dWD3btuS0ESR4aZtnEaDsQ24mHiR8CzhrOmxhl51e2mi8HP6r6cCQ/Ls6+7doVAhO+FOZajk1kTOrDkJDQrl6LmjFMlZhCDRv0kzAzHGOB2DR9SuXdusWLHC6TCU04yBzz6DH3+EmTN1gp0H7D25l34L+lEmbxmGNRkGXE4cyv+IyEpjTO2ryzXlq8zr1Ck7yun55+3M7PPnnY4oUzkff54hS4Zw+4jbmb11NjmzXB5JponCIbNmwenTHnlpTRYqc1q7FmrXhv/9D4YPh2+/hfBwp6PKFI6cO8LwpcOJ/CSSQT8PolX5VmzptYUBdw9wOrTAFRcHPXvapfM/+MAjp9BrFipzMcbOwH7+ecib1w6NbdjQ6agyhXWx6/j4j4+ZuH4icQlxNIlowtcPf61DYZ22Y4fdC37VKvjnP+2S+h6gyUJlHmfPwnPP2VVimzaFiRPtxWx1y3ad2EX1L6qTLSQbnat1ps8dfahcqLLTYSljoGNHmzBmz4Z//MNjp9JkoTKH/fvtIoCbN9vhsa++qhezb9HIlSPZemQr77V4j9J5SjPp4Um0KNeCfNnyOR2aungREhIge3YYOxayZoXSpT16SkeuWYjILhFZLyJrRGSFqyyfiCwQkW2u27xu9QeIyHYR2SoiLZyIWfm4QoWgUiW7ttPrr2uiuEnbjm4jySRdur8mdg0JSQkAtK/aXhOFL0hIgHvvhR497OPbb/d4ogBnL3A3NsZEuQ3R6g8sMsZEAotcjxGRSkA7oDLQEvhMRPSbQNmLev/8J8TGQkgITJtmu5/UDUkySczdNpeWX7ek/IjyLNyxEIDhTYezqPMinUzna0JCoHVraOXdfch9aTRUa2C86/544CG38m+MMReMMTuB7UBdB+JTvubvv+HTT+GHH5yOxC/tObmHt355iwojKvDApAdYF7uOIY2HUOO2GgCaJHxJQoLdA36hTeT06wePPebVEJz6bTDAfBExwJfGmJFAYWPMAQBjzAERSb4yWQz43e3YGFfZNUSkO9AdoKTO0M28Vq6EWrWgcmXYtg2KFnU6Ir9x/Pxxpm2axsT1E4neHQ1A/RL1eaPRGzxS6RHd59oX7d9v5wtFR9sl9R1qPTuVLO4yxux3JYQFIrIllbopze5Jcdq5K+mMBDuD+9bDVD7l4kX7F9XHH18e+aGJIk1JJunSkhv3jLuH9YfWU6FABYY0HkKHqh0ok7eMwxGq61q4EDp0sCP9JkywS+o7xJFkYYzZ77o9JCIzsd1KsSJSxNWqKAIcclWPAUq4HV4c2O/VgJXzdu2Cxx+HP/+EF1+0e2SrNH216iuGRA9hy/NbCAsJ493m71IgewFq3FZDZ1n7ssREGDoU3ngDKlSwOzlWqpSuQz211IrXk4WI5ACCjDGnXfebA28Cc4AuwFuu29muQ+YAk0TkfaAoEAn86e24lYO+/Ra6dLH/gaZPh4cfdjoin2SMYfXB1UxcN5FuNbtRqWAlyuQtQ+OIxpy6cIqwkDCal23udJj+5fBhePllO4/B3bx5kCOHXXds5kxYsMCWv/nm5fvXExZ2Zf3Nm2HyZPu4Tx9YvRqOHrXlnTrB55/bc6XDos2xfLHkbz57ohYFc2a9gTeaNidaFoWBma7MFwJMMsbME5HlwFQR6QbsAdoCGGM2ishUYBOQAPQyxiQ6ELfytvh4GDgQ3nkHatSwo53KlnU6Kp8TeyaWMavHMGHdBLYc2UJoUCjVClejUsFKNI5oTOOIxk6H6J9+/dW2Zo8cgfr1U94cKzgYsrhd5wkJufJxSq6uHxp67fHFitku165d070p18nz8bwycz15s2chd7bQtA+4QbrqrPJNMTHQrp39D9uzJ7z/vv2LTAG2FbEsZhmfLv+UaRunEZ8UT4OSDehYtSNtK7fV+RC3whh47z3o39/OX5g2zf6x4uP6TVvLjNX7mPXcXVQtnvumX+d6q87q2Djlm9q3hzVrYNIke19d8vW6r3lv2XusObiGXFlz0bN2T3rW6UmFAhWcDi1zeOYZ+OoreOQRe5v75r94veXnrYeYtjKG5xqVvaVEkRpNFsp3JCbarqewMLsvdnCwvbin2HF8BxF5IhARlu1dRpJJ4stWX9KhagfCs+hquhmqfXuoVg169/aLfdlPx8UzYMZ6yhUKp0+TSI+dR5OF8g0JCXaEU+nSMHq0nUOhAPj+r+9pNbkV0V2jubvU3bzb/F3CQsJ0NFNGSd4g68QJe42sSRP74yeGzd1C7Kk4pvesT1io5xa30GShfENICDRqZC/sBbjYM7F8tforSuQqQafqnWgc0Zhh9w7j9gK3A5AtNJvDEWZCy5fD8eN20luQLy1skbpftx9h8p976N6wDDVK5k37gFugF7iVc5KS4K237EiTRo2cjsZxaw+u5T+//efSBetnaj7DyAdHOh1W5rV2rR2JVKkSXLhg7/tRojh7IYEWH0aTJTiIuS/cnWGtCt1WVfmWo0ftQmgDB9px6gFsw6ENPDr1UaK+jOK7v76jZ+2ebO61WROFpxhjuzrvuMPOawC7xLcfJQqAt+dtYd+J8/zn0Woe7X5Kpt1QyvuWLbPj12Nj7YSjZ591OiJHbDmyhTeWvMGUDVMIzxLOoIaD6HtnX/KE5XE6tMzr7Fk7FPu//728QZYf+n3HUSYs282Td5WmdmnvDJPWZKG8xxj48EO7rHiJEjZp1KzpdFSO+CPmD+qPqU+2kGwMaDCAl+q/pHMjPG3TJrv96ObNdhmNgQP9ct+T8xcT+df0dZTMl51+LW732nk1WagbM2eOnbB08eKV5dmzw6JF9v6gQbB1K0yZYh/37GnnTJw+DRs3wkMP2d298gTWX9A7ju9g46GNPHj7g9QpVoe3m75Nl+pdKJijoNOh+YfDh6FvX7s0vbv0/O4BrFsH4eF2qQ0/Gu10tXd+3Mruo+eY/Ew9smfx3le4f3XSKefEx9vlB1q3hgMHIFeua3+SZctm/1Mmy5HDPl+sGIwYATNmBFyiAHh5/ss8+92zxCfGEyRBvFz/ZU0U6bV0KURFwf/+Bzlz3vjvXq5cdpLd6tV+nShW7DrG2N920rFeSe4sm9+r59bRUCptR4/a5cB/+w2ee862LHTpjTTtPbmXYUuH0ffOvpTPX56dx3cSFhJGkZxFnA7NfyQl2bXBBg6EiAi79EZUlNNROSIuPpH7P1rKhYQkfuzbkPCsnmlV6HIf6ublzg1588I339gL0ypVMadiePuXtxm5aiTGGOoVr0f5/OWJyBvhdGj+Jy7O7uPw8MN2BJN7KyLAfLDwL3YcOct/u9X1WKJIjSYLlbKEBPsXXbduUKiQXSZcZwxf18EzB5mxeQbTNk1jya4lBAcF81TUUwxsOJCSuXXXxhu2cqVd6iVHDrtDXL58Af37t2bvCUZF76BdnRLcHelM16UmC5Wyv/+2a+1nzw4vvBDQ/1FTM3n9ZEauGsmSXUswGCoWqMigewbRNaorpfOUdjo8/7R/P9x1Fzz/PLz7LuT3bt+8r7mQkEi/aWspnCuMVx6o6FgcmizUlbZssX/R3X47rF8P5co5HZFPOXz2MDO3zKRbjW4EBwWzfP9yYs/EMuieQbSt1JbKhXRNq5sWH29nURctaruemjVzOiKf8Mmi7Ww7dIaxT9YhV1jG71ORXjoaSllJSXYbx8qV7YgT0EThcvDMQY6eOwrAz7t+5tnvnuWPfX8A8FbTt9jUaxODGw3WRHErVq+2v3vJQ2Afe8xeJwtwG/ad5PMlf/NIzeI0vr2Qo7FoslB2/Pr998Nrr9kNh3R/a46eO8rnyz+n8fjGFH2vKCNX2qU3Hij/ABt6bqB+ifoAZAlOY1c0lTpj4Msv4c474dw52+2pALiYkMTL09aSP0cWBrVK3/7bnqTdUIHu119tgjh82P6nfeaZgL0+kZiUyMIdCxmzZgyztsziYuJFKhaoyGsNX+Phinbf7+yh2bUFkVHOnLFLvUyaBC1a2CU4Cuq8k2Sf/bydLQdPM6pzbXJnd677KZkmi0B19daRy5b5xdaRnrDrxC7Grh7L2DVj2XtqL/my5aNn7Z48GfUk1QpX030jPGHDBrv0xl9/2e7PAQP8biE/T9p84BQjftpO66iiNKtU2OlwAE0Wgen4cbsR/Jw5frV1ZEa6mHjxUhfSgEUDmLJhCs3KNuPd5u/S+vbWZA3J6nCEmdeKNz+k6tD+nAvLwTvPfcD6XDXh09+cDsunHDh5njzZQxn8oO+0YnUGdyBq2RJ++snOo+jTJ+C6nRbvXMyj0x5l6ZNLqVSwEtuObiNLcBZK5SnldGiZ2vmLifz+2NM0nj2OteWiGPv8ME7lLuB0WD4pSIRn7o7gjjLeHzasM7gDnTF2ol1oqE0S587Z9fwDwIm4E0xeP5lSeUpxf+T9VClUhRZlWxAkttsjMr/n9i1W1t+Hz9Br4iryhZUjW/se1B77ER9m1cEB/kSTRSBISoIOHewCa6NHQ9WqTkfkcQfPHOTH7T/yw/YfmL11NnEJcTwV9RT3R95PwRwFmfTIJKdDDBgr//M5P89fQWzDx+n/xjPUc3gIqLo5miwCQVCQnWSXI4dtYWTCbqeLiRf5be9vzNs+jx///pE1B+2y1IVzFObJqCfpVqMbNYsE5t4ZTrmQkMjQ7zZT/b/Tue/8Ydp/8yFFC+R0Oix1k/SaRWaVvHVk+fJwzz1OR+MR+07to1iuYgA8OvVRpm+eTkhQCHeVuIuW5VrSslxLqhWudqm7SXnPvlWbGDJjDfMSctOzbhH+7/7KhIbpoAF/oNcsAon71pEdO2aaZHEu/hzBEkzWkKx8tvwzes3txf7/20+RnEV4vu7zdKrWicYRjcmVNXBXJvUFqz4ZR7l+z/NsoVI8PHchzavokuyZgSaLzCalrSP9lDGG9YfWM//v+cz/ez7Ru6OZ+PBEHqn0CM3KNOOjlh9dGuLaqHQjZ4NVxMddYGX7Z6k3azzbSlag8Kxp1NBEkWlosshMvv7azoj1460jD545yMIdC5n/93wW7FjAwTMHAahUsBK96vTi9gJ2z+HI/JE6ismHHNywjRP/eJh6Ozfwx/3tiZo6mqw5dOmOzESTRWZw/rxdRnzUKGjYECZPtit3+gFjDCJCXEIcd35156UL0wWyF6BZmWY0L9ucpmWaUjxXcYcjVdezduRkSvbtQfGEBFb+53Pu6NfD6ZCUB2iy8Hfbttlup7Vr7ZIJb74JIf7xz9r92+6ciDvB1LZTCQsJo3aR2jxe+XGal21O1G1RemHaxyVcuMjyLn24c8qX7ChaltDp06hVLzCXjAkE/vGtkpmdPm33tV63LvV6Dz5o19ABqF0bOnWyrYkdO2DfPvj+e7tyrI8xxvDX0b9YsnsJ0bujWXNwDWt7rCU4KJgyectw5uKZS3VH/WOUg5FeaebqGMb8sov4xCSvnbPJ8nm0jp5BSFLCFeUH8hdlyFP23/7lif/mQmgYnzz2EgBDvuxH/lNHU33dzaUqX1F/e4nbGX//0wB8/F73a853tT8q17+i/qLazZl9z6NUWx3Nf6Z8yZ9NHqbajPGE5Qq/8Tet/IYmC6dlywYHD0KpUhAcfP167qtxRkTYbSbBrta5Ywfk9I3x60kmifWx64neHU30nmiid0dz6OwhwM55aBzRmFMXTpE3W176N+jvcLTXiotP5I1vNzL5z71ULJKLkvk83++e5UIc7b5+hwbRc9hTsjxHC5W4Mqb8hS/FEV/4NpJCs156fP62YpxMY1nvpMKFr6gvhQpeeny6SHGCEhNTPf7q+lkLFaBkvuycbNqSpY0qc/eTbW78TSu/o/MsnGAMjBwJbdrY/a2Tkvx2xc34xHgMhizBWZi+aTpPf/s0J+JOAFAqdykalmp46ScyX6RPr+C688hZnpu4is0HTvFco7L8X7PyhAR7+N9lzx5o1cruSvjqq/D6637TjagyJ51n4Ut27oQXX4TYWBg0yK8Sxbn4c8QlxJEvWz42Hd5E3VF1mdBmAg9XfJjI/JE8WvFR7il9D3eXvNuvFub7ft0B/jV9HSHBwtiudWhcwUtLUuTLB3nywA8/6KZTyqdpsvCmvXuhRAkoUwb++MPn12hKTEpk0+FN/LnvT/uz/0/Wx67nhTte4L0W71EuXzm61ehGRJ4IAKoVruZT1x3S40JCIsPnbmHcb7uoUTIPIzrUpFiebB4+6QW7mGPfvnaY85IlmXIJFpW5aDeUNxhjh7X26QPjxtmd6XzUjM0z+D3md/7c9ycr9q/gbPxZAPKE5aFusbrULVqXFuVa0KBkA4cjvXV7j53j+UmrWBtzkm4NIvhXywpkCfFCK++XX+ys+kmT4PHHPX8+pW6AdkM55cwZ6NEDJk6E5s19bqLcmNVj2HdqH6/d8xoAryx6hZ0ndhJ1WxRPRj3JHcXvoG6xupTLVy5TDWVdsCmWl6auwRj4omMtWla5zfMn3bYNIiOhQQM7w758ec+fU6kMosnCkzZuhEcftVtHDhkCr7zi1esTJ+JOsO3oNrYd23b59tg2Dpw+wO4XdyMi/LrnV7Ye3XopWfzwxA8UzVk00+4UF5+YxLs/buXL6B1ULpqLz56oSan8OTx80ni7fe2HH0J0NNx1lyYK5Xc0WXjK+PF2Mb9cuezSG/fe65HTnL14li1HtlCjSA2CJIixq8cyatUoth3bxpFzRy7VE4QSuUsQmS+SmpE1uZB4gbCQMEY+OJLgoMtDdiPyRngkTl9w4OR5ek9azYrdx+lYrySvPlCJsNBUhitnhL17bVfTsmXw/PN2joxSfshvkoWItAQ+AoKB0caYtxwOKWXnzkHv3jBmDDRqZJfeuO3GujjOXDxD7JlYYs/GcvDMwSvvn40l9kwsX7b6kqqFq/L1uq/p8X0Pdr+4m5K5SxKfFE/WkKy0qdCGyHx2/aTIfJGUzVeWsJCwa87lnigys+i/DvPilDXExSfyUbsoWkcV8/xJ582zq/5evAhTpsBjj3n+nEp5iF8kCxEJBj4FmgExwHIRmWOM2eRsZCno3BmmTyfhlf4c+2dvTiSc4uS+vZyIO8HJCyftbdxJmpZpSvXbqrP1yFb+ufCfDL5nMDWK1GDKhim0m57yBfAC2QtQOEdhCocXJsE167ZFuRZMf2w6ecPyAtC9Vne61+rutbfr6xKTDB8t/ItPFm+nfKGcfPpETcoV8vBM44QEGDwY/v1vqFYNpk3Tbifl9/wiWQB1ge3GmB0AIvIN0BrI8GTxf8PHM/y1rmnWW3J7Gd7pNoYCh7cy7p1nmVGnFmPavkf18ML0zg1nRr0Fo2zjJ7vrx31pv7H3tuTluv0pcGAZb43/gY9bF2V7xXaU/XsDf/0vL0IwQhAiwa77wYAAZ4EdfPbQT/yz/Ckq71jHi/97n5c7vsqOouVosC6aLvPGpBn/8Kvq/6vHexzLlZ8Hls3hoaUz0jz+6vo9XhpNYnAIHRZMoPHqn9I83r1+nS1/0rf3CACem/kxNbatSvXYM9nCr6hf8ORh3ug6BIBX/vsmEQd2XKprjKFVoqFDthAK5QwjaDR218AZrvfYvr2d/T5ypH3cpImdUZ+au+66sv6dd15eiqV6dTh+3HY/desGn3xiZ+kr5ef8JVkUA/a6PY4B7ri6koh0B7oDlCxZ8qZOVKhAHo6Fp31x91zBgkQWDie72PrxhQoTWTgcqtTlrzXfESShBEmI/cHeBrtugySEUiXv41zhcPIFVeZ8REMiitdDCodT/HwFTpdOe/vPAkUKEFk4nELn83GsVFmK3JaX4MLh5C5akGOlyqZ5/NX1SxXORf5c4WQvWjhdx19dv1zhcJKCQwgtVpRjx9I+3r3+qfNl7GcHmOLFOXbxZKrHxmXLcUX9uFzZLz2+UKIUx7JcOWehcK4wbnOfO1HKbbJgRITdbjZZ+fKXl1K5Hvfjy5e/coXfihUhMRHeesvue65UJuEX8yxEpC3QwhjztOtxJ6CuMab39Y7xqXkWSinlJ643z8JfBs7HAO6rqxUH9jsUi1JKBRx/SRbLgUgRiRCRLEA7YI7DMSmlVMDwi2sWxpgEEXke+BE7dHaMMWajw2EppVTA8ItkAWCMmQvMdToOpZQKRP7SDaWUUspBmiyUUkqlSZOFUkqpNGmyUEoplSa/mJR3M0TkMLD7Jg8vABxJs1Zg0c/kSvp5XEs/k2v542dSyhhT8OrCTJssboWIrEhpBmMg08/kSvp5XEs/k2tlps9Eu6GUUkqlSZOFUkqpNGmySNlIpwPwQfqZXEk/j2vpZ3KtTPOZ6DULpZRSadKWhVJKqTRpslBKKZUmTRZuRKSliGwVke0i0t/peHyBiOwSkfUiskZEAnI3KREZIyKHRGSDW1k+EVkgIttct3mdjNHbrvOZDBaRfa7flTUicr+TMXqTiJQQkcUisllENorIC67yTPN7osnCRUSCgU+B+4BKQHsRqeRsVD6jsTEmKrOMF78J44CWV5X1BxYZYyKBRa7HgWQc134mAB+4fleiXCtFB4oE4CVjTEWgHtDL9f2RaX5PNFlcVhfYbozZYYy5CHwDtHY4JuUDjDHRwLGrilsD4133xwMPeTUoh13nMwlYxpgDxphVrvungc1AMTLR74kmi8uKAXvdHse4ygKdAeaLyEoR6e50MD6ksDHmANgvCqCQw/H4iudFZJ2rm8pvu1xuhYiUBmoAf5CJfk80WVwmKZTpuGK4yxhTE9s910tEGjodkPJZnwNlgSjgAPCes+F4n4iEA9OBF40xp5yOJyNpsrgsBijh9rg4sN+hWHyGMWa/6/YQMBPbXacgVkSKALhuDzkcj+OMMbHGmERjTBIwigD7XRGRUGyimGiMmeEqzjS/J5osLlsORIpIhIhkAdoBcxyOyVEikkNEcibfB5oDG1I/KmDMAbq47ncBZjsYi09I/lJ0aUMA/a6IiABfAZuNMe+7PZVpfk90Brcb11C/D4FgYIwx5t8Oh+QoESmDbU2A3a99UiB+JiIyGWiEXW46FngdmAVMBUoCe4C2xpiAueB7nc+kEbYLygC7gGeT++szOxFpACwF1gNJruJXsNctMsXviSYLpZRSadJuKKWUUmnSZKGUUipNmiyUUkqlSZOFUkqpNGmyUEoplSZNFko5wLVC68tOx6FUemmyUEoplSZNFkp5iYgMdO2XshC43el4lLoRIU4HoFQgEJFa2CVkamD/360CVjoalFI3QJOFUt5xNzDTGHMOQEQCet0x5X+0G0op79G1dZTf0mShlHdEA21EJJtrJd8HnQ5IqRuh3VBKeYExZpWITAHWALuxK5Qq5Td01VmllFJp0m4opZRSadJkoZRSKk2aLJRSSqVJk4VSSqk0abJQSimVJk0WSiml0qTJQimlVJr+H4iVK2ttVJSxAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -769,6 +867,80 @@ "kenv.plot()" ] }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([ 0. , 0. , 0. , 0. ,\n", + " 0. , 106.08611111, 106.08611111, 106.08611111,\n", + " 106.08611111, 212.17222222, 212.17222222, 212.17222222,\n", + " 318.25833333, 530.43055556, 636.51666667, 848.68888889,\n", + " 1060.86111111, 1273.03333333, 1273.03333333, 1273.03333333]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3985, 0.2023, 0.0788,\n", + " 0.0232, 0.0451, 0.0097, 0.001 , 0.0029, 0.031 , 0.0352, 0.1081,\n", + " 0.2332, 0.3624, 0.1898, 0.0815]), reference_distribution=array([[ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 77.81536443,\n", + " 0. , 0. ],\n", + " ...,\n", + " [1197.29622961, 1501.02714205, 1245.41812316, ..., 1634.12265299,\n", + " 1482.57903984, 1393.33205578],\n", + " [1473.59535951, 1626.11273722, 1512.29343527, ..., 1711.93801742,\n", + " 1575.24022983, 1486.2208595 ],\n", + " [1841.99419939, 1751.19833239, 1690.21031 , ..., 1867.56874628,\n", + " 1667.90141982, 1486.2208595 ]]))" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k_test = ripley.k_test(points, keep_replications=True)\n", + "k_test" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(k_test.support, \n", + " k_test.reference_distribution, \n", + " color='k', alpha=.01)\n", + "plt.plot(k_test.support, \n", + " k_test.reference_distribution[:,0], \n", + " color='k', label='Simulations')\n", + "plt.plot(k_test.support, k_test.statistic, color='orangered',\n", + " label='Observed')\n", + "plt.title('Alternative Plot Style')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -780,12 +952,12 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -801,6 +973,80 @@ "lenv.plot()" ] }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([ 0. , -1.82269693, -3.64539386, -5.46809079,\n", + " -7.29078772, -3.30243845, -5.12513538, -6.94783231,\n", + " -8.77052924, -8.18621202, -10.00890895, -11.83160588,\n", + " -11.8073359 , -10.70116577, -11.28365896, -10.90433326,\n", + " -10.7870093 , -10.85579328, -12.67849021, -14.50118714]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4021, 0.2052, 0.0869,\n", + " 0.0273, 0.0449, 0.0112, 0.0021, 0.0027, 0.0314, 0.0342, 0.1121,\n", + " 0.2296, 0.364 , 0.1906, 0.0819]), reference_distribution=array([[ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ -1.82269693, -1.82269693, -1.82269693, ..., -1.82269693,\n", + " -1.82269693, 2.58715172],\n", + " [ -3.64539386, -3.64539386, 1.38442619, ..., -3.64539386,\n", + " 1.34537542, 0.76445479],\n", + " ...,\n", + " [-12.6454847 , -10.97749319, -9.06137052, ..., -9.76660799,\n", + " -11.65668151, -12.27644449],\n", + " [-12.99868847, -12.18440487, -10.31450566, ..., -9.88914623,\n", + " -12.23107585, -13.08710202],\n", + " [-14.8213854 , -13.40917683, -12.13720259, ..., -11.1724894 ,\n", + " -13.45720087, -14.42277641]]))" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l_test = ripley.l_test(points, linearized=True, keep_replications=True)\n", + "l_test" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(l_test.support, \n", + " l_test.reference_distribution, \n", + " color='k', alpha=.01)\n", + "plt.plot(l_test.support, \n", + " l_test.reference_distribution[:,0], \n", + " color='k', label='Simulations')\n", + "plt.plot(l_test.support, l_test.statistic, color='orangered',\n", + " label='Observed')\n", + "plt.title('Alternative Plot Style')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -811,16 +1057,15 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "from libpysal.cg import shapely_ext\n", + "from libpysal.cg import shapely_ext, asShape\n", "from pointpats import Window\n", - "import libpysal as ps\n", - "va = ps.io.open(ps.examples.get_path(\"vautm17n.shp\"))\n", - "polys = [shp for shp in va]\n", - "state = shapely_ext.cascaded_union(polys)" + "import geopandas\n", + "df = geopandas.read_file(ps.examples.get_path(\"vautm17n.shp\"))\n", + "state = df.geometry.cascaded_union" ] }, { @@ -832,7 +1077,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -841,7 +1086,7 @@ "array([list([1]), list([1, 2])], dtype=object)" ] }, - "execution_count": 31, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -853,16 +1098,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 32, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -870,13 +1115,14 @@ "source": [ "n = 100\n", "samples = 1\n", - "pp = PoissonPointProcess(Window(state.parts), n, samples, asPP=True)\n", + "pp = PoissonPointProcess(Window(asShape(state).parts), \n", + " n, samples, asPP=True)\n", "pp.realizations[0]" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -885,7 +1131,7 @@ "100" ] }, - "execution_count": 33, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -903,16 +1149,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 34, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -922,6 +1168,58 @@ "csrs" ] }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "ripley = importlib.reload(ripley)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "simulations = ripley.simulate(state, size=(100,100))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADJCAYAAAAzQMlMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO2dd3xUVfqHnzMlvZIQSgKEHnovAopgAQUVxbZrrz/r2ruu7uoqrrura2XRRdeCFQERFBVQpLeEXkMgDUhI79PO74+ZCSkzyUwyLeE8H/hk5t47975zZ+Z7znnPe95XSClRKBQKRdtH428DFAqFQuEZlKArFApFO0EJukKhULQTlKArFApFO0EJukKhULQTlKArFApFO8Gvgi6EmC+EyBNC7Hbx+KuFEHuFEHuEEAu8bZ9CoVC0JYQ/49CFEOcA5cDHUsrBzRzbF/gKmCqlLBJCJEgp83xhp0KhULQF/NpDl1KuAQrrbhNC9BZC/CiE2CaE+F0IkWLbdQfwjpSyyPZaJeYKhUJRh0D0oc8D7pdSjgIeBd61be8H9BNCrBNCbBRCTPebhQqFQhGA6PxtQF2EEBHABOBrIYR9c7Dtrw7oC5wLJAG/CyEGSymLfW2nQqFQBCIBJehYRwzFUsrhDvZlAxullEYgQwhxAKvAb/GlgQqFQhGoBJTLRUpZilWsrwIQVobZdi8Gpti2x2N1wRzxi6EKhUIRgPg7bPFzYAPQXwiRLYS4DbgOuE0IsQPYA1xmO3wFUCCE2AusBh6TUhb4w26FQqEIRPwatqhQKBQKzxFQLheFQqFQtBy/TYrGx8fL5ORkf11eoVAo2iTbtm07JaXs6Gif3wQ9OTmZrVu3+uvyCoVC0SYRQhxztk+5XBQKhaKdoARdoVAo2glK0BUKhaKdoARdoVAo2glK0BWKNkJeaTU3zt/MkrQc1PoRhSOUoCsUbYQ9uaWsOZjPA1+kMfu99ezOKfG3SYoAQwm6QtHGuHViT7KKqrjivfV8uz3b3+YoAggl6ApFG+OSYV1Y8eA5jOwew8Nf7eCl7/diNFv8bZYiAFCCrlC0EfbkWl0skSE6OoQH8clt47jprB58sDaDP76/kZOl1X62UOFvlKArFG2Ew3nlAKRmWmu66LUa/nLZYP597XB255Qy4821bEhvWQLSPbklrNx3kvXppzCp3n6bJdAKXCgUCidcNiKRxWm5lFQZ628fnsiALlHc9ek2rvtgI49PT+H/zulFnapfTfLpxmM8u3h37fO48CCmpiQQEaJjeLcYLhue6NH3ofAeStAVijZAtdHMC9/tITkujOvH92i0v1+nSL67bxJPfLOTOT/sZ9uxIv5x1TCiQ/VNnjersJK/LdvHpD7xPDatP8dLqvl+Zy6/7DtJjcnCh+uOEqTVcNGQLt56awoPogRdoWgDvLXqEMcKKllw+zhC9FqHx0QE63j7jyMYuS6WV5bv49K31/LedaMY2DXK6XnXHMqnymjmr5cNolfHCIZ1g+mDOwNQYzJz1dwN3P3ZdqamJPDYtP4M6OL8XAr/o3zoCkWAcyS/nHdWpzOlf0cm9Ilv8lghBLdN6skXd46n2mjmivfWsSQtx+nx+4+XEazTkBwX3mhfsE7LJ7eN4+EL+pGWVcwV765n7aFTrX4/Cu+hBF2hCHBqTNZJyvBg1wfUo5M78P39ZzM0KYYHvkjjL0v3NAptzCut5ptt2Uwb1BmNxrG/PTpUz5/O68uPD55NaJCWub+lt/yNKLyOEnSFIsDZnlkEwOyRSW69rmNkMJ/dPo5bJ/bkw3VHue6DTeSVnQ5tfHv1YYxmCw9f0K/Zc8WGBVFjNJMcH+ae8QqfogRdoQhwth0rIkSvYWIz7hZH6LUa/nzJQN64Zjg7s4u55K21bDtmbSB+3nuSaYM7kxzf2N1Sl0qDiScX7qLCYOacvg4L5SgCBCXoCkWAM21QZ6qNFj5an9Hic8wakci3d08kSKfh2nkbeO/XdI6XVDO4a3Szr12wKZOF27O5b0ofzh/QqcU2KLyPEnSFIsCxT0TGhAW16jwDu0ax9L5JTOgdz6s/7gcgpXNks6+zx7PfcFYPp752RWCgBF2hCFAsFsnWo4Us2JzJDeN7cPXobq0+Z0xYEPNvHsPDF/Rj9sgkJvVt3o0zNMnaiz//n7+pKJcAR8WhKxQBiJSSez7bzo97ThARrOPOc3p57NxajaB7hzC+3JJFv2d+oGtMKI9N68+sEY5XhI5J7sDieyfy6Nc7ePDLVJ6bOZBgnYaSKiNmC5zTL56kWDVZGggoQVcoApCvt2bz454T3DW5N7dN6knHyGCPnXtxag5PfbuLKqMZgJziKp76dheAQ1FfnJrDaysOkFNchVYjeOCLtHr79VrBrZN68qepfd0KrVR4HnX3FYoAI+NUBS8s3cNZveJ4fFp/j/utX1txoFbM7VQZzby24kAjQW8o/maLJEir4YHz+jJrZCI1RjPv/ZrOf347wpLUXD69fSx9Epr3yyu8g/KhKxQBRGGFgT++vxGtRvDPq4d5ZRIyt7jK5e2OxN9gtrBgcyaJMaH06hjBa1cNY+HdEyisMPD1VlVww58oQVcoAoj9J0o5XlLN8G4xdI0J9co1nJ3X0XZXxX9Uj1gGJ0bx28F8Nh4pILOgkhqT2eFrFd5DCbpCEUDkldYAMDUlwWvXeGxaf0IbJPgSwJSUxouG3BH/s/t2ZP+JMq6dt5FzXlvNyL/+zMYjLcvPrmgZStAVigDgzZWHuHbeBp5dvJsxybHc4CBFrqeYNSKR2aMSqevMkcDCbTksTq2fyMuR+IfqtTw2rX+j8z54fl9WPjKZT28bx9+vHEqnqBDuW5DKxiMFSCm98E4UDVGCrlD4mZIqI3N/S2fbsSJ0WsHr1wxHp/XuT3P1/nwaSqx9YrQus0Yk8soVQ0iMCUUAiTGhvHLFEIfRMEIIeneMYFLfeK4e3Y33rh+FlJJr523kjo+3eu/NKGpRUS4KhR8orDDw4boMLhzYmX/8dACDycKieybSq2O4T0L/3JkYnTUi0WmMelP07xzJuien8tqKA/x3bQZ7c0ubzM2uaD2qh65Q+BgpJc8t3s1bqw5zydtr+e1gPi/NGsyQpGifxXG74xtvDSF6LXdN7k1UiI7b/7eFEyWqkLU3UYKuUPgQi0Xy9KJdLNt1HICEyGDmXj+Sa8d296kd7vjGW0vHyGDm3zyG3JJqftl30uPnV5zG5e6AEEILbAVypJQzG+y7DHgRsAAm4EEp5VpPGqpQtAe+25HL55uzuOfc3jw2rb/LhZybw76aM7e4qnYpP9Bom911Yv/rbL+niQ23JharqDF55fwKK+6M7x4A9gGOnGArge+klFIIMRT4CkjxgH0KRZuj2mjmf+uPMnNYVxIbuDAWbs8mKTbU42LecCn/Y1/vAAFGs6zd9tCXaTz4ZRqJdcTbWwLeEPt9yHHiu1d4BpdcLkKIJGAG8IGj/VLKcnk6LikcGk2gKxRnDH9ZupdXftjPZW+vI9VWbQggs6CSdYdPMWt4osfEHByv5jRaZK2Y27E/s+duaRii6E3s8fX9XUjXq2g5rvrQ3wAex+pScYgQ4nIhxH5gGXCrk2PuFEJsFUJszc/Pd9tYhSLQWZSazeebM5k9MomwIC3XztvI0h25APzz5wME6TTccJZnY8ydRaw0haMQRW8ibc1JQ7+9wrM0K+hCiJlAnpRyW1PHSSkXSSlTgFlY/emOjpknpRwtpRzdsaMqZaVoX3y/M5eHvtzB6B6xzJk9hMX3TmRYUgz3f57KU9/uZElaLrdM7EmnqBCPXrelkSktaQhaSrDOKuT2gtcK7+BKD30icKkQ4ijwBTBVCPGps4OllGuA3kII9wsgKhRtmF05JQRpNXx6+zj0Wg0dwoP45PaxzB6ZxOebs4gK0XHXOb09fl1HESt6jUCvbdqtY28IFqfmMHHOKno+uYyJc1Z53BWzN7eU//vEurDIZFHeWG/S7KSolPIp4CkAIcS5wKNSyuvrHiOE6AOk2yZFRwJBgErioDij2HikkOT4MELqiGuwTss/rhrKuJ4dSIgKJjpM7/HrOotYsW/LKa5CUH9iyx6i6G5udHfJK6vmjo+3klNcxfkDEpg+qHOrz6lwTotXMQgh7gKQUs4FZgM3CiGMQBVwjVTJGxRnEDuzi9mRVcwLlwxstE8IwdVjWl8+rimcRazYtzkKa5w1IpGJc1a5nBvdHUqqjESH6nl20W6KKg0svW8SQ5KaL0itaB1uCbqU8lfgV9vjuXW2vwq86knDFIq2xPc7jxOk1XDFqCR/m+IQZ4LvTgoAV8gpruKP72/kWEElH94yhrSsYqamJCgx9xFqpahC0UqMZgt5pdVEhOiICvG8S8WbeDoFwPtrjnCsoBKAWz7cQlGlgYsGd2mxfQr3UIKuULQCk9nCjDd/Z3FaLhoPxpb7Ck+mADCZLXy/M5fBiVGEBWm5fEQiqx45lxlDlaD7CpVtUaFoBT/vPcnBk+VcNrwrM4a0PeHyZAqAdekFnCo38NKsIUwfrCY//YESdIWiFcxfl0G3DqH86+rhaL1Q/9MXeCoFwJLUHCJDdA4rHyl8g3K5KM5IymtM/POnA2zOKGxxNZ1d2SVsOVrETWclt1kx9xRVBjMr9pzg4sFdahcRKXyP6qErzkjmr83grVWHeWvVYYYmRXPbpJ5cPKQLejcqBX24LoPwIK3XQxLbAr/sO0mFwcxlI7r625QzGiXoijOOKoOZ+esyOLd/R84f0In5azN44Is0/r3yEN/dN4kIF4pM5JVWs3RnLteN60FUiN5pnHcg4g1bl6Tl0DkqhHE94zxkpaIlKJeL4oyjoKKG4kojFwzsxPXje/DLw5N545rhHMmv4KstWS6d49ONxzBZJDdPSK5dbZlTXIXEP9kMXcUbtuaX1bD6QD6XDu96xrue/I0SdMUZx8p9eQAIW917jUYwa0Qio3vEMn9dBiZz0wmkqo1mPtuUyXkpCSTHhztMX+vrbIau4g1bl6TlYLZIrgzQRVVnEkrQFWccb606xNjkDo0E6Paze5FdVMWKPU2XSVu4PZuCCgO3TuwJeH61pTfxhq1L0nIZkhhNv04q17m/UT50xRlHdKie+MgggnT1+zMXDOxEj7gwXluxH4PZzAUDOzfyp2cVVjJn+X7GJMdyVm+rv7hrTKjDSjwaIej55LKA8qk7s9XVlaGO/O9xEUGkZRVTXGkgJizI0yYr3ED10BVnHF2iQznuoPq8ViP4y6WDMJqlNa/5Sz9z34Lt/Lz3JAaTdXn/vQu2A/Cvq4fXVh1ytNoSwCxlwPnUW7My1Jn/fWxyB0qrjPx75SGnrzWZLfx+KJ8dWcWtfQuKJlA9dMUZhcFk4VR5DRYnsefn9k9g7RNT2J5ZxJK0XL7feZzvdx4nOlSPRlj9zW9eO4JuHcJqX9NwtaUQ0DDttycyGHqC1qwMdeZ//2xTJteO7c4nG45x/fge9O4YAYDFItl6rIilO3JZvus4BRUGIkN0rH18qlfSCCtA+CvL7ejRo+XWrVv9cm3FmcuL3+/lv2szeOePI13KMWI0W1h3+BRL0nIprDDw3MwB9Elw7itenJrDg1+mOdwngIw5M1pqut/p+eQyp8WCu3cII7Owktkjk7hqdBKr9ufx/Y5cckuqCdZpOH9AJ8Ykx/LC0r3cP7UPj1zofq4YhRUhxDYp5WhH+1QPXXHGYDJbWLApkytGJLqcMEqv1XBu/wTO7Z/g0vFNRYu0NINhoODM/94lOgSjLTJo4fZsFm7PRqcRTO7Xkcenp3D+wE61cxGbjxYyf20Gt07sSWy48rd7GiXoijOC3Tkl/N3mMpjc33u5RpqKFmlJBsNAwD4R6qzy0RPTU5g1IpHyGhMZ+RWcKK1mTHKswwnSB8/vxw+7T/CfNUd48qIUn72HMwUl6Ip2T1m1kbs+3UZZtYlh3WKY1Md75W6d9WJjQvV+95+3hIYl6iTUinpiA/97RLCOIUnRDMF5MYt+nSK5dFhXPlqfwdWjk+hl87crPIOKclG0e17/+RC5xVXMv3kMS+6dSFxEsNeu5SyK5IVLB3ntmt7E0USoXczXPTnVYSPVXNHppy4aQLBOy0NfptW6ahSeQfXQFe2eowUV6DQa+vigN+jJ/OKBgCsLkerGpseE6SmvNmG0hfk4KjrdOTqEV64Ywj2fbeetVYd5+IJ+Xn4XZw5K0BXtGpPZgtkiMZgtHC2oYFhYjNev6an84oFAcwuRGrpkiiqNjY51FLJ58ZAuXDEykbdXHaK0yshZveMY3zNOhTO2EiXoinbLV1uyeHbxbgxmC6F6Lel55Qzr5n1Bb088Nq1/PcGG+guRHLlkHOGop//CpYMorzbxxZZMPlp/FCFgcNdozuodx1m94xiT3MGlzJeK06i7pWiXLNyWzZPf7qxd4FNlNPPM4t1szypi9f78duEO8QXNuZBczQHjKGQzKkTPvBtHU2MysyOrhA3pBaxPP8VH644yb80RNAJ0Gg0Gs4W48CCemJ6ics83g1pYpGh3WCySQc+vcNhzdBR298oVQ5Sot5CJc1Y5dMnUxd17XGUw89aqQ8xbcwRTgyW3vTuG8+D5/bhk2JlbSKOphUUqykXR7njvt3SnboCG3Zcqo5lHvtoREHlW2iKOonr0WkFMqB6BNRrG3QYzNEjLkrTcRmIOcKygkj99kcqPu4+31nS/IKWkvMbU4rKHzaFcLop2R2pmkVvHm6VsFImhcA1vRfU4c+WYLJIR3WN44Is0Ft4dxuBE5zHv/qbGZCbjVAURwTqSYsOoNpr50+ep/LT3JC/OGswN43t4/JpK0BXtikqDiW3HihjUNYoj+RX1euoN3S11CZTkWW0Rb0T1OIuuSYwJ5T83jGLs31aycl9eQAh6eY2Jw3nldf6XcTivnMzCSiwSBidG8f39Z/P1tmx+2mvNtT82uYNXbFGCrmhX/Hogn6JKI/++dgSFFYZ6PccpKR1ZuC3HqTsmEAtSnKlMSenIZxszG813PDatPxbbWqS4CP/mgvlk4zHeXX24XipmvVaQHBfOwK5R9IgL57eD+cwanojJbOG5xbsBuHlCMv07e6cYiBJ0Rbui0mAVa62trFzDnuPoHh145KsdmB34MNt68qz2wuLUHBZuy6kn5gKYPcr6eS5Js853PLt4Nzuyirl2bDdGdo+tzU/vCzILKnlx6V4Gdo3i+vE96JMQQZ+ECLp3CEOv1SCl5PJ319MlOoTrx/dg6c7c2tc+5MWFVErQFe2GSoOJf6w4QErnSMb2dDyktQt8U7HVvsJR9Z/WuC48fT5/4SzdwOr9+QBsPFIAQErnSJbvOs7X27LpmxDBoK5RbDxSyMnSaq+//0WpORjMFt67fiRdoht3BH7ae5K0rGJenT2EIK2Gp7+19s4fvbAf0aHeWzylBF3RbtiQXsCJ0mrmzB6CXus8gCsQluc3XGHpaIm8P8/nT5pLN/DnmYN4bFoKHcKDKK8xsWxnLu+uTmdx2ulesDfef0F5DX9bvo+N6QXkllTTJyHCoZibLZJ/rDhAr47hXDEikXdWH679XLz9WShBV7Qblu7IJUSvYVzPuGaP9ffyfGfVf1o6Mevp83kDV0cQzaUbCA3SEhpkDZWMCNZxzZjuvLnycKPjq4xm/v7jfo+9/5ziKr7dnkOPuDD+cukgpqY4zpG/KDWHQ3nlvHvdSJbvPsE/fz4IQLcOoSTFhjl8jadQceiKdsGe3BKW7Mjllok9a3/sLaG5TIGewpWkV/48n6dxVo/U0f2959zehDQo4N2cS8zp+y+pprDC0Crb7QxNiuGCgZ3IL6th2qDO9coQ2qkxmXn954MMSYzmosGd+e1Afu2+Zy4e4BE7msJlQRdCaIUQqUKI7x3su04IsdP2f70QYphnzVQonHOsoIIHvkgjKkTPXZN7t/g87ohOa3E2AdvSiVlPn88V3Gn8mhpB1OXAiTL+/N0eqk0WtBrrJKcri5Oaep8Xvr6GYwUVrrylZnluxkBMFsnLy/c53L9gUyY5xVU8MT0FIQQzh3XhvJQEfn98CtMHu1YlqzW400N/AHD8LiADmCylHAq8CMxrrWEKhStsSC/g0rfXkV9Ww3vXjWzVhJOrouMJnOVNb+nErKfP1xzuNn6ujiC6dQilc1QIQkCQVkNiTChf3Dm+WbeJs/f/yAX9OFVew/JdJ1x/c03QPS6M2SMT+XH3iUarPctrTLy96jATescxqa+1iMrUlE789+YxDnvz3sAlQRdCJAEzgA8c7ZdSrpdS2pfnbQSSPGOeQuGcDekF3PLRZhIig/nuvolMaGUlIl+6LWaNSOSVK4aQGBPa4iXy3jxfc7jb+Lk6gggL0vHSrMFICZP7daS8xsS18zaSWVAJOB8VOHv/t0zqSWSwjoMny1r5jq1kFVaSllVCYmxoozDJ//6eQUGFgcen+6+0nquTom8AjwOuRMPfBvzgaIcQ4k7gToDu3bu7eGmFojG7c0q47X9b6BYbxud3jifeA1WImpuM8zSenpj15USvu41fc2l46zIlJYEZQ7rw876TvHHNcJ5ZtItr5m3g1ok9+dfPB51G8jR8/2XVRm6ev5lKo5kZQ1rn7qioMfHur4d5//cMtELw0qzB9fYXVhh4//cjTB/UmeF+TNHcbA9dCDETyJNSbnPh2ClYBf0JR/ullPOklKOllKM7dvReoV5F+yavtJqXlu0lRK/lszvGeUTMwfdui7aMuz57d0cQz18ykGCths82HeOz28dTY7Lwyg/7XB4VVBvN3DR/M2lZxbz1hxGcP7CTe2+wAY8v3Mk7q9OZMaQLqx89l9mj6jsh3l19mEqDiUen+bf6kis99InApUKIi4EQIEoI8amU8vq6BwkhhmJ1yVwkpSzwvKkKBfx2MJ/b/7cFk0Xy7IyBJESGeOzcgRCf7i/cXZTkTo/bjjsjiISoEB6/KIXnFu/mux25fHDTaK54d73DYx2NCvYdL2V7ZjHPzRzIxa3snYN1RHjxkM68fs1wh9f/eOMxZo9Mok+Cd5b0u0qzgi6lfAp4CkAIcS7wqAMx7w58C9wgpTzoBTsVCgD+unQPFglSwvy1GcSFB7VZt0Wg0JJFSb5o/K4b252tRwuZ+1s632zLIiZUT3FV4xJ3jkYFveKt9WNrTM1XU2oOi0VyvLia6YM6O9z/718OgYQHA6A2aosXFgkh7gKQUs4F/gzEAe/aJgpMzhKwKxQt5e8/7ic9/3T4WVteDekrXOl5u7MoyZfpBTQawb+vHcFNE5J56Ms0iiuNhOg0VJsstcc4GxVEh+np1iGUPTmlrbbjVEUNBrPFYcNxOK+cr7dlcfOEniQGQC4gtxYWSSl/lVLOtD2eaxNzpJS3SyljpZTDbf+VmCs8ytajhbz7a3qj7d4KK2wPuBpa6OoEpy/j9Osysnss7143kiqjmZ4dw+kabXWzCeDpi1McNignS6sJ0mrYe7z1gv7l5iwABnWNarRv2c7jWCQkxvpfzEGtFFW0EZbuyHW6ryVhhb5aEepPXA0tdHWC05dx+g0Z1DWa52YMYN/xMm6emMzKRyaj1QiHgn2qvIbz//kbR05VcNXo1kVQH8kv563Vh5kxtAujHeQwv3xEIjqNYP7ajFZdx1MoQVcEPJuOFPBtak7tysGGuBtW6K+epq9xteftanSPs/PlFFf5pFG8fnwPLhrcmb//eIDSKiM3npXMF1uy2JNbUu+46FA9w7vHICWtWmgmpeTZxbsJ1ml4fubARvurjWYe/WYHQsBrVw1t8XU8iRJ0RcDz8YZjaITg6YtTPBJW6O2eZqD0/l3tebsaUthUw+mLRlEIwZzZQ+kcHcJ9C1K5ZWIyMaF6HvoyjQ9+P8LmjEIqDSb0Wg1PXWTNmxKsa3len2+357A+vYAnpqeQEFU/mspikTzy9Q42ZxTyj6uGMaF36xa1eQqVbVER0JgtkoKKGvRaDbdN6kVceHCrJ+W8tSJ0cWoOf1m6h6LK05EY/py4nZLSkU83Zjrc3hBXonschSrWxVPZHZuaeI0O1fPWH0Zw1dwN3PHxVoYmxZCaWcRLy6xZSTQC+nWKJMTW8E/s03zmTUcUVhh4adleRnaP4Y9jGy+CfHn5PpbtPM5TF6Vw2fDAmZBXgq4IWCwWyVPf7mTjkcLaTHWeCCv0xorQhqF/dfFXGlt7QQhXtzdH3VBFR/cPPNMoNhdCOaJ7LG/9YQSv/3KQ3w7mExakZUr/jgzoEoVOI9iRXcLO7GJG9Yh1mK+8OQ6eLOPC19cA8O60FDQNXH2ZBZV8sDaDLtEhjRYY+RvlclEELMt3H+errdlcM7obd5zTy2Pn9caKUEdunLr4ys9cF2+MRGaNSGTdk1Odhug5ahS9kZXxoiFdWPHgOSy6ZwKXDuvKpgxrFNTy3Sc4u288vzw8mW/uOqsF7xD+tux0DsK6pePAmoDr1RX7ATheUs3ol36huonP3dcoQVcELGXVJgAGdo3ikw1HPeaX9kYiK1dE0teTr95Mqetqo+itrIxg9amP6B7LnNlD2fzM+bw6ewiRITpeWraP8a+s5N4F22vL1bnDbwdPj2AWbMrkcF557fNvtmaxbOdxJvWJZ2hSNI9c0I9gXeDIqHK5KAIWexm557/bU2+7J/zSnl4R6syN0xBful9asjzfTnMLiFxdKepuJSV33WHf7cjlT5+nWm0a3pULBnbi/AGd2HasiOW7TvDz3pPsemFarU+9OfJKqxECBneNZkLvOLpEh9AzPhywRr18svEYfRMi+PjWsY1cMYGAEnRFwHLZ8K7EhQfxyFc7KKysX3Wm7jC8OVHxxerG5iYM6+KrKkItXZ7vaioAVxpFb2ZlBBiedDqzYd2aonYevbC/y2IOsD69AClhzuwhDOoaXW+f0SxrVyr3eno565+c6tUCIi1BCboiYNHZekANxdyOXWiaEh5fFU+eNSKRrccK+XxTFmYp0QpBsE5QabQ0OtaXItCSkYgn65O62+N2txHqHhdGxisX88u+PF5bsZ+DJ8vr7Z/c372srkdOWQX72cW7WXTPxNrt6w+fqo2kAYiPCA4oV4sdJeiKgOXRr3eycHs2Wo3AbJGN9muFaFZ4fFU8eXFqDqIyStoAACAASURBVAu35WC2VbExS4nRDHqtwGg+bXtbSMfryclUb2dlBKsv3epqSaCsxkR4kI6iSgPT31jDA5+nseS+iS730ockWnvlaVnFtdtKq43c8tEWakwW/jxzIDOGdqFTlOeyfHoSJehtALvLIKe4io4RwTx1UQpXBFi4lKepNJhYuD2buPAgrhnTjQ/XHW0kCs7cG3WFx1dViBw1HEaLJCZUT3iwrk2l4/VkWKe3sjI6cqOlZhaREBXCnef0Ij4imNeuGsYtH25hzg/7eeHSQS6dd1SPWLQawV2TT0dVnSqrocZk4e+zh3L1mG6tstvbKEEPcBq6DPLLa3h84U40GhHwwtAaTpVZ3SwFFQa+2JLFK1cMafQDdhYPrRGCnk8uo2tMKDFh+noLfex42u3hrIEoqTKS9vyFHr2Wt2nNZKojPDkB7Wzx1hMLd1Jjy8L44+4T/PPqYUzpn8DNE5L5aP1RJvfryJSUhGbP/8u+k5gtkumDrDnULRbJqz9awxQfX7iTod2iSencOElXoKAEPcBx1PMzWSRzftjfrgU9/VR5rbtiQu84p6LgaCLS7vbIKa5CrxE+cXv4unydN/FGr7o1E9NGs4V3Vh/m0Mlyft57EoO58bxETZ2UurtySpj55loeuqAfj0/vz8YjBTz2zQ5+eOAcOkY2Xd3qx90nSIwJZXBiFBaL5OlFu1ix5ySje8SSX15TG3kVqChBD3CchcKdKK32sSWexWKRrD6Qx6aMQgYnRnPpsK6A9ce7KDWHx7/ZSYfwIP40tY/TYW5D4dEIUSvmdnzl9vB0r9bfeLpX3ZqJ6fJqE+/+mo7B1FjIG5Joa1jP6deRV3/cT2ZhJf++dgQz3/qdd389zPOXOHe9lFUbWXvoFDec1cOaN+aHfXyxJYv7p/bh4Qv6NSoKHYgoQQ9gftl7EgE0ng4kIJLpt5R1h0/xyg/72J1TikaARUKQVsN5AxK4+9Nt/LIvj24dQvn41nG1McDOqCs8PZ9c5vAYX7g9ArF8nS+LUTSFKxPTTdkaGx7Eg+f35e8/Np08TXC6A3Tf1D507xDGh+szuHRYV8wWSWRw03K3+kA+BrOF6YOtlYmW7z7O1JSENiPmoAQ9IJFS8sHvGbz8wz6SYkPJL6upV6VFI+CB8/r60ULnHDpZRkJUiMO0paXVRl76fi9fbc0mKTaU168ZxoUDOzPo+RW8vHwf7/9+hG3Hinj+koHcdFay2ws3/OH2CBTRdGSXL8I1XaG5iWlXbL3z7F68/vPBeq6zuoTqtQzsEsW2zCKuH9+d/p0ieeiCvny3I4c/vL8RgBE9Ypu0c8XuE8RHBDOyu/W4kkoj3TuEtRkxB7X0P+AwmCw8uXAXf1u+j+mDOvPTQ5OZM3to7TL1mFA9Up6Olw0kfjuYzwWvr2HEX39i9nvrKakzcbX20Cmmv76Gb7Zlc8+5vVn5yGQuH5FEeLCOiX3iyCyspKC8hpcvH8ItE3u2aBWeN3K0NIU7y9p9nVLXn8UoGtJcCoK/LN3TrK06rYanbSlxGxIVouOVK4bwwU2jiY8IIjWzGJ1WEBmi5zlbHvMQvYaR3ZwLusFkYfWBPC4c1Kk2TLasxkRUK/Kp+wPVQw8giioM3PXpNjZlFHLvlN48ckH/2mgWe09FSsmQF34KqIRAACazhT8v2U3P+HBG9Yjlm23Z3PHJViwWSZXRzJ7cUnp1DGfh3RMY0b3+D+u/N43heEk1yXGt6w352u3haoy7P3rLTRWjWJya49NeelPzC4tTcxxGIUHj93DLpJ4UVRp4c9VhAOLCgyitNhIXEczo5Fhiw4N4adYQ7vp0G3N/Tef+8/py2fBEJvfriMFkITrMuThrhNVlY+9HlFUbW10gwx8oQQ8Q0vPLue2jLeQWV/Ovq4dxxUjHceY1JgvlNSYfW9c8JoukvNpE97gwnpiewsnSan4/dAqAYUnR/N/kXjx0fj+HCzxC9NpmfeWu4ukcLU3haoy7rxY31aWp3DK+dr001dBOnLPK6esc9ewfvrA/ibGhPLFwF4MSo7l4cGdeXr6Pq+Zu4JPbxlJWbUSrEaw5lM/9NrdkTFhQszbqtBrG94pj3WFrMq+SKmsjowRd4TZrD53ins+2oddqWHDHOIe1C+2E6LXMGNqFTzYeY3RyLDOGdGm1j+94SRUHT5YzuZ97y6Qb2nXrpJ68tuIAu3NK+OS2cXyy8RjJcWGc3bfl5w1kXPXZ+2pxU12ayi3jj/zszhrapu6BM1fZNWO6U2208I+fDrD2UD7DusWQmlnMzLfWUm20cFavON78wwi3bZzQJ56V+/PIKa5qs4KufOh+5rNNx7jpw810jg5h8b0TmxRzO69cMYSUzpHctyCVf/50sFXXP15SxZXvbeCm+ZtZktYyv67FIlmwKZN5a46g0wi6xFiXRd8wvke7FXNw3WfvzTS2zrCnCHaGrxKEOcM+p+B4ihPC9FpC9Jpa16KUkryyaky2GPSbJiTz22NTuPGsZHZlW2uKVhst3DIxmU9uG9tsvLkjJvWxlpGb8e/fufTtdQDsyi5u6iUBhxJ0P2EyW3jhuz08s2g3Z/eNZ+HdE+jWIcyl10aF6Fly70Qm9Ynny61ZlFQaOV5ShZTOfh7OeXLhLkqrjAxJjObxb3bWy2HRFKv2n2T6G2t46tudzHp3HU8v2kX/zpEsf+Bs9h8v88kEoL9rd9pFM7aOb9ZRwiZfT9bWtc+dQhS+ou5ksjMqjWbu+nQ7d326jWqjmbs/3c7Yv62k/3M/8vBXaUgp6RAexAuXDuKXhydz8RBrqOGyncf5ae/JFtm111ZsurjqtE//P2uOtKni4aIlIuAJRo8eLbdu3eqXa/ubk6XVPPbNTtYczOfWiT15+uIUdC1YgZaaWcSVczegFQKD2cKQxGj+fMlAxrjQy6+oMbFgUyav/LCPe6f04eYJyVz2zjoKyg28OGswV9pyxUhpXQD024F8th0r4sCJMowNEmV17xDGQxf0ZdbwRJak5TqcAGttAYmGOCr55o3reMoOf4U3Bsp9qsvEOaucinlkiI5e8eFUGMy1hSW6RIdwvMS6kG5szw5szijkxcsGccNZyfVeu+1YIc8u3kPGqXJ2vTANnUaQW1Lt8poNZ3YlxoSy7smpbrxD7yKE2CalHO1wnxJ035BVWMknG4/xw+7jZBVWodMIXpo1mGsdFKB1h41HCli+6zhx4cF8tTULk8XC0vsnkRDpOBtcVmElc39LZ/mu4xRVGpnUJ543rh1OfEQweWXV/OnzVDYeKeTq0UnMHNqVN345yPbMYoJ1GgwmS70hcohOwyMX9uf2s3vW+vF99aPw1HVaK7RtQQQCLVa+55PLnLpaAGLD9HSNCaXKYK4Nz40M1lFWY+KG8T3IKqpkQ3oBvz8+hYQGWQ+X7sjlflvBi+vGdeezTZm8duVQrhrdfFItZ3YJIGPODBffnfdpStDVpKgXkVKyPr2Aj9YfZeW+kwghmNK/IzeOT2Zy/4706xTp0nma+kGO7xXH+F5xtscduO6DTZzz99X89bLBXN3gS1xSZeShL9PYeqyI8wckcM+UPrWLKAASIkP47PbxvPHLQd5efZivtmbTOSqEly8fwturDpFbUj/dQLXJwkfrj9ar9+mrCUB3r+PoHgKtDif0x4Snu/gy8scVnE4mR4fw88OTCbet6KyoMXHHx1tZn15Ajc13/vuhfP5vcm9+PZBPpaHxhO/IOouHPtuUSZBOw9OLdpEcH97syLU95ONRgu4FKg0mvt6azWebjnHwZDkdwoO4+9zeXDeuh9tfDndimMf1iuOXhyfz9KJdPLlwJ9mFlUTZFiIZzBY+3XiMvLIa/n7l0EZib0erETxyYX/O6hVHen45V43uRoheyzOLdjk8vqFw+epH4c51nN3DEL2m1eGE7UEEfI2zuPTHp6fUijlAeLCO+TeP4b4FqWzPLOKK8Yl8sDaD1fvzCAvS0q1DGFUGM6FBp+cnEmOsK5A7hAfz8rJ9DE2K5utt2dz1yTY2Pn1ek8m12kM+HiXoHsae2S2rsIohidH846phzBzaxa0yWHVxN4Y5OT6c/940hps/3Fy7AMNOv04RzL1+FMO6xTR6XUMm9Ilngm3WH1wXLl/9KNy5jrN76Eo+dU/aobDizgKwEL2W928cRY3Jwq8H8vhgbQaRIXoqDWbGvfwLxZVG7p/al3um9K4V68Fdo5n51lpqTBYOnCwjNkzPRbZJU0/ZFagoQfcQlQYTr/6wn/9tOEaPuDC+uHN8rSukNbRkSB8apOWLO8dTXGlEoxFoNQKtEIToNS2OWXdVuHz1o3DnOu66P9zpXbcHEfAH7riBhBCE6LW1oYgzh3UhNEjDpxszAXj9l4PsyS1h3o1Wt3JibCg3TUhmxZ4THCuopKjSSGpmMfuOlzI0qenOTKC5p9xFCboH2HSkgMe+2UlmYSU3T0jm8en9CQvyzK1t6ZBeCEFsePMr5FzFHeHy1Y/C1etEh+rrhaLZiQnVU2OytLp33dZFoK1gn+jPL6vhr5cO5kRJNWlZxbWLgOyEBel4+uIBPHVRCun55SxJy+WtVYfZcrSoWUFv6yhBbyX/+vkgb648RPcOYXx553jGeaBXXpdAGtJ7S7icTVh6ote7ODWHCkPjVAl6jagtS6Z6122DjpHBaAS8/vNBsgsreXbGQBJjQ7nu/U2sPpDH2kOnmNT3tJtQCEGfhEgm9YnnrVWH6d3RM+klAhkVttgKjGYL/Z79gVHdY/n4trEe65U3JNDCzjyJozhpR0WhWxo77SysMDZMT+qf21ZpOAWs2HOCTzceY+3hU0gJd5/bm7vO6c018zaQVVjJF3eexZAka6HnSoOJL7dk8f6aI+SV1bDuyakBW9zZHTwStiiE0AJbgRwp5cwG+1KAD4GRwDNSyn+0wt42g04jkBIsUnpNzKFtDOlb2ug4mrBsKObQ8vwjzvznxU4y/CkCm2mDOjNtUGcue2cdO7KKee/XdNYdPsXfLh/Mnz5P4+YPN7Pw7gmsSz/FP1YcoKjSyNjkDrx21bB2IebN4Y4KPQDsAxxVSC0E/gTM8oRRbQV72s8xPZtfmemI9tLzbk16WHcmLOse6+q9U2GFgYGnv+sFZTW1j3dll3DDfzfz8AX9eGf1YWa+tZbyGhMTesfx8AX9GNUjlg9+zyA9v5yZQ7vSwYNzS4GGS4IuhEgCZgB/Ax5uuF9KmQfkCSECZzmVFymsMLA4NYevtmYB1Fuc4yqBVFGmtbQmPWxTaV4dHQvu3btAmoMIJHzZmfD0d31xag4FFYba5xKoMph5efk+Pr9jPPcuSOWGs3rw6IX90WoE/1t/lL8t3wfAX5fu5dz+CTwxvT8948NZujOXzIIqQvQagnUaQvRa4iOCOW9AQpuqVGTH1R76G8DjgGtLG50ghLgTuBOge/fWLXn3B9VGM6//cpD5azMwmiVDk6J5cdZgpqYkuH0uf+TI9hatWS3ZVJrXugioN1nq6r1TYYWN8XVnwtPfdUfnk4CU1tQWQVrB3F/TWZKaw3XjepCWXUxiTCjv3ziaxWk5fL45k7s/247FIp1W/vJGgIMvaFbQhRAzgTwp5TYhxLmtuZiUch4wD6yToq05l6/JK63m+v9u4uDJcq4alcTtZ/eif+eWt29tYcl4Q5z16lrj1mgouDFhesqrTfUSgAnguvHda4919961hTkIX+LrzoSnv+tNve6pRbtq647mllTz2k8HiI8IorTKRP/OkTx98QBCdBreXHWYfp0imHfDKM4b0Ikak5lqo4XSKiMXvrGGH/ecaJ+CDkwELhVCXAyEAFFCiE+llNd717TAYuX+PA6eLOftP45g5tCurT5fW/PtNtWra61bo6HgNucO8Pa9ay9zG87wdmei4f2LCdM7LDPX0s+rKTedoyLSRRVGzFKSXVRJj7hw7pnSh/G94hjXKw6treZcWJCOsCDoEB7E2X3i+WnPSf48c2Cbc7s0K+hSyqeApwBsPfRHzzQxB+siFIBe8REeOV9b8+021auzZxX0lAg216P25r0LxLkNTzcw3mwQHd0/R7Tm83LVTWfHbAvNTs8vp0dcOCF6bb20Fna77ffYvhBtT24pgxOjW2Sjv2hxrJ0Q4i4AKeVcIURnrCGNUYBFCPEgMFBKWeoZM/3P0YJKACKCPROe2NZ8u8316nzp1vDmvfOEO8KTAuyNBsabDaKj+2dHYPV1J3qgwbdfq26DERWio7Taeb3dHVklTE3p1Gh7w3tsX1X81qpD/OcGh+HeAYtb6iSl/BX41fZ4bp3tJwDHVY3bOCazhWW7jjN/XQZjkmPpHudaVSFXCFTfriNBCjQXkbfuXWvdEZ4WYG/4u73ZIDZ1n+xi7ok88fbP/5r/bGBTRiH9OkVw1+TePLNod737JYCZQ7uwYu9JukQ7jkN31git3JfXajt9jVr6X4eSSiPLdh0nv6yGSoOJCoOJ3w+d4lhBJX0TInh2xkB/m9hqmltmHx2qp8JgqvVF2gVp9qhEFm7LaTMuopbS2obrhe/2eFSAveXv9laD2FwYqqcn/TdlFALw1MUDmNI/AY0QtT33TlHBPHXRgBavhTBZJJkFlR7txHkbJeg2iisNzHhzbe2XMUSvITxIR3J8OE9dNIALB3ZCo2lbEyQNWZyaw2Pf7Kgn1o98vQMN1EaVOEpiVWU0s3p/Pq9cMaTNuIhaSmvcEYtTcxzeP2i5kAXayKg5mvNve9ruhy/ox5ajhZzbz1qMvG5DZe+8PPRlWosWnwH8tPcEt5/dy+G+QEQJOtbKQk8v2sXJ0moW3DGOcT1Pz363J/6ydE+jKACzReLK1FJucVXAuoga0hofdmvcEa+tOOB0X0uFrK1Nntvv0wvf7WnUuHnD7j+d19fhdk8sPqsymlmxRwl6m+Obbdks33WCx6f3Z0Lv+OZf0EZxFDrmKoHaI2yIJ3zYLW24muqFt1TI2trkOZy+f/4M/3Q29/Dgl2m8tuJAPVsc3eOrRifxxi+H2HK0iFPlNcRHBPvE7tZyxgt6abWRF77bw7ieHfi/c3q7/fr2HrMMgd0jbIg/V+A6G7rHhulbde22MjJqiD/tbqpxddTIN7T14w1Hax//svdkq4u5+wrnBfbOAMwWSXpeORUGM5cM6+q2m8XeG8wprkJy+ouyODXHOwa7yeLUHCbOWUXPJ5cxcc4qQvWufdx6jSA2TI/AGpXQkrS1zdnirXvkzxW4j03rT2iDUoOhei3PXzLI69dW1Ke5EaW9kXfG/hNltY+f/26Px+zyNmdMD91ikcz9LZ3/rDlCSZURrRBYkEgJQkCvFiS/D+R8LI5cD3qtQANY6hyn1wiuGduN1fvzvTbK8OViHX9OIrZF90h7xZXFR0018vuPlzK8WwxpWcXUmCyU15g8tgbFmwS+ha1ASsmO7BK+2prF4tQcKg2nP1z76rFQvYY7z+ndIt95IOdjcdTYGM2S2DA9YUE6twWnNa4lXzZ8/p5EbCjq9l6gEnXf4mzxUV2cNfIWi+TAiTKuHJVEWJCW9ekFzF+b4XQCNpBol4IupSS7qIq/LdvHj3tOWIsj49idUmW0MG/NEXrGh7v9owvkkLKmCju4W6mntT1sXzZ8/u4lB2LqgDOVupOzrjTyr/64n1HdY+nXKZIKg5mULlHcO6UPY19eyb9+PqgE3ReUVRv5ams2CzYdo7jSiE4rqDZaagvHPnJBP26amMywF35yeo6W9hb93RtsCk82Nq3tYfu64fPnZJy/3XAtGUm194l9Vxv5935NB+DV2UMASOkcSUKdKkcGk4UgXWBPO7ZZQc8uquR/64/yxeYsympMjO4Ry/hecZjMEq1WMLBLFGOSO9SmuG1uBVtOcRWLU3Pc+iL7uzfYFJ5sbFrbww7khs/T+NMN15LRQXsfUZgtkgqDibE9O/DhLWMoqzZSVm2irNrE55szKa82UVZtpKKOO/aJhbsQAvp1isRSJ41zWlYxY1tYncxXtDlBt1gkzy3ZzWebMgEYmhTNXZN7Mzo5lmCtliCdBr1WoNWIeqkvXZkkackXOVBDyjzZ2LS2hx3IDZ+n8acbriWjA3+PKBpiNFuorDFTYTBRaTBRXmOmssZEeY2JSoN1e0WNiYoac+3+Ctv+8moTZTXW/dZ9JqqNlmavKQSE6bUkRAaTV1ZDj7gwJvfrSLhtEvSJ6SkUlNfQr5NnMq16kzYn6KlZRbViDrAzu4R7Ptvu8FiNsFaQ12oEOo11qOSoorydKqOZF7/fS0yYHo0Q6DQCvU6DXqtBpxEE6TS2c50+Z+1z7entWtG4QfEUNSYzf168h7IaIyF6rfW/TkuI3lo+K1SvtZXT0pIY65lESJ7oYQdqw+dp/DkaacnowNXXSCmpMVmoMVqoMpqpNprr/W24vdzWC7b3iEurTVQZTdQYLdbzmMy157M/NpgsmJz8Nh0RqtcSHqwjLEhLZIiOiGAdiTEhhAfrrP+DrPsjbM/tx0SG6IkK0RERYn0cptc2mdbj7nPdX5/iL9qcoA/vFsuC28dRXmNNIGUwmzGYLBjM0vrXZMFotmC2SCxSYrJILBbrX5PZws97T5JbUu30/AUVBm7+cItHbK0r7g3/6zQCjRBYpMRolhjNFizSGkYJ1ixxCNAIgcb2VwjrELKo0kiv+HBqTBaqbT+iapPFYUP19MUpdIoKITpUT0xYEDGhemLC9ESG6F2Ouz+TetitxZ/3yvnCpiA+35xJRY2p/nfGaCE0SFsv+suOViOYOGdVPZGWbtYY0wiIDNETaRPO8CAtwXoNUaF6gnUa23/rqDpYpyHY1hGxirCWsCAd4cFawoN0tcJtF+tQvbZdpudoLUK6+yl5iNGjR8utW7f6/Loms4UTpdVc/s568strGu3vGBHM3BtGIW2NgdFswWSWGMynGwqzrYGo/Wu21H9uqd+QWKTEZLY3MPXPoRUCnfa0m0gjRO0Px2J7YBd6i5RYJPSIC+OuyY17DSazhWqThSqDmXNfW13PL9gQISAyWEdMWBDRoXqiQ/WE6DXoNBrbqEQQpLWNTuo81ms16HXW53VHMEFaDUE6Te3owP5jDdZb9wXX265Bpw3sySVZp6G1dhhO/63dZmtEQ/RawoK06LUazNL6uZvrfOb2zoXZQp3H1mPKqk0UVxqoMphr62JKTjfsFoust91gslBabaS0ykRJldH22Eip7TyOKvY0RAhqR3UWCaVVRuq+SiNgaFIMvTtGEBqkIUSnJTRIWzsitI8CQ/Wnt4XoNdZjdNbnESHWHnJbq/jTFhBCbJNSOkzU3uZ66K1Fp9WQFBvGMzMGOBwaPzNjAKN6xPrRwpaj02qI0GqICNax56/Ta3/8xZVGSqoMlFRZHxdXGimusgpBcaWB4iojJVVGiiqtYmW0jXZMFutjYx0hc2NE3CR6ragVh9Cg0391GmENMbX+QwgQCDQa61+7Pggh6uyH8GAdQTpNrb1Gs9Vmk02Urc9PPzaZ7Y0rtgbX+t5MFgsWCxjMzfte/YFWI4gOtboMokP1RIXq6RodSlSojqgQPVlFlaw7XEBJlZEO4UFcP647M4Z2JTLE2rMNsTWwdYW2vUe5nEmccT30uqgvsvuYLadFsW4P1i6g1UbrkN7eg63vLzXXHlNlNFNlOD2crzJY/5rMsraHKgHq9Fgtsm5v1fpAYt1eUWOuDSvTa0XtaCLINqKo91wr0GqsIwxNnTkR+3+NEARprXMmQfYRiO70KMQ+WrHPqVQbzVQazBjNltrXaxvMp2hsjzUa6m2zj5JCg7RoRP1Gy+5mszZcdRow1es9o1E9dCecKRN1nsQqVNZhtUKhCCwC25GpUCgUCpdRgq5QKBTtBCXoCoVC0U5Qgq5QKBTtBCXoCoVC0U7wW9iiECIfOOaXi0M8cMpP13YVZaNnUDZ6BmWjZ/CEjT2klB0d7fCboPsTIcRWZ3GcgYKy0TMoGz2DstEzeNtG5XJRKBSKdoISdIVCoWgnnKmCPs/fBriAstEzKBs9g7LRM3jVxjPSh65QKBTtkTO1h65QKBTtDiXoCoVC0U5o14IuhJguhDgghDgshHjSwf7LhBA7hRBpQoitQohJgWZjnePGCCHMQogrfWmf7drN3cdzhRAltvuYJoT4c6DZWMfONCHEHiHEb4FmoxDisTr3cLft8/ZZVWIX7IsWQiwVQuyw3cNbfGWbGzbGCiEW2X7Xm4UQg/1g43whRJ4QYreT/UII8abtPewUQoz02MWllO3yP6AF0oFeQBCwAxjY4JgITs8jDAX2B5qNdY5bBSwHrgw0G4Fzge8D/LOOAfYC3W3PEwLNxgbHXwKsCiT7gKeBV22POwKFQFCA2fga8LztcQqw0g/fx3OAkcBuJ/svBn7Amup+PLDJU9duzz30scBhKeURKaUB+AK4rO4BUspyabvDQDjg6xniZm20cT+wEMjzpXE2XLXRn7hi4x+Bb6WUmQBSSl/fS3fv4x+Az31imRVX7JNApLBW2IjAKuimALNxILASQEq5H0gWQnTyoY1IKddgvTfOuAz4WFrZCMQIIbp44trtWdATgaw6z7Nt2+ohhLhcCLEfWAbc6iPb7DRroxAiEbgcmOtDu+ri0n0EzrINxX8QQgzyjWm1uGJjPyBWCPGrEGKbEOJGn1lnxdX7iBAiDJiOtRH3Fa7Y9zYwAMgFdgEPSCl9WavPFRt3AFcACCHGAj2AJJ9Y5zoufxfcpT0LuqM6XY164FLKRVLKFGAW8KLXraqPKza+ATwhpXRe8dm7uGLjdqz5JYYBbwGLvW5VfVyxUQeMAmYA04DnhBD9vG1YHVz6Ptq4BFgnpWyql+dpXLFvGpAGdAWGA28LIaK8bVgdXLFxDtaGOw3ryDYV344iXMGd74JbtOcSdNlAtzrPk7D2LBwipVwjhOgthIiXUvoqwY8rNo4GvrDVkYwHLhZCmKSUvhLNZm2UUpbWebxcLzmXCAAAAtNJREFUCPFuAN7HbOCUlLICqBBCrAGGAQd9Y6Jb38dr8a27BVyz7xZgjs1NeVgIkYHVT73ZNya6/F28BayTj0CG7X8g4ZY2uYWvJwx8ODGhA44APTk9gTKowTF9OD0pOhLIsT8PFBsbHP8Rvp8UdeU+dq5zH8cCmYF2H7G6Clbajg0DdgODA8lG23HRWP2v4QH4Ob8HvGB73Mn2e4kPMBtjsE3UAndg9VX77D7WsSMZ55OiM6g/KbrZU9dttz10KaVJCHEfsALr7Ph8KeUeIcRdtv1zgdnAjUIII1AFXCNtdzyAbPQrLtp4JXC3EMKE9T5eG2j3UUq5TwjxI7ATsAAfSCkdhpX5y0bboZcDP0nrSMJnuGjfi8BHQohdWMXoCem7UZirNg4APhZCmLFGNd3mK/vsCCE+xxr5FS+EyAaeB/R1bFyONdLlMFCJbUThkWv78HenUCgUCi/SnidFFQqF4oxCCbpCoVC0E5SgKxQKRTtBCbpCoVC0E5SgKxQKhQ9oLmmXg+OvFkLstSVCW+DSa1SUi0KhUHgfIcQ5QDnW2Pgms0AKIfoCXwFTpZRFQogE6UL+IdVDVygUCh8gHSTtsq1O/9GWX+h3IUSKbdcdwDtSyiLba11KJqcEXaFQKPzHPOB+KeUo4FHgXdv2fkA/IcQ6IcRGIcR0V07WbleKKhQKRSAjhIgAJgBf23I1AQTb/uqAvlhXnCYBvwshBkspi5s6pxJ0hUKh8A8aoFhKOdzBvmxgo5TSCGQIIQ5gFfgtzZ1QoVAoFD5GWjNDZgghroLa0nTDbLsXA1Ns2+OxumCONHdOJegKhULhA2xJuzYA/YUQ2UKI24DrgNuEEDuAPZyuwLQCKBBC7AVWA49JKQuavYYKW1QoFIr2geqhKxQKRTtBCbpCoVC0E5SgKxQKRTtBCbpCoVC0E5SgKxQKRTtBCbpCoVC0E5SgKxQKRTvh/wEe9jduaFvUwwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(*simulations[23].T)\n", + "geopandas.GeoDataFrame(geometry=[state]).boundary.plot(ax=plt.gca())" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -931,12 +1229,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -952,6 +1250,27 @@ "genv.plot()" ] }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'GtestResult' object has no attribute 'pvalues'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mripley\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg_test\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msimulations\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhull\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpvalues\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'GtestResult' object has no attribute 'pvalues'" + ] + } + ], + "source": [ + "ripley.g_test(simulations[10], hull=state).pvalues" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -961,17 +1280,17 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0. , 0. , 0.1 , 0.32, 0.52, 0.68, 0.81, 0.87, 0.92, 0.95, 0.96,\n", - " 0.97])" + "array([0. , 0.04, 0.25, 0.55, 0.76, 0.88, 0.93, 0.96, 0.97, 0.98, 0.98,\n", + " 0.98])" ] }, - "execution_count": 36, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -982,17 +1301,17 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0. , 0.14, 0.35, 0.54, 0.72, 0.85, 0.92, 0.97, 0.99, 1. , 1. ,\n", + "array([0. , 0.2 , 0.51, 0.73, 0.9 , 0.96, 0.99, 1. , 1. , 1. , 1. ,\n", " 1. ])" ] }, - "execution_count": 37, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1010,12 +1329,12 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1040,12 +1359,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1070,12 +1389,12 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1100,12 +1419,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 489bd33004f4cba9f8ab0cf77492ffa50b4654bb Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 1 Jun 2020 14:20:50 +0100 Subject: [PATCH 14/67] move to using volume for scipy convex hulls --- pointpats/ripley.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 3cd4359..c03ef8b 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -23,11 +23,20 @@ def _area(shape): If a shape has an area attribute, return it. Works for: shapely.geometry.Polygon - scipy.spatial.ConvexHull """ return shape.area +@singledispatch +def _area(shape: spatial.ConvexHull): + """ + If a shape is a convex hull from scipy, + assure it's 2-dimensional and then use its volume. + """ + assert shape.points.shape[1] == 2 + return shape.volume + + @_area.register def _(shape: numpy.ndarray): """ From a2b34b9a737003281bbc31319d25676c4a100c8c Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 1 Jun 2020 14:21:30 +0100 Subject: [PATCH 15/67] fix docs & add __all__ --- pointpats/ripley.py | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index c03ef8b..0ed553b 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -6,6 +6,21 @@ from libpysal.cg import alpha_shape_auto from libpysal.cg.kdtree import Arc_KDTree +__all__ = [ + "simulate", + "simulate_from", + "f_function", + "g_function", + "k_function", + "j_function", + "l_function", + "f_test", + "g_test", + "k_test", + "j_test", + "l_test", +] + ### Utilities and dispatching TREE_TYPES = (spatial.KDTree, spatial.cKDTree, Arc_KDTree) @@ -527,9 +542,8 @@ def g_function( tuple, encoding (stop,), (start, stop), or (start, stop, num) int, encoding number of equally-spaced intervals numpy.ndarray, used directly within numpy.histogram - distances: numpy.ndarray, (n, p) or (p,) - distances from every point in a random point set of size p - to some point in `coordinates` + distances: numpy.ndarray, (n, n) or (n,) + distances from every point in the point to another point in `coordinates` metric: str or callable distance metric to use when building search tree edge_correction: bool or str From e650ad01fbde99ba7d542fd3f3619ec0046bbbac Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 1 Jun 2020 14:21:57 +0100 Subject: [PATCH 16/67] since _k_neighbors removes self-neighbors, we need to use k=1 for the g_function --- pointpats/ripley.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 0ed553b..cab0d95 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -595,7 +595,7 @@ def g_function( except NameError: tree = _build_best_tree(coordinates, metric) finally: - distances, indices = _k_neighbors(tree, coordinates, k=2) + distances, indices = _k_neighbors(tree, coordinates, k=1) counts, bins = numpy.histogram(distances.squeeze(), bins=support) fracs = numpy.cumsum(counts) / counts.sum() From 2e8273dd1da0c8db4aa506b4fcb20588f21ec9c5 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 1 Jun 2020 17:10:28 +0100 Subject: [PATCH 17/67] code hygene and correctness changes --- pointpats/ripley.py | 106 ++++++++++++++++++++++++++++++-------------- 1 file changed, 72 insertions(+), 34 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index cab0d95..116b7d3 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -21,7 +21,9 @@ "l_test", ] -### Utilities and dispatching +# ------------------------------------------------------------# +# Utilities and dispatching # +# ------------------------------------------------------------# TREE_TYPES = (spatial.KDTree, spatial.cKDTree, Arc_KDTree) try: @@ -42,8 +44,8 @@ def _area(shape): return shape.area -@singledispatch -def _area(shape: spatial.ConvexHull): +@_area.register +def _(shape: spatial.qhull.ConvexHull): """ If a shape is a convex hull from scipy, assure it's 2-dimensional and then use its volume. @@ -69,7 +71,7 @@ def _bbox(shape): Works for: shapely.geometry.Polygon """ - return shape.bounds + return _bbox(numpy.asarray(shape)) @_bbox.register @@ -84,7 +86,7 @@ def _(shape: numpy.ndarray): @_bbox.register -def _(shape: spatial.ConvexHull): +def _(shape: spatial.qhull.ConvexHull): """ For scipy.spatial.ConvexHulls, compute the bounding box from their boundary points. @@ -124,23 +126,23 @@ def _(shape: spatial.Delaunay, x: float, y: float): If the returned simplex index is -1, then the point is not within a simplex of the triangulation. """ - return delaunay.find_simplex((x, y)) > 0 + return shape.find_simplex((x, y)) > 0 @_contains.register -def _(shape: spatial.ConvexHull, x: float, y: float): +def _(shape: spatial.qhull.ConvexHull, x: float, y: float): """ For convex hulls, convert their exterior first into a Delaunay triangulation and then use the delaunay dispatcher. """ exterior = shape.points[shape.vertices] delaunay = spatial.Delaunay(exterior) - return _contains(x, y, delaunay) + return _contains(delaunay, x, y) try: from shapely.geometry.base import BaseGeometry as _BaseGeometry - from shapely.geometry import Point as _ShapelyPoint + from shapely.geometry import Point as _ShapelyPoint, Polygon as _ShapelyPolygon HAS_SHAPELY = True @@ -154,6 +156,14 @@ def _( """ return shape.contains(_ShapelyPoint((x, y))) + @_bbox.register + def _(shape: _ShapelyPolygon): + """ + If a shape is an array of points, compute the minima/maxima + or let it pass through if it's 1 dimensional & length 4 + """ + return numpy.asarray(list(shape.bounds)) + except ModuleNotFoundError: HAS_SHAPELY = False @@ -192,6 +202,10 @@ def _(shape: pygeos.Geometry): except ModuleNotFoundError: HAS_PYGEOS = False +# ------------------------------------------------------------# +# Constructors for trees, prepared inputs, & neighbors # +# ------------------------------------------------------------# + def _build_best_tree(coordinates, metric): """ @@ -211,13 +225,25 @@ def _build_best_tree(coordinates, metric): elif metric in BallTree.valid_metrics: tree = lambda coordinates: BallTree(coordinates, metric=metric) elif callable(metric): - warnings.Warn( + warnings.warn( "Distance metrics defined in pure Python may " - " have unacceptable performance!" + " have unacceptable performance!", + stacklevel=2, ) tree = lambda coordinates: BallTree(coordinates, metric=metric) - except ModuleNotFoundError: - pass + else: + raise KeyError( + f"Metric {metric} not found in set of available types." + f"BallTree metrics: {BallTree.valid_metrics}, and" + f"scikit KDTree metrics: {KDTree.valid_metrics}." + ) + except ModuleNotFoundError as e: + if metric not in ("l2", "euclidean"): + raise KeyError( + f"Metric {metric} requested, but this requires" + f" scikit-learn to use. Without scikit-learn, only" + f" euclidean distance metric is supported." + ) return tree(coordinates) @@ -230,15 +256,13 @@ def _prepare_hull(coordinates, hull): - a shapely shape using alpha_shape_auto """ if (hull is None) or (hull == "bbox"): - return numpy.array( - [*numpy.min(coordinates, axis=0), *numpy.max(coordinates, axis=0)] - ) + return _bbox(coordinates) if isinstance(hull, numpy.ndarray): assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" assert hull.ndim == 1, f"bounding box provided is not shaped correctly! {hull}" return hull if HAS_SHAPELY: # protect the isinstance check if import has failed - if isinstance(hull, shapely.geometry.Polygon): + if isinstance(hull, _ShapelyPolygon): return hull if HAS_PYGEOS: if isinstance(hull, pygeos.Geometry): @@ -248,7 +272,8 @@ def _prepare_hull(coordinates, hull): return spatial.ConvexHull(coordinates) elif hull.startswith("alpha") or hull.startswith("α"): return alpha_shape_auto(coordinates) - + elif isinstance(hull, spatial.qhull.ConvexHull): + return hull raise ValueError( f"Hull type {hull} not in the set of valid options:" f" (None, 'bbox', 'convex', 'alpha', 'α', " @@ -298,10 +323,11 @@ def _prepare(coordinates, support, distances, metric, hull, edge_correction): f"`metric` argument must be callable or a string. Recieved: {metric}" ) if distances is not None and metric != "euclidean": - warnings.Warn( + warnings.warn( "Distances were provided. The specified metric will be ignored." " To use precomputed distances with a custom distance metric," - " do not specify a `metric` argument." + " do not specify a `metric` argument.", + stacklevel=2, ) metric = "euclidean" @@ -319,7 +345,7 @@ def _prepare(coordinates, support, distances, metric, hull, edge_correction): support = numpy.linspace(0, support[0], num=20) # default support n bins elif len(support) == 2: support = numpy.linspace(*support, num=20) # default support n bins - elif len(support == 3): + elif len(support) == 3: support = numpy.linspace(support[0], support[1], num=support[2]) else: # try to use it as is try: @@ -352,7 +378,9 @@ def _k_neighbors(tree, coordinates, k, **kwargs): return distances, indices -### simulators +# ------------------------------------------------------------# +# Simulators # +# ------------------------------------------------------------# def simulate(hull, intensity=None, size=None): @@ -380,8 +408,7 @@ def simulate(hull, intensity=None, size=None): n_observations = 100 n_replications = 1 size = (n_observations, n_replications) - - if isinstance(size, tuple): + elif isinstance(size, tuple): if len(size) == 2 and intensity is None: n_observations, n_replications = size intensity = n_observations / _area(hull) @@ -402,10 +429,15 @@ def simulate(hull, intensity=None, size=None): f" to the number of replications." f" Recieved: `intensity={intensity}, size={size}`" ) - elif intensity is not None and isinstance(size, int): + elif isinstance(size, int): # assume int size with specified intensity means n_replications at x intensity - n_observations = int(intensity * _area(hull)) - n_replications = size + if intensity is not None: + n_observations = int(intensity * _area(hull)) + n_replications = size + else: # assume we have one replication at the specified number of points + n_replications = 1 + n_observations = size + intensity = n_observations / _area(hull) else: raise ValueError( f"Intensity and size not understood. Provide size as a tuple" @@ -457,7 +489,9 @@ def simulate_from(coordinates, hull=None, size=None): return simulate(hull, intensity=None, size=(n_observations, n_replications)) -### Ripley's functions +# ------------------------------------------------------------# +# Statistical Functions # +# ------------------------------------------------------------# def f_function( @@ -493,13 +527,14 @@ def f_function( if distances.ndim == 2: k, p = distances.shape if k == p == n: - warnings.Warn( + warnings.warn( f"A full distance matrix is not required for this function, and" f" the intput matrix is a square {n},{n} matrix. Only the" f" distances from p random points to their nearest neighbor within" f" the pattern is required, as an {n},p matrix. Assuming the" f" provided distance matrix has rows pertaining to input" - f" pattern and columns pertaining to the output points." + f" pattern and columns pertaining to the output points.", + stacklevel=2, ) distances = distances.min(axis=0) elif k == n: @@ -556,10 +591,11 @@ def g_function( if distances is not None: if distances.ndim == 2: if distances.shape[0] == distances.shape[1] == coordinates.shape[0]: - warnings.Warn( + warnings.warn( "The full distance matrix is not required for this function," " only the distance to the nearest neighbor within the pattern." - " Computing this and discarding the rest." + " Computing this and discarding the rest.", + stacklevel=2, ) distances = distances.min(axis=1) else: @@ -680,7 +716,7 @@ def j_function( f"requested {support} bins to evaluate the J function, but" f" it reaches infinity at d={gsupport[first_inf]:.4f}, meaning only" f" {first_inf} bins will be used to characterize the J function.", - stacklevel=1, + stacklevel=2, ) else: first_inf = len(gsupport) + 1 @@ -779,7 +815,9 @@ def l_function( return support, numpy.sqrt(k_estimate / numpy.pi) - linearized * support -### Ripley tests +# ------------------------------------------------------------# +# Statistical Tests based on Ripley Functions # +# ------------------------------------------------------------# FtestResult = namedtuple( "FtestResult", ("support", "statistic", "pvalue", "reference_distribution") From a7e68e07507256ccc260fc8503a168862007e31b Mon Sep 17 00:00:00 2001 From: ljwolf Date: Tue, 2 Jun 2020 18:14:46 +0100 Subject: [PATCH 18/67] move the bbox comparison around to catch the array and avoid warnings --- pointpats/ripley.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 116b7d3..d1cdc58 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -255,12 +255,12 @@ def _prepare_hull(coordinates, hull): - a scipy.spatial.ConvexHull object from the Qhull library - a shapely shape using alpha_shape_auto """ - if (hull is None) or (hull == "bbox"): - return _bbox(coordinates) if isinstance(hull, numpy.ndarray): assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" assert hull.ndim == 1, f"bounding box provided is not shaped correctly! {hull}" return hull + if (hull is None) or (hull == "bbox"): + return _bbox(coordinates) if HAS_SHAPELY: # protect the isinstance check if import has failed if isinstance(hull, _ShapelyPolygon): return hull From bfbeab8307d86ffd3349f47fd4548f68742c489a Mon Sep 17 00:00:00 2001 From: ljwolf Date: Tue, 2 Jun 2020 18:15:54 +0100 Subject: [PATCH 19/67] fix linearization in the l function --- pointpats/ripley.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index d1cdc58..50d2931 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -799,7 +799,7 @@ def l_function( edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. linearized : bool - whether or not to subtract the expected value from l at each + whether or not to subtract l from its expected value (support) at each distance bin. This centers the l function on zero for all distances. Proposed by Besag (1977) #TODO: fix besag ref """ @@ -812,7 +812,11 @@ def l_function( edge_correction=edge_correction, ) - return support, numpy.sqrt(k_estimate / numpy.pi) - linearized * support + l = numpy.sqrt(k_estimate / numpy.pi) + + if linearized: + return support, support - l + return support, l # ------------------------------------------------------------# From 5834930efc0c6372dd528084fee65f5d530b8e83 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Tue, 2 Jun 2020 18:16:44 +0100 Subject: [PATCH 20/67] move to replications instead of reference_distribution --- .../distance_statistics-numpy-oriented.ipynb | 24 +++++++++---------- pointpats/ripley.py | 20 ++++++++-------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb index e6a4112..d2480a6 100644 --- a/notebooks/distance_statistics-numpy-oriented.ipynb +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -580,7 +580,7 @@ " 0.19047619, 0.19047619, 0.28571429, 0.47619048, 0.57142857,\n", " 0.76190476, 0.85714286, 0.95238095, 0.95238095, 1. ]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3179, 0.1553, 0.0608,\n", " 0.0189, 0.0252, 0.0058, 0.002 , 0.0014, 0.0084, 0.0102, 0.075 ,\n", - " 0.1346, 0.3083, 0.1204, 0. ]), reference_distribution=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0.1346, 0.3083, 0.1204, 0. ]), replications=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", " 0. ],\n", " [0. , 0. , 0. , ..., 0. , 0. ,\n", " 0. ],\n", @@ -625,7 +625,7 @@ ], "source": [ "plt.fill_between(g_test.support, \n", - " *np.percentile(g_test.reference_distribution, \n", + " *np.percentile(g_test.replications, \n", " q=(2.5, 97.5), axis=1),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(g_test.support, g_test.statistic, color='orangered', label='Observed')\n", @@ -680,7 +680,7 @@ " 0.775, 0.869, 0.931, 0.971, 0.997, 1. , 1. , 1. , 1. ,\n", " 1. , 1. ]), pvalue=array([0. , 0.0409, 0.013 , 0.0082, 0.0718, 0.1941, 0.3569, 0.4831,\n", " 0.2651, 0.0693, 0.0267, 0.0136, 0.008 , 0.002 , 0.0042, 0.0211,\n", - " 0.0604, 0.1262, 0.2283, 0. ]), reference_distribution=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0.0604, 0.1262, 0.2283, 0. ]), replications=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", " 0. ],\n", " [0.01003009, 0.01484624, 0.015 , ..., 0.01778243, 0.0167364 ,\n", " 0.0079096 ],\n", @@ -725,7 +725,7 @@ ], "source": [ "plt.fill_between(f_test.support, \n", - " *np.percentile(f_test.reference_distribution, \n", + " *np.percentile(f_test.replications, \n", " q=(2.5, 97.5), axis=1),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(f_test.support, f_test.statistic, color='orangered',\n", @@ -781,7 +781,7 @@ " 2.85388128, 3.86597938, 6.30252101, 12.29508197,\n", " 26.51515152, 208.33333333]), pvalue=array([0.000e+00, 9.720e-02, 3.000e-01, 4.309e-01, 2.423e-01, 2.479e-01,\n", " 1.459e-01, 6.450e-02, 1.790e-02, 1.160e-02, 4.300e-03, 1.500e-03,\n", - " 1.000e-03, 1.000e-04]), reference_distribution=array([[1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1.000e-03, 1.000e-04]), replications=array([[1. , 1. , 1. , ..., 1. , 1. ,\n", " 1. ],\n", " [1.01425439, 1.01754386, 1.01853871, ..., 1.02073171, 1.01914414,\n", " 1.01380898],\n", @@ -826,7 +826,7 @@ ], "source": [ "plt.fill_between(j_test.support, \n", - " *np.percentile(j_test.reference_distribution, \n", + " *np.percentile(j_test.replications, \n", " q=(2.5, 97.5), axis=1),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(j_test.support, j_test.statistic, color='orangered',\n", @@ -884,7 +884,7 @@ " 318.25833333, 530.43055556, 636.51666667, 848.68888889,\n", " 1060.86111111, 1273.03333333, 1273.03333333, 1273.03333333]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3985, 0.2023, 0.0788,\n", " 0.0232, 0.0451, 0.0097, 0.001 , 0.0029, 0.031 , 0.0352, 0.1081,\n", - " 0.2332, 0.3624, 0.1898, 0.0815]), reference_distribution=array([[ 0. , 0. , 0. , ..., 0. ,\n", + " 0.2332, 0.3624, 0.1898, 0.0815]), replications=array([[ 0. , 0. , 0. , ..., 0. ,\n", " 0. , 0. ],\n", " [ 0. , 0. , 0. , ..., 0. ,\n", " 0. , 0. ],\n", @@ -929,10 +929,10 @@ ], "source": [ "plt.plot(k_test.support, \n", - " k_test.reference_distribution, \n", + " k_test.replications, \n", " color='k', alpha=.01)\n", "plt.plot(k_test.support, \n", - " k_test.reference_distribution[:,0], \n", + " k_test.replications[:,0], \n", " color='k', label='Simulations')\n", "plt.plot(k_test.support, k_test.statistic, color='orangered',\n", " label='Observed')\n", @@ -990,7 +990,7 @@ " -11.8073359 , -10.70116577, -11.28365896, -10.90433326,\n", " -10.7870093 , -10.85579328, -12.67849021, -14.50118714]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4021, 0.2052, 0.0869,\n", " 0.0273, 0.0449, 0.0112, 0.0021, 0.0027, 0.0314, 0.0342, 0.1121,\n", - " 0.2296, 0.364 , 0.1906, 0.0819]), reference_distribution=array([[ 0. , 0. , 0. , ..., 0. ,\n", + " 0.2296, 0.364 , 0.1906, 0.0819]), replications=array([[ 0. , 0. , 0. , ..., 0. ,\n", " 0. , 0. ],\n", " [ -1.82269693, -1.82269693, -1.82269693, ..., -1.82269693,\n", " -1.82269693, 2.58715172],\n", @@ -1035,10 +1035,10 @@ ], "source": [ "plt.plot(l_test.support, \n", - " l_test.reference_distribution, \n", + " l_test.replications, \n", " color='k', alpha=.01)\n", "plt.plot(l_test.support, \n", - " l_test.reference_distribution[:,0], \n", + " l_test.replications[:,0], \n", " color='k', label='Simulations')\n", "plt.plot(l_test.support, l_test.statistic, color='orangered',\n", " label='Observed')\n", diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 50d2931..4a556a8 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -824,19 +824,19 @@ def l_function( # ------------------------------------------------------------# FtestResult = namedtuple( - "FtestResult", ("support", "statistic", "pvalue", "reference_distribution") + "FtestResult", ("support", "statistic", "pvalue", "replications") ) GtestResult = namedtuple( - "GtestResult", ("support", "statistic", "pvalue", "reference_distribution") + "GtestResult", ("support", "statistic", "pvalue", "replications") ) JtestResult = namedtuple( - "JtestResult", ("support", "statistic", "pvalue", "reference_distribution") + "JtestResult", ("support", "statistic", "pvalue", "replications") ) KtestResult = namedtuple( - "KtestResult", ("support", "statistic", "pvalue", "reference_distribution") + "KtestResult", ("support", "statistic", "pvalue", "replications") ) LtestResult = namedtuple( - "LtestResult", ("support", "statistic", "pvalue", "reference_distribution") + "LtestResult", ("support", "statistic", "pvalue", "replications") ) _ripley_dispatch = { @@ -939,7 +939,7 @@ def f_test( whether or not to conduct edge correction. Not yet implemented. keep_replications: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's reference_distribution attribute + will be returned as the result's replications attribute n_replications: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. @@ -986,7 +986,7 @@ def g_test( whether or not to conduct edge correction. Not yet implemented. keep_replications: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's reference_distribution attribute + will be returned as the result's replications attribute n_replications: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. @@ -1032,7 +1032,7 @@ def j_test( whether or not to conduct edge correction. Not yet implemented. keep_replications: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's reference_distribution attribute + will be returned as the result's replications attribute n_replications: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. @@ -1078,7 +1078,7 @@ def k_test( whether or not to conduct edge correction. Not yet implemented. keep_replications: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's reference_distribution attribute + will be returned as the result's replications attribute n_replications: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. @@ -1125,7 +1125,7 @@ def l_test( whether or not to conduct edge correction. Not yet implemented. keep_replications: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's reference_distribution attribute + will be returned as the result's replications attribute n_replications: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. From f11e881d6f52f2b3a913fe7b07cd959f4498aa34 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Tue, 2 Jun 2020 18:17:08 +0100 Subject: [PATCH 21/67] fix empty space distribution with inputted distances --- pointpats/ripley.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 4a556a8..e9146b3 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -861,19 +861,22 @@ def _ripley_test( **kwargs, ): stat_function, result_container = _ripley_dispatch.get(calltype) - core_kwargs = dict(support=None, metric="euclidean", edge_correction=None,) + core_kwargs = dict(support=support, metric=metric, edge_correction=edge_correction,) tree = _build_best_tree(coordinates, metric=metric) if calltype in ("F", "J"): # these require simulations core_kwargs["hull"] = hull # amortize to avoid doing this every time empty_space_points = simulate_from(coordinates, size=(1000, 1)) - empty_space_distances, _ = _k_neighbors(tree, empty_space_points, k=1) - if calltype == "F": - distances = empty_space_distances.squeeze() - else: # calltype == 'J': - n_distances, _ = _k_neighbors(tree, coordinates, k=1) - distances = (n_distances.squeeze(), empty_space_distances.squeeze()) + if distances is None: + empty_space_distances, _ = _k_neighbors(tree, empty_space_points, k=1) + if calltype == "F": + distances = empty_space_distances.squeeze() + else: # calltype == 'J': + n_distances, _ = _k_neighbors(tree, coordinates, k=1) + distances = (n_distances.squeeze(), empty_space_distances.squeeze()) + else: + pass core_kwargs.update(**kwargs) observed_support, observed_statistic = stat_function( From 650a252ef8d4f6e0030f3684f6f7c81c500bd92d Mon Sep 17 00:00:00 2001 From: ljwolf Date: Tue, 2 Jun 2020 18:17:32 +0100 Subject: [PATCH 22/67] shape replications better & use truncation in supports --- pointpats/ripley.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index e9146b3..8d970d9 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -910,7 +910,7 @@ def _ripley_test( observed_support, observed_statistic, pvalues, - replications.T if keep_replications else None, + replications if keep_replications else None, ) @@ -1014,6 +1014,7 @@ def j_test( metric="euclidean", hull=None, edge_correction=None, + truncate=True, keep_replications=False, n_replications=9999, ): @@ -1050,6 +1051,7 @@ def j_test( edge_correction=edge_correction, keep_replications=keep_replications, n_replications=n_replications, + truncate=truncate, ) From 2ae135766872d44096ce9557f61895d03d1eda7a Mon Sep 17 00:00:00 2001 From: ljwolf Date: Fri, 5 Jun 2020 14:47:06 +0100 Subject: [PATCH 23/67] fix geometry typedispatching --- pointpats/ripley.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 8d970d9..2bba10c 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -142,7 +142,7 @@ def _(shape: spatial.qhull.ConvexHull, x: float, y: float): try: from shapely.geometry.base import BaseGeometry as _BaseGeometry - from shapely.geometry import Point as _ShapelyPoint, Polygon as _ShapelyPolygon + from shapely.geometry import Point as _ShapelyPoint HAS_SHAPELY = True @@ -157,7 +157,7 @@ def _( return shape.contains(_ShapelyPoint((x, y))) @_bbox.register - def _(shape: _ShapelyPolygon): + def _(shape: _BaseGeometry): """ If a shape is an array of points, compute the minima/maxima or let it pass through if it's 1 dimensional & length 4 From 5882077f8e7b860ab5217fa94334da3276ce5f5e Mon Sep 17 00:00:00 2001 From: ljwolf Date: Fri, 5 Jun 2020 14:47:13 +0100 Subject: [PATCH 24/67] flip linearized --- pointpats/ripley.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 2bba10c..0428f45 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -815,7 +815,7 @@ def l_function( l = numpy.sqrt(k_estimate / numpy.pi) if linearized: - return support, support - l + return support, l - support return support, l From 02e7b5901315f30f663fe26b76926cf738e5311d Mon Sep 17 00:00:00 2001 From: ljwolf Date: Fri, 5 Jun 2020 14:48:03 +0100 Subject: [PATCH 25/67] update work in progress notebooks --- .../distance_statistics-numpy-oriented.ipynb | 307 ++++++++++-------- 1 file changed, 163 insertions(+), 144 deletions(-) diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb index d2480a6..fb69b0f 100644 --- a/notebooks/distance_statistics-numpy-oriented.ipynb +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -108,7 +108,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -141,7 +141,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 5, @@ -150,7 +150,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -207,7 +207,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 7, @@ -216,7 +216,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -264,14 +264,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:656: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", - " warnings.warn(\n" + "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/ipykernel_launcher.py:1: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", + " \"\"\"Entry point for launching an IPython kernel.\n" ] }, { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -280,7 +280,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -338,7 +338,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -362,7 +362,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 11, @@ -371,7 +371,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -405,7 +405,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEWCAYAAACNJFuYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3dd3hUZfr/8fedTgoQSKEEEkpCrxmwwLoWVGyInSKwSlGWtX3tHdeyu+q6roqFogsoKK6i2AXLItiYUEMLgRB6CgHSSEKS5/fHjP4iCZKQmTkzmft1XXOZzJw555NxmHvOc+5zHjHGoJRSStUUYHUApZRS3keLg1JKqVq0OCillKpFi4NSSqlatDgopZSqRYuDUkqpWrQ4KJ8kIkkiYkQkyPn7ZyIywepcp0pEnhCRfBE54OHtvioiD3tym8o3iJ7noKwkIjuBScaYZQ18XhKQBQQbYyob8DwDJBtjMhuyPXcSkQ5ABpBojMl143b+hOO1HuqubaimQ/cclLJeInDQnYVBqYbS4qB8gogEisizzqGXHcAlxz3+rYhMcv7cVUT+JyJHnMu/47x/uXPxdSJSLCLXiUi0iHwsInkicsj5c8Jx631cRFaKSJGIfCkiMTUeHyoi34vIYRHZ7fx2joiEOvPuEpEc5/BNszr+rmHAUqCdM9N/RORsEdlz3HI7ncsiItNFZJGIzHNm2igithrLdhCR951/00EReUlEegCvAmc4t3PYuex/ROSJGs+dLCKZIlIgIktEpF2Nx4yI3Cwi25yv1QwRkQb9j1Q+Q4uD8hWTgUuBAYANuPp3ln0c+BKIBhKAFwGMMWc5H+9njIk0xryD49/AGzi+vXcEjgIvHbe+McANQBwQAtwFICIdgc+c648F+gNrnc/5B5DivK8r0B545PigzuG0i4B9zkx/Oukr4TACeBtoCSz5JbOIBAIfA9lAknO7bxtjNgM3Az84t9Py+BWKyLnA34BrgbbOdbx93GKXAoOAfs7lLqxnXuVjtDgoX3Et8LwxZrcxpgDHh9iJHMPxYd/OGFNmjFlxogWNMQeNMe8ZY0qNMUXAk8Afj1vsDWNMhjHmKLAIxwc+wFhgmTFmoTHmmHNda53fpicDdxhjCpzrfQoYdSp/+AmsMMZ8aoypAubj+LAGGAy0A+42xpSc7O8/zljgdWPMamNMOXA/jj2NpBrL/N0Yc9gYswv4hv//WqgmRouD8hXtgN01fs/+nWXvAQT42TnkcuOJFhSRcBF5TUSyRaQQWA60dH4D/0XNDqJSINL5cwdgex2rjQXCgTTncNNh4HPn/a5yfKYwZ+dWByC7IQfpa2hHjdfVGFMMHMSx93Gi7UaimqQgqwMoVU/7cXzw/aLjiRY0xhzA8c0dERkKLBOR5SfoULoT6AacZow5ICL9gTU4isvJ7MbxTf14+TiGp3oZY/bWYz3HK8FRXIBfh4rqW1h2Ax1FJKiOAnGy1sR9OPa4ftluBNAaOJW/Qfk43XNQ3iBYRMJq3Or60rIIuFVEEkQkGrjvRCsTkWtqHFQ+hONDscr5ew7QucbiUTg+yA+LSCvg0QbkfgsYJiLXikiQiLQWkf7GmGpgFvAvEYlzZmovIvUdn8/AsSdwiYgEAw8BofV87s84CunfRSTC+XoOcT6WAySISMgJnrsAuEFE+otIKI6hsJ+MMTvruW3VhGhxUN7gUxwf0L/cptexzCzgC2AdsBp4/3fWNwj4SUSKcRysvc0Yk+V8bDow1znccy3wPNAMx7f9H3EM/9SLc9z9Yhx7HwU4Dkb/MvZ/L5AJ/OgcrlqGYw+lPus9AvwZmI3jW3sJsOd3n/T/n1sFXIbjIPgu5/Oucz78NbAROCAi+XU89yvgYeA9HAWmC649TqJ8iJ4Ep5RSqhbdc1BKKVWLFgellFK1aHFQSilVixYHpZRStTSJ8xxiYmJMUlKS1TGUUsqnpKWl5Rtj6jyHpkkUh6SkJOx2u9UxlFLKp4jICa80oMNKSimlatHioJRSqhYtDkoppWrR4qCUUqoWLQ5KKaVq8driICLDRWSrc8rCE16BUymllOt5ZXFwXr9+Bo7pE3sCo0Wkp7WplFLKf3hlccAxgUqmMWaHMaYCxzy2l7t6I8XllUxfspEjR4+5etVKKeXTvLU4tOe3U0Lu4bdTFSIiU0TELiL2vLy8U9rI1gNFvPljNrcsXENlVfWpp1VKqSbGW4tDXVM0/mbiCWPMTGOMzRhji409tal5UxOjeWJkb5Zn5PHUp1tOaR1KKdUUeevlM/bw2/mCE3DMb+tyowZ3JCOnmNdXZpESH8mowSecmlgppfyGt+45rAKSRaSTc77bUTime3SLBy7uzlkpsTz0QTo/7jjors0opZTP8MriYIypBP6CY87gzcAiY8xGd20vKDCAl8YMILF1OFPfTGPXwVJ3bUoppXyCVxYHAGPMp8aYFGNMF2PMk+7eXvOwYOZMGES1gYlzV1FUph1MSin/5bXFwQpJMRG8MnYgWfkl3Pb2WqqqzcmfpJRSTZAWh+Oc2TWG6SN68fWWXP7xuXYwKaX8k7d2K1nq+tMTycgpYubyHSTHRXKNrcPJn6SUUk2I7jmcwCOX9mRo1xgeXJyOfWeB1XGUUsqjtDicQFBgADPGDKR9dDNump/G7gLtYFJK+Q8tDr+jRXgwsyfYqKiqZvI8OyXllVZHUkopj9DicBJdYiOZMWYg23KLuf2dtVRrB5NSyg9ocaiHs1JiefiSHizdlMOzX261Oo5SSrmddivV04Qzk8jILeblb7eTHB/JFQMSrI6klFJuo3sO9SQiPDaiF6d3bsW9721g9a5DVkdSSim30eLQAMGBAbwyNpU2zcOYMi+NfYePWh1JKaXcQotDA0VHhDBngo3yY1VMmmuntEI7mJRSTY8Wh1OQHB/FC2MGsOVAIXcuWqcdTEqpJkeLwyk6p1scD1zcg8/SD/D8sgyr4yillEtpt1IjTBzaiYycIl74OpPk+Cgu69fO6khKKeUSuufQCCLC4yN7MygpmrveXce63YetjqSUUi6hxaGRQoMCefX6VGIiQ5k8z86BI2VWR1JKqUbT4uACrSNDmfMnGyXllUyZb+doRZXVkZRSqlG0OLhI9zbN+feoAWzYe4S7/7sOY7SDSSnlu7Q4uNCwnvHcO7w7H6/fz4tfZ1odRymlTpl2K7nYTWd1JiOniOeWZpAcF8lFfdpaHUkppRpM9xxcTER46oo+DOzYkjsWrSV97xGrIymlVINpcXCDsOBAXhtno1V4CJPn2ckt1A4mpZRv8briICLPiMgWEVkvIotFpKXVmU5FbFQosybYOFx6jCnz0yg7ph1MSinf4XXFAVgK9DbG9AUygPstznPKerVrwb+u68fa3Ye577312sGklPIZXlccjDFfGmN+udTpj4BPz6ozvHdb7roghQ/W7uPlb7dbHUcpperF64rDcW4EPqvrARGZIiJ2EbHn5eV5OFbDTDunKyP6teOZL7by5cYDVsdRSqmTsqQ4iMgyEUmv43Z5jWUeBCqBt+pahzFmpjHGZoyxxcbGeir6KRERnr66L/0SWnD7O2vZtK/Q6khKKfW7LCkOxphhxpjeddw+BBCRCcClwFjTRAbqw4IDmTXeRvOwYCbPs5NfXG51JKWUOiGvG1YSkeHAvcAIY0yp1XlcKa55GLPG2zhYUs7N89Mor9QOJqWUd/K64gC8BEQBS0VkrYi8anUgV+qT0IJ/XtMfe/YhHng/XTuYlFJeyesun2GM6Wp1Bne7pG9bMnKS+fdX2+jWJpIpZ3WxOpJSSv2G1xUHf3Hbeclk5hbzt8+20CU2kvN6xFsdSSmlfuWNw0p+ISBAePaafvRq15xbF65h64EiqyMppdSvtDhYqFmIo4MpIjSISfNWUVBSYXUkpZQCtDhYrm2LZswcbyOnsJyb30yjorLa6khKKaXFwRv079CSZ67uy89ZBTzyoXYwKaWspwekvcTl/duzLaeYl77JJDk+iolDO1kdSSnlx3TPwYv83/kpXNgrnic/2cS3W3OtjqOU8mNaHLxIQIDw3LX96damObcsWENmrnYwKaWsocXBy0SEBjF7go3Q4AAmzrVzSDuYlFIW0OLghdq3bMZr42zsP1zGtAWrOValHUxKKc/S4uClUhOj+duVffh++0Ee+2ij1XGUUn5Gu5W82FWpCWTkFvHa/3aQEh/F+DOSrI6klPITuufg5e65sDvDesTx2Eeb+G6bd894p5RqOrQ4eLnAAOH5UQPoGhvJtLdWsyOv2OpISik/oMXBB0Q6O5iCAgOYNNfOkdJjVkdSSjVxWhx8RIdW4bx6fSq7D5Xyl4WrqdQOJqWUG2lx8CGDO7XiyZF9+G5bPk98stnqOEqpJky7lXzMtYM6kJFTxOwVWSTHRzL2tESrIymlmiDdc/BB91/cg7O7xfLohxv5fnu+1XGUUk2QFgcfFBggvDB6AEkxEfz5rdXszC+xOpJSqonR4uCjmocFM2eCDYBJ8+wUlmkHk1LKdbQ4+LDE1hG8PHYgO/NLuHXhGqqqdZIgpZRreG1xEJG7RMSISIzVWbzZmV1ieOzyXny7NY+/faodTEop1/DKbiUR6QCcD+yyOosvGHtaIttyin/tYLpuUEerIymlfJy37jn8C7gH0HGSenrokh78ITmGhz5I56cdB62Oo5TycV5XHERkBLDXGLPuJMtNERG7iNjz8vSCdEGBAbw0eiAdosOZ+tZqdheUWh1JKeXDLCkOIrJMRNLruF0OPAg8crJ1GGNmGmNsxhhbbGys+0P7gBbhwcyeYKOyqppJc+0Ul1daHUkp5aMsKQ7GmGHGmN7H34AdQCdgnYjsBBKA1SLSxoqcvqhzbCQvj00lM6+Y27SDSSl1irxqWMkYs8EYE2eMSTLGJAF7gIHGmAMWR/MpQ5NjePSynny1JZenv9hidRyllA/yym4l1XjjTk9k6wHnLHJxUVyVmmB1JKWUD/Hq4uDce1CnQESYPqIXWfkl3P/+BpJiwklNbGV1LKWUj/CqYSXlWsGBAbw8diBtW4Zx0/w09hzSDialVP1ocWjiWoaHMGeCjfJj1Uyel0aJdjCdkhnfZLJ4zR6rYyjlMVoc/EDXuCheHDOArQcKueOdtVRrB1ODZOYW8cwXW7lz0Tq+2ZJrdRylPEKLg584u1scD17Sky835fDc0gyr4/iU11fuJCQogJT4KG5ZuIZtOUVWR1LK7bQ4+JEbhyQxalAHXvomkw/X7rU6jk8oKKngvbQ9XDmgPa//aRBhwYFMnGunoKTC6mhKuZUWBz8iIvz18t4M7tSKu/+7nrW7D1sdyest+Cmb8spqbhzaiXYtmzFrfCoHCsuY+mYaFZXVVsdTym20OPiZkKAAXr0+lbioUCbPs7P/yFGrI3mt8soq5v6QzVkpsaTERwEwoGM0T1/Vl5+yCnh0yUaM0eM3qmnS4uCHWkWEMGfCIErLK5k8z87RiiqrI3mlj9ftJ6+onIlDO/3m/pED2vPns7uw8OddzP1+pzXhlHIzLQ5+qlubKF4YPYCN+wq569112sF0HGMMc1ZkkRwXyVnJteebuuuCbpzfM56/fryJ5Rl6VWDV9Ghx8GPn9YjnvuHd+WTDfl74epvVcbzKjzsK2LS/kIlDOyEitR4PCBCev64/KfFRTFuwmszcYgtSKuU+Whz83JSzOnPVwASeX7aNT9bvtzqO15izIotWESGMHND+hMtEhAYxe4KNkMAAJs1dxeFS7WBSTYcWBz8nIjx1ZW9SE6O58921bNhzxOpIlsvKL+GrLTlcf1pHwoIDf3fZhOhwXhuXyr7DZUxbsJpjVdrBpJoGLQ6K0KBAXhuXSuuIUCbNW0VOYZnVkSz1xsosggMCuP6MxHotb0tqxZNX9GZl5kEe/3iTm9Mp5RlaHBQAMZGhzBpvo6iskinz7JQd888OpiOlx3jXvocR/dsRFxVW7+ddY+vAlLM6M++HbOb/mO3GhEp5hhYH9aue7Zrzr+v6s27PEe7573q/7OFf8PMujh6r4sYhnU6+8HHuHd6dc7vHMX3JRr7PzHdDOqU8R4uD+o0Le7Xh7gu7sWTdPmZ8k2l1HI86VlXN3O93cmaX1vRs17zBzw8MEP49qj9dYiOY+tZqsvJL3JBSKc/Q4qBq+fPZXRjZvx3PfpnB5+n+M0Prpxv2c6CwrNZJbw0RFRbM7PGDCBCYOHcVR44ec2FCpTxHi4OqRUT4+1V96dehJXe8s5aN+5p+B9MvJ711jongnG5xjVpXx9bhvHJ9KrsOlnLLwjVUageT8kFaHFSdwoIDmTUulZbhwUyeayevqNzqSG5lzz7E+j1HuGFoJwICap/01lCnd27NEyN7szwjjyc/3eyChEp5lhYHdUJxzcOYNd5GQWkFN81v2h1Mc77LokWzYK4aeOKT3hpq1OCO3DikE2+s3MnCn3e5bL1KeYIWB/W7erdvwXPX9mf1rsM8sHhDk+xg2l1QypebDjD2tI6EhwS5dN0PXNyds1JiefiDdH7ccdCl61bKnbQ4qJO6uE9b7hiWwvur9/La8h1Wx3G5N1buJECE8WckuXzdQYEBvDRmAImtw5n6Zhq7Dpa6fBtKuYMWB1Uvt57XlUv7tuUfn29h6aYcq+O4TGHZMd5ZtYtL+7alTYv6n/TWEM3Dgpk9YRDVxtHBVFSmHUzK+3llcRCRW0Rkq4hsFJGnrc6jHB1Mz1zdjz7tW3D722vYcqDQ6kgusWjVbkoqqpg4tLNbt9MpJoJXxg5kR34Jty5cQ5VeIl15uXoVBxFJEJG7RORDEVklIstF5GURuUREXFpgROQc4HKgrzGmF/CsK9evTl2zkEBmjrMRERrEpLl2Dhb7dgdTZVU1b6zcyeBOreiT0MLt2zuzawzTR/Tim615/OPzLW7fnlKNcdIPdhF5A3gdqAD+AYwG/gwsA4YDK0TkLBdmmgr83RhTDmCMyXXhulUjtWnh6GDKKyrnZh+fR/mLjTnsPXy0USe9NdS40xMZf0YiM5fv4F37bo9tV6mGqs+3/n8aYy4wxrxgjPneGJNpjEk3xrxvjLkFOBvY58JMKcAfROQnEfmfiAyqayERmSIidhGx5+XpTFye1K9DS565ph+rdh7ioQ98t4NpzooddGwVzrAe8R7d7iOX9mRo1xgeWLwB+84Cj25bqfo6aXEwxqSf5PEKY0yDLsIjIstEJL2O2+VAEBANnA7cDSySOqbiMsbMNMbYjDG22NjYhmxeucCIfu245dyuLLLvYc6KLKvjNNiaXYdYveswNwxJItAFJ701RFBgADPGDCQhOpyb5qexu0A7mJT3OWlTt4hsAE741dAY07ehGzXGDPud7U0F3jeOr6M/i0g1EAPo7oGXuWNYCttyinnq0810iYts9GUnPGnOiiyiwoK4xtbBku23CA9m9gQbI2esZPI8O+9NPZOIUNeeY6FUY9RnWOlS4DLgc+dtrPP2KfBfN2T6ADgXQERSgBBAr3/shQIChOeu60f3Ns25dcEatuUUWR2pXvYePspn6QcYPbgjkRZ+IHeJjWTGmIFsyy3m9nfWUq0dTMqL1GdYKdsYkw0MMcbcY4zZ4LzdB1zohkyvA51FJB14G5hgfHVQ2w+EhzjmUQ4NDmTiXDuHSrx/HuW53+8EYMKZSZbmABxnT1/Sg6Wbcnjmy61Wx1HqVw1pQ40QkaG//CIiZwIRrg7kPIZxvTGmtzFmoDHma1dvQ7lWu5bNmDk+lQOFZUx9y7s7mIrLK1n48y4u6t2G9i2bWR0HcBSp0YM78sq321m8Zo/VcZQCGlYcJgIzRGSniGQBLwM3uieW8jUDO0bzj6v68OOOAh5dstFrO5jete+mqKzSo+2rJyMi/PXyXpzeuRX3vreB1bsOWR1JqfoXB2NMmjGmH9AX6G+M6W+MWe2+aMrXXDEggalnd2Hhz7t+HbrxJlXVhjdW7mRgx5YM6BhtdZzfCA4M4JWxqbRpHsaUeWnsO3zU6kjKz9XnJLjra54FbYwpNMYcqfF4l5rDTcq/3X1BN4b1iOevH29ieYZ3NZgt25zDroJSt18q41RFR4QwZ4KN8mNVTJprp7Si0upIyo/VZ8+hNbBGRF4XkWkicq2IjBeRv4rI/4CngaZzJTbVKAEBwvOj+pMSH8W0BavZnldsdaRfzVmRRfuWzbiwl2dPemuI5PgoXhgzgC0HCrlz0TrtYFKWqU+30r+BgcBCIBY4z/n7XmCcMeYqY8w2t6ZUPiUyNIhZ422EBAYwaa6dI6XWX4V0w54j/JxVwA1DkggK9MrrTf7qnG5xPHBxDz5LP8DzyzKsjqP8VL3+lRhjqowxS40x040xNxljbjfGvAZc6eZ8ykd1aBXOq+NS2XOolGkLVnPM4nmU56zYQURIINcOsuakt4aaOLQT19oSeOHrTJasc+XVaZSqn8Z+hfo/l6RQTdKgpFY8dUUfVmTm88THmyzLceBIGR+v38+1gzrQPCzYshwNISI8PrI3g5KiufvddazbfdjqSMrPNLY4ePaiNMrnXGPrwOQ/dGLuD9m8+WO2JRnm/rCTamO44UzvaV+tj9CgQF69PpWYyFAmz7Nz4EiZ1ZGUH2lscdCjZeqk7ruoB+d0i+XRJRv5PtOzV0IprahkwU+7uKBnGzq2Dvfotl2hdWQoc/5ko6S8kinz7RytqLI6kvIT9WllLRKRwjpuRUA7D2RUPi4wQHhh9AA6x0Qw9a3V7Mwv8di231u9lyNHjzHxD76111BT9zbN+feoAWzYe4S7/7vOa08wVE1LfbqVoowxzeu4RRlj9DKSql6iwoKZM2EQAeKYR/nIUfd3MFVXG95YkUW/hBbYEr3rpLeGGtYznnuHd+fj9ft58esGXSFfqVPi3T19qknp2Dqcl8emkn2wlFsWrqHSzR1M32zNZUd+CTcO7UQdU4L4nJvO6syVA9vz3NIMPtuw3+o4qonT4qA86owurXl8ZG+WZ+Tx1KfunUd5zoos2rYI4+I+bd26HU8REZ66og8DO7bkjkVrSd975ORPUuoUaXFQHjd6cEduGJLE6yuzePvnXW7ZxqZ9hXy//SDjz0gi2MtPemuIsOBAXhtno1V4CJPn2ckt1A4m5R5N51+N8ikPXtzDMZfBh+n8tOOgy9c/Z0UWzYIDGTO4o8vXbbXYqFBmTbBxuPQYU+anUXZMO5iU62lxUJYICgzgxdED6NAqnJvfTGPXQdfNo5xbVMZH6/ZxjS2BFuG+cdJbQ/Vq14J/XdePtbsPc99767WDSbmcFgdlmRbNHB1M1QYmzVtFUZlrOpje/CGbY9XV3DDEd9tX62N477bcdUEKH6zdx8vfbrc6jmpitDgoS3WKieCVsQPZnlfCbW+vpaqRVyEtO1bFmz/t4rzu8XSKcflEhV5n2jldGdGvHc98sZUvNx6wOo5qQrQ4KMud2TWG6SN68fWWXJ7+vHEdTIvX7KWgpMKrZnpzJxHh6av70i+hBbe/s5ZN+wqtjqSaCC0OyiuMOz2Rcacn8tryHbxr331K6zDG8PqKLHq2bc7pnVu5OKH3CgsOZNZ4G83Dgpk8z05+cbnVkVQToMVBeY1HLuvJkK6teXBxOvadBQ1+/vJt+WzLLWZiEznprSHimocxa7yNgyXl3Dw/jfJK7WBSjaPFQXmN4MAAZowZSLuWYdw0P409hxrWwTT7ux3ERYVyWT//vORXn4QW/POa/tizD/HA++nawaQaxeuKg4j0F5EfRWStiNhFZLDVmZTntAwPYfaEQVRUVTNprp2S8vrNo5yRU8R32/IZf0YiIUFe97b2mEv6tuX2Ycm8t3oPs77bYXUc5cO88V/R08Bjxpj+wCPO35Uf6RoXyYwxA8nIKeKOd9bWax7l11dkERoUwJjTEj2Q0Lvdem4yl/Rpy98+28JXm3V6d3VqvLE4GKC58+cWgM6R6IfOSonl4Ut78uWmHJ79cuvvLnuwuJz31+zlyoEJtIoI8VBC7xUQIDx7TT96tWvOrQvXsPVAkdWRlA/yxuJwO/CMiOwGngXutziPssifzkxi9OCOvPztdj5Ys/eEy7354y4qKquZODTJc+G8XLMQRwdTRGgQk+atoqCkwupIysdYUhxEZJmIpNdxuxyYCtxhjOkA3AHMOcE6pjiPSdjz8vI8GV95iIjw2IhenNapFfe8t541uw7VWqa8sor5P2ZzdrdYusZFWZDSe7Vt0YyZ423kFJZz85tpVFS69xLpqmmxpDgYY4YZY3rXcfsQmAC871z0XaDOA9LGmJnGGJsxxhYbG+up6MrDQoICePX6VNo0D2PyvDT2HT76m8eXrN1HfnG535z01lD9O7Tkmav78nNWAY98qB1Mqv68cVhpH/BH58/nAtsszKK8QHRECLMn2Cg7VsXkeXZKKxwdTMYY5qzIolt8FEO7xlic0ntd3r89fzmnK2+v2s3rK3daHUf5CG8sDpOBf4rIOuApYIrFeZQXSImP4sXRA9i0v5A7F62jutrw/faDbDlQ5JcnvTXU/52fwoW94nnyk018uzXXkgxV1YbN+wtZ8NMunajIB0hT2M202WzGbrdbHUN5wKzlO3jy083cel4y6XuPsH7PYVbcey5hwYFWR/N6JeWVXP3qD+wpKGXxtDPdfoymtKKStbsOY88+hD37EGuyD1HkPG+lRbNgPpw2hCQ/uDiiNxORNGOMrc7HtDgoX2KM4Z7/rufdtD0A3HZeMnecn2JxKt+x9/BRLn9pBRGhQXzw5yFEu7D198CRMuzZBdh3HiIt+xCb9hdSVW0QgZS4KFKTorElRpMQHc6U+XZaR4SweNoQmoc1zTk3fIEWB9WklFdWcf3sn9iw9wjf3XMusVGhVkfyKWnZhxg980dsSdHMvXHwKU2jWlVt2HqgiLTsAseewc5D7HU2C4QFB9C/Q0tsia1ITYpmYMdoWjT7bQH4YftBxs35iSFdY5gzwUZQE5rK1ZdocVBNTtmxKvKLy0mIDrc6ik96L20Pd767jutP78gTI/ucdPmS8krW7j6Mfech7NkFrN11+NchorioUGxJ0aQmtsKWGE3Pds3rVXAW/LSLBxZv4MYhnXjksp6N/ptUw/1ecQjydBilXCEsOFALQyNclZpARpvi0AYAAA9dSURBVG4Rr/1vBynxUYw/I+k3j+8/cvTX4SF7dgGb9xf9OkTULT6KEf3bYUuKxpbYioToZqfUEDDmtI5k5BTx+sosUuIjGdUE5/v2ZVoclPJT91zYne25xTz20SbCQ4I4WlFZ5xDRgA7R/PnsLqQmRjOgjiGixnjokh5szyvm4Q/T6RQTwWmdW7ts3apxdFhJKT9WXF7JVS9/z9Ycx/WXTnWIqDGOHD3GFTNWcqi0giV/GUqHVrpH6Cl6zEEpdUK5hWX8lFVA/w4tT3mIqLF25BUzcsZK2rQI472pZxKlHUwe8XvFQVsElPJzcc3DuKxfOzq0CrfsZMLOsZG8PDaV7Xkl3P72WqrqcZl25V5aHJRSXmFocgzTL+vJV1tyefrzLVbH8Xt6QFop5TXGnZHE1pwiXlu+g+T4KK5OTbA6kt/SPQellFd59LJenNmlNQ+8v4G07AKr4/gtLQ5KKa8SHBjAy2MH0q5lGDfNT2PPoVKrI/klLQ5KKa/TMjyE2RMGUV5ZzaS5dkqcZ2Mrz9HioJTySl3jInlx9AAycoq44521VGsHk0dpcVBKea2zu8Xx0CU9+XJTDv9cutXqOH5Fu5WUUl7thiFJbMstYsY320mOi2LkgPZWR/ILuueglPJqIsJjI3pzWqdW3PPeetbsOmR1JL+gxUEp5fVCggJ45fpU4puHMmV+GvucFwZU7qPFQSnlE1pFhDBnwiCOVlQxeZ6d0grtYHInLQ5KKZ+REh/FC6P7s2l/IXe9u87vO5hWZuaz/4h79qK0OCilfMq53eO5/6LufLrhAP/+apvVcSxTUFLBtAWrue+9DW5Zv3YrKaV8zuQ/dGZbTjH//mobyfGRXNq3ndWRPO7pz7dQVFbJAxf3cMv6dc9BKeVzRIQnruiNLTGaOxetY/2ew1ZH8qi07EO8vWo3E4d2olubKLdsw5LiICLXiMhGEakWEdtxj90vIpkislVELrQin1LK+4UGBfLquFRiIkOZPM9OTmGZ1ZE8orKqmoc+SKdN8zBuOy/Zbduxas8hHbgSWF7zThHpCYwCegHDgZdFJNDz8ZRSviAmMpTZE2wUlVUyZZ6dsmNVVkdyu3k/ZLN5fyGPXtaTiFD3HRmwpDgYYzYbY+o6F/5y4G1jTLkxJgvIBAZ7Np1Sypf0aNuc56/rz/q9R7j7v+tpClMfn0huYRnPLc3gjymxDO/dxq3b8rZjDu2B3TV+3+O8rxYRmSIidhGx5+XleSScUso7XdCrDXdf2I2P1u3jpa8zrY7jNk98spmKqmoeG9HL7VO6um2fRESWAXWVtgeNMR+e6Gl13Ffn1wBjzExgJoDNZmu6XxWUUvUy9Y9d2JZTzD+XZpAcH8nw3m2tjuRSKzPzWbJuH7edl0xSTITbt+e24mCMGXYKT9sDdKjxewKwzzWJlFJNmYjwtyv7kJVfwh3vrCMhOpze7VtYHcslyiurePjDdBJbhzP17C4e2aa3DSstAUaJSKiIdAKSgZ8tzqSU8hFhwYHMHJ9Ky/Bgpsyzk1vUNDqYZn+XxY68EqaP6EVYsGd6dKxqZb1CRPYAZwCfiMgXAMaYjcAiYBPwOTDNGNP02w+UUi4TFxXGrPE2DpUe46b5aT7fwbS7oJQXv97GRb3bcE63OI9t16pupcXGmARjTKgxJt4Yc2GNx540xnQxxnQzxnxmRT6llG/r3b4Fz13bjzW7DvPA+xt8uoPpsY82ESDCw5f29Oh2vW1YSSmlXOKiPm35v/NTeH/NXl793w6r45ySpZtyWLY5h9vOS6Zdy2Ye3bZeW0kp1WTdcm5XtuUW8/QXW+gaF8n5PeOtjlRvRyuqmL5kI8lxkdw4tJPHt697DkqpJktEeObqvvRp34Lb3l7D5v2FVkeqt5e+2cbew0d5YmRvggM9/1GtxUEp1aSFBQcya7yNqLAgJs21k19cbnWkk8rMLWbm8h1cObA9p3VubUkGLQ5KqSYvvnkYM8fZyC8uZ+qbaZRXem8HkzGGRz5Mp1lwIPdf5J7LcdeHFgellF/o16Elz17Tj1U7D/HQ4nSv7WD6aP1+vt9+kLuHdyc2KtSyHHpAWinlNy7r145tucW88NU2urWJYtIfOlsd6TcKy47x+Meb6JvQgjGDO1qaRYuDUsqv3H5eMttyinjq0810iY3knO6eO7HsZP61NIP84nJmj7cRGODeC+udjA4rKaX8SkCA8M9r+9GjbXNuWbiGjJwiqyMBsHHfEeZ+v5Oxp3WkX4eWVsfR4qCU8j/hIUHMGm8jLDiQSXPtFJRUWJqnutrw0AfpRIeHcPcF3S3N8gstDkopv9SuZTNmjU/lQGEZU99Mo6Ky2rIs76btdlzq4+IetAgPtixHTVoclFJ+a0DHaJ6+qi8/ZRXw6BJrOpgKSir422dbGJzUiisH1jm3mSX0gLRSyq+NHNCejJwiXv52OynxUdwwxLOXqnj68y0UlVXy+Mjebp/drSF0z0Ep5ffuuqAb5/eM5/GPN7E8w3PTDqdlH+LtVbuZOLQT3dpEeWy79aHFQSnl9wIChOev609KfBTTFqwmM7fY7dusrKrmoQ/SadM8jNvOS3b79hpKi4NSSgERoUHMnmAjJDCASXNXcbjUvR1M837IZvP+Qh69rCcRod43wq/FQSmlnBKiw3ltXCr7DpcxbcFqjlW5p4Mpt7CM55Zm8MeUWIb3buOWbTSWFgellKrBltSKJ6/ozcrMg/z1o01u2cYTn2ymoqqax0b08qqD0DV5376MUkpZ7BpbB7Y5L5udEh/JuDOSXLbulZn5LFm3j9uHJZMUE+Gy9bqa7jkopVQd7h3enfO6xzH9o02szMx3yTrLK6t4+MN0EluHc/Mfu7hkne6ixUEppeoQGCA8P6o/XWIj+PNbq8nKL2n0Omd/l8WOvBKmj+hFWHCgC1K6jxYHpZQ6gaiwYGaPH0SAwMS5qzhy9Ngpr2t3QSkvfr2Ni3q34Zxu3nMl2BPR4qCUUr+jY+twXr0+lV0HS/nLgtVUnmIH02MfbSJAhIcv7enihO5hSXEQkWtEZKOIVIuIrcb954tImohscP73XCvyKaVUTad1bs0TI3vz3bZ8nvx0c4Ofv3RTDss253D7sGTatWzmhoSuZ1W3UjpwJfDacffnA5cZY/aJSG/gC8B7rkSllPJbowZ3JCOnmNdXZpESH8Xoes7UdrSiiulLNpISH+nx6zY1hiXFwRizGajV32uMWVPj141AmIiEGmPKPRhPKaXq9MDF3cnMK+bhD9LpFBPB6Z1bn/Q5L32zjb2Hj/LOlNMJDvSdkXxvTnoVsOZEhUFEpoiIXUTseXmeu1CWUsp/BQUG8NKYASS2Dmfqm2nsOlj6u8tnOs+VuHJge06rRyHxJm4rDiKyTETS67hdXo/n9gL+Adx0omWMMTONMTZjjC02NtaV0ZVS6oSahwUzZ8Igqo2jg6morO4OJmMMjy5Jp1lwIPdf1MPDKRvPbcXBGDPMGNO7jtuHv/c8EUkAFgPjjTHb3ZVPKaVOVVJMBK+MHUhWfgm3LlxDVXXtSYI+Wr+flZkHuXt4d2KjQi1I2TheNawkIi2BT4D7jTErrc6jlFIncmbXGKaP6MU3W/P4+2e/7WAqLDvG4x9vom9CC8bU88C1t7GqlfUKEdkDnAF8IiJfOB/6C9AVeFhE1jpv3n+2iFLKL11/eiLjz0hk1ndZLLLv/vX+fy3NIL+4nCdG9iYwwDsvrHcyVnUrLcYxdHT8/U8AT3g+kVJKnZpHLu3JjrwSHly8gU4xEYSHBDL3+52MPa0jfRNaWh3vlOlVWZVSqhGCAgOYMWYgI19eyU3z02jbIozo8BDuvqC71dEaxauOOSillC9qER7M7Ak2Kquq2bivkAcu7kGL8GCrYzWK7jkopZQLdImN5I0bBrEy8yBXDvT9CztocVBKKRdJTWxFamIrq2O4hA4rKaWUqkWLg1JKqVq0OCillKpFi4NSSqlatDgopZSqRYuDUkqpWrQ4KKWUqkWLg1JKqVrEmNrXIfc1IpIHZDdiFTE45q/2Z/oaOOjroK/BL/zhdUg0xtQ5W1qTKA6NJSJ2Y4zN6hxW0tfAQV8HfQ1+4e+vgw4rKaWUqkWLg1JKqVq0ODjMtDqAF9DXwEFfB30NfuHXr4Mec1BKKVWL7jkopZSqRYuDUkqpWvy6OIjIcBHZKiKZInKf1XmsIiI7RWSDiKwVEbvVeTxBRF4XkVwRSa9xXysRWSoi25z/jbYyoyec4HWYLiJ7ne+HtSJysZUZ3U1EOojINyKyWUQ2ishtzvv97v1Qk98WBxEJBGYAFwE9gdEi0tPaVJY6xxjT34/6uv8DDD/uvvuAr4wxycBXzt+buv9Q+3UA+Jfz/dDfGPOphzN5WiVwpzGmB3A6MM35WeCP74df+W1xAAYDmcaYHcaYCuBt4HKLMykPMcYsBwqOu/tyYK7z57nASI+GssAJXge/YozZb4xZ7fy5CNgMtMcP3w81+XNxaA/srvH7Hud9/sgAX4pImohMsTqMheKNMfvB8YEBxFmcx0p/EZH1zmEnvxlOEZEkYADwE37+fvDn4iB13Oevfb1DjDEDcQyxTRORs6wOpCz1CtAF6A/sB/5pbRzPEJFI4D3gdmNModV5rObPxWEP0KHG7wnAPouyWMoYs8/531xgMY4hN3+UIyJtAZz/zbU4jyWMMTnGmCpjTDUwCz94P4hIMI7C8JYx5n3n3X79fvDn4rAKSBaRTiISAowCllicyeNEJEJEon75GbgASP/9ZzVZS4AJzp8nAB9amMUyv3wgOl1BE38/iIgAc4DNxpjnajzk1+8Hvz5D2tmi9zwQCLxujHnS4kgeJyKdcewtAAQBC/zhdRCRhcDZOC7LnAM8CnwALAI6AruAa4wxTfpg7Qleh7NxDCkZYCdw0y9j702RiAwFvgM2ANXOux/AcdzBr94PNfl1cVBKKVU3fx5WUkopdQJaHJRSStWixUEppVQtWhyUUkrVosVBKaVULVoclPIA55VO77I6h1L1pcVBKaVULVoclHITEXnQOV/IMqCb1XmUaoggqwMo1RSJSCqOS7IMwPHvbDWQZmkopRpAi4NS7vEHYLExphRARPzuul3Kt+mwklLuo9emUT5Li4NS7rEcuEJEmjmvenuZ1YGUaggdVlLKDYwxq0XkHWAtkI3jqp9K+Qy9KqtSSqladFhJKaVULVoclFJK1aLFQSmlVC1aHJRSStWixUEppVQtWhyUUkrVosVBKaVULf8PNkXqFFF14xQAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -429,7 +429,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 13, @@ -438,7 +438,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -480,7 +480,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -542,7 +542,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3hUxdfA8e+kETqBhBog9N5BehcFBKWJFEEQRZEi2H5YQcXyikoXRaWpgCgggiAioUrHAKF3klCSkAYJ6TvvH5NggLQN2b13k/k8zz5kd+/dexKSPXvnzpwjpJRomqZp+ZeT0QFomqZpxtKJQNM0LZ/TiUDTNC2f04lA0zQtn9OJQNM0LZ/TiUDTNC2f04lAM5wQor0Q4rSNXnuqEOLHB9j/uBCiUy6GZBghhI8QQgohXIyORTMXnQi0HBFCDBJC7BNCxAghQlK+fkkIITLYvp4Q4i8hRIQQIlIIcUgI0RNASrlTSlnLvt9BujEuFkJMS/uYlLKelHKbDY61TQgRJ4SITnNbl9vH0bTs0IlAs5oQ4lVgFjAdKAuUAV4E2gJuGey2Dticsm1pYAJw0+bBmts4KWWRNLfeRgek5U86EWhWEUIUBz4AXpJS/iqlvCUVPynlUCllfDr7eAJVgG+llAkpt3+klLtSnu8khAhKs/0lIcTrQoijKWcc3wshygghNgohbgkh/hZCeKS3b5r9H84g/l+EENeFEFFCiB1CiHopj48GhgJvpP10nva1hBAFhBAzhRBXU24zhRAF0sYhhHg15QzpmhBiZA5/xhm+lhCiVUr8zmm27yuEOJrytZMQYrIQ4rwQIkwIsVIIUTKD45QXQvwuhAgXQpwTQjyf5rmpQohfhRA/p/zM/xVCNLpn31VCiFAhxEUhxIQ0zz0khDgohLgphAgWQnyZk5+DZj86EWjWag0UANZasU8YcA74UQjRRwhRJhv79Ae6ATWB3sBG4C3AE/V7OyHjXTO1EaiBOiv5F/gJQEq5IOXrzzL5dP420ApoDDQCHgLeSfN8WaA4UAEYBcxLTVg5kO5rSSn3AjFAlzTbDgGWpXw9AegDdATKAxHAvAyOsRwIStluAPCxEKJrmuefAH4BSqa8/m9CCFchhBPqDO9ISnxdgYlCiEdT9psFzJJSFgOqAStz9BPQ7EYnAs1ansANKWVS6gNCiN0p4/6xQogO9+4gVUGrzsAl4AvgWsqn8RqZHGeOlDJYSnkF2AnsSznriAfWAE1yEryUcmHKWUw8MBVolHKWkx1DgQ+klCFSylDgfWBYmucTU55PlFJuAKKBzK59zE75uaXePszmay0HBgMIIYoCPVMeA3gBeFtKGZTmexxw7wViIURFoB3wPyllnJTyMPDdPd/PoZSzvkTgS8AdlQhbAF5Syg9Szu4uAN8Cg9LEXl0I4SmljE5JXpqJ6USgWSsM8Ez7xiKlbCOlLJHyXLq/UylvTOOklNWAyqhPtUszOU5wmq9j07lfxNrAhRDOQohPU4ZNbqISE6jklh3lgctp7l9OeSxVWNoECdzOIs4JUsoSaW7vZvO1lgH9Uoal+gH/SilT46oMrElNLsBJIBl1bebe7yVcSnnrnu+nQpr7galfSCkt/Hf2UBkonzaJoc7WUo8xCnUmd0oIcUAI0SuTn4FmAjoRaNbaA8Sjhg1yREoZiBquqJ8L8cQAhVLvpIyde2Ww7RBU3A+jhl18UndLDS2LY11FvQmmqpTymF1JKU+g3rR7cPewEKg37x73JBj3lDOrtK4CJVPOKFJVAtJuVzH1i5ThIO+U/QKBi/cco6iUMnUW2Fkp5WDU8Nv/Ab8KIQrnxveu2YZOBJpVpJSRqCGRr4QQA4QQRVIuUDYG0v1jF0J4CCHeF0JUT9nWE3gWyI0hgzOAuxDiMSGEK2rMvkAG2xZFJbEwVPL4+J7ng4GqmRxrOfCOEMIr5Xt4D8jxGoUHtAx1PaADahw/1dfAR0KIygApsd6XtFOS8W7gEyGEuxCiIeqT/E9pNmsmhOiXcvY3EfWz2wvsB24KIf4nhCiYcqZVXwjRIuWYTwshvFLOIiJTXis5F793LZfpRKBZTUr5GfAK8AYQgnoD/Qb4H+rN5V4JqE/ff6OmjB5DvamMyIVYooCXUOPbV1BnCEEZbL4U9Un6CnCC+xPR90DdlOGO39LZfxpwEDgK+KMuNk9LZ7vsmivuXkdwyIp9lwOdAF8p5Y00j88Cfgf+EkLcQn2PLTN4jcGo/5erqOsuU6SUm9M8vxZ4CnXBeRjQL+WaRTLqAn5j4CJwA/XzT73W0h04LoSITolnkJQyzorvTbMzoRvTaJp2LyHEVKC6lPJpo2PRbE+fEWiapuVzOhFomqblc3poSNM0LZ/TZwSapmn5nMOVo/X09JQ+Pj5Gh6FpmuZQDh06dENKme4aG4dLBD4+Phw8eNDoMDRN0xyKEOJyRs/poSFN07R8TicCTdO0fE4nAk3TtHzO4a4RpCcxMZGgoCDi4vLeKnZ3d3e8vb1xdXU1OhRN0/KoPJEIgoKCKFq0KD4+Poj0W+Y6JCklYWFhBAUFUaVKFaPD0TQtj7LZ0JAQYmFKm71jGTwvhBCzU1rkHRVCNM3pseLi4ihVqlSeSgIAQghKlSqVJ890NE0zD1teI1iMqkKYkR6oloE1gNHA/Ac5WF5LAqny6velaZp52GxoSEq5Qwjhk8kmTwBLU9oY7hVClBBClJNSXrNVTJrmcK5dg++/h4SE+5/r2RNatYKQEJg7FwYOhPr14dw5WJpZ87cU927/3HNQqRIcPgyrV2e9/73bT5wIJUvCzp2weXPW+9+7/bvvgqsr/PEH7NuX9f5ptz96FN58Uz3+889w/Hjm+xYsePf2ISEwfry6/+23EBiY8b4AXl53b+/mBs88o+7PmAEREenudjMukZNXbxFRzpsT3foC0HT1Ym55leNse9XyudWP83BKvr99wy2vMhR4aQwdambUd+kBSCltdkPVOj+WwXPrgXZp7m8Bmmew7WhUHfiDlSpVkvc6ceLEfY8Z4fr163Lw4MGySpUqsmnTprJVq1Zy9erVD/y6Zvn+NDuLiJCyXj0pQUoh7r/NmqW2O3ZM3V+5Ut3/66/0t7/3du/2u3ap+0uWZG//e7c/f17d/+ST7O1/7/axser+hAnZ2z/t9iVL/vdze/LJrPe9d/t69f6737Zt1vvfu323bv/dr1o13X0sQshkIWQyQu7waSJ9Jq+XPpPXy0slyspf63e5cz/WxU0mI+67HSpfS3668WTOfpeklMBBmdF7dUZP5MYti0TwRzqJoFlWr9msWbP7vkEzvFFaLBbZqlUrOX/+/DuPXbp0Sc6ePfuBX9sM359mZ3FxUnbuLKWrq5RbthgdjfaAbscnySfm7pI1394gD10ONySGzBKBkbOGgkjTE5X/+qE6JF9fX9zc3HjxxRfvPFa5cmXGp54+apo1duxQt8WLoUsXo6PRHkCyRTJhhR9HgiL5+ulmNK3kYXRI9zEyEfwOjBNCrEC10ouSuXB94P11xzlx9eYDB5dW3fLFmNK7XqbbHD9+nKZNczzxSdPu1q0bnDwJNWoYHYn2AKSUvL/uOJtPBPP+4/V4tF7Z+7ZJSE4gIjaCiLgIwmPDiYhN+TcugojYCB6t/iitvFvZNE6bJQIhRGpPVU8hRBAwBXAFkFJ+DWwAegLngNvASFvFYoSxY8eya9cu3NzcOHDggNHhaI7iu++gQgXo0UMnAQcmpeTG7RvM3LqbxXuDGduhPf2alWLIqiEMrDeQPrX7cOrGKZovaE5MYkymr+VR0MNxE4GUcnAWz0tgbG4fN6tP7rZSr149Vq1adef+vHnzuHHjBs2bNzckHs0BJSXBN9+At7dKBJqpWaSFTec2EXgzkMCoQPVvmq/jktT6n3pl+jO5+/NYSObA1QM8XPVhAEoXLs0LzV7Ao6AHHu4elCxYEo+CKf+m3C/uXhwXJ9sP3OSJlcVm0KVLF9566y3mz5/PmDFjALh9+7bBUWkOxcUFfH3BSZcAszcpJVHxUQRHBxMcE0xwdDDXo68THBOMZyFPJraaCEDbhW2p61mXbx//FoGg/8r+xCbF4iScKF+0PBWLVaRJuSY0L9uNzUeTqOHpwzdP9cHJSeCEC2fHn71zzJIFS/LFo18Y9S3fRSeCXCKE4LfffmPSpEl89tlneHl5UbhwYf7v//7P6NA0szt/Hj78EObNg6JFjY4mz4uMi6SEewkAHl/+OEeCjxAcHUx8cvx92zoLZzpX6XwnETxS9REqFKsAqL/5Xc/uwquQF+WKlrvzyf1s8C36z99NIw93Vj3fhuKFzF8nTCeCXFSuXDlWrFhhdBiaI7lxQw0DhYXBO+9A9epGR5SnWKSFs2FnqeVZC4Dnfn8O34u+XHj5AgDNyjXDo6AHZQqXoWyRspQpXIYyRf77ulShUjiJ/87QpnSactfrNy139wSR4JtxjFh0gAKuziwe2cIhkgDoRKBpxomNhccfh4AA2LJFJ4FckJiciN91P3Ze3snOgJ3sCthFWGwY1169RtkiZelbuy+NyjTCIi04Caf73tgfRHR8EiMXHSDidgIrX2iNt0ehXHttW9OJQNOMkJwMQ4fC3r3wyy/Qtq3RETmkmIQY9l3Zd+eNf0/QHm4nqmtz1Tyq8Xitx2lfqT0FXQoC8FjNx2wSR2KyhTE/HuJ08C2+f6Y59SsUt8lxbEUnAk2zNynhlVdgzRpVl6Z/f6Mjchg342/y87GfaVepHXW86rD10lZ6L++NQNCwTEOebfws7Su3p32l9pQrWs4uMUkpeWu1PzvP3uCz/g3pVKu0XY6bm3Qi0DR7mzEDZs+GSZNU4TUtXdduXWNv0F72XdlHozKNGNxgMInJiYxeP5rPu31OHa86tK/Unj+H/klL75Z3LgDb26wtZ/nlUBATutZgYIuKWe9gQjoRaJo9/fILvPoqDBgAn39udDSmkZCcwP4r+9kXtI+9V/ayL2gfgTdVBVBXJ1fGPzSewQ0GU6pQKS6+fJHKxSsDUNy9OI9Wf9SwuFceCGTm32cZ0MybSQ877gJAnQg0zV6kVAvG2raFH37Q6wVSjFk/huXHlhMVHwWATwkf2lZqS8sKLWlZoSVNyjXB3cX9zvY+JXwMivRu28+E8uYaf9rX8OSTfg0cuneITgS56Pr160ycOJEDBw5QoEABfHx8mDlzJnPnzsXX1xchBO7u7qxcuZIqVarg4+ND0aJFEULg4eHB0qVLqVy5stHfRt5nsUD8/XPG71OggHqzTkqCxERwdwch1NdJSVnvn3b75GR1f906iItTX+dTm89vZv2Z9czqMevOY33r9OXxmo/TpmIbyhQpY7dY4pOSUcWPrXP6+i1e+vEQNcsU5auhTXF1duykrhNBLpFS0rdvX5555pk7awkOHz7Mzz//zNWrVzl69ChOTk4EBQVRuHDhO/tt3boVT09PpkyZwrRp0/j222+N+hbyj5deUp/Ms3LkCDRsCF9/rZqQhIaCpydMnQoff5z1/mm337wZ/voLSpRQTVHykWu3rvHbqd8YVH8QHgU9OB56nFUnVzG101Q8Cnowv9cDNSfMsdlbzjLj7zM5SgQA5Yu7s3hkC4q622GtwKVL8OOP8NZbNjmT1Ikgl2zduhVXV9e7ylA3btwYX19fypUrh1PKf563t3e6+7du3ZrZs2fbJdZ8b+ZMqFw56z+osimVIlu3hk8/hUIp88IffRSKFcv6OGm3L14cwsNVIsgHzoWfY83JNaw5tYY9QXsA8CzkyZP1nmRM8zFMaDnhroVa9rZ8fwBfbj7DI3XL0CQHZaGdBPRsUI4yxexwZpecrNabBAXB8OGqK1wuy5OJoNPiTllu06tmL15r89qd7Uc0HsGIxiO4cfsGA1YOuGvbbSO2Zfl6x44do1mzZvc9PnDgQNq1a8fOnTvp2rUrTz/9NE2aNLlvuz///JM+ffpkeRwth5KS4P331UydkiX/a1OYHc2aqVuqDh3ULbus3d5Bnbpxip+P/czqU6s5GnwUUCtvP+z8If3q9KOOZx0ACrgUMDJMtp4O4Z3fjtGxphfzHGFYx9kZvvhCDVXaIAlAHk0EZuLt7c3p06fx9fXF19eXrl278ssvv9C1a1cAOnfuTHBwMKVLl2batGkGR5uH+fnBZ59BrVrw9NNGR5OnxCfF0/r71vhd90MgaFepHTMenUGf2n1Mc2E3lX9QFGN/+pc65RxgbN9iUQsO27RR/SlsKaPWZWa9mbVV5d9//y3bt2+f5XbTp0+X48aNk1JKWblyZRkaGipv374tBw4cKCdNmpTuPmb4/vKEixeNjiDPWOS3SE7cOPHO/QkbJsjZe2fLqzevGhhV5gLCYmSzDzfLNp9skcE3Y40OJ2uzZ6t+xwcP5srLkUmrShOnQ8fSpUsX4uPj77rYe+DAAbZv387Vq6oDp8Vi4ejRo/fNDCpYsCAzZ85k6dKlhIeH2zXuPO+nn9RFNgAfH0NDcWRXb11l7v65JCYnAnAm7Ax7r+wlyaJmT83qMYvxLcfbbTWvtSJvJ/DMov0kJltY8mwLShd1gFlbzz0HCxeCHTof6kSQS4QQrFmzhs2bN1OtWjXq1avH1KlTOXr0KL1796Z+/fo0bNgQFxcXxo0bd9/+5cqVY/DgwcybN8+A6PMoX18YOVL9MVksRkfjcEJiQph/YD6dFnfC+0tvxm8cz+7A3QB82PlD9ozaY5emKQ8qLjGZ55ceJCg8lm+HN6d6aZOX+t62DSIj1eyyESPUFGQbEzKnc6cM0rx5c3nw4MG7Hjt58iR16tQxKCLby+vfn034+0O7dlCxIuzalW9m6zwoKSV/nvuTGXtn4HvRl2SZTG3P2jxV7ymeqvcUdbwc6/fQYpGMX+7HH/7XmDO4Cb0blTc6pMzt3g1du8KgQbBoUa6+tBDikJQy3ZaJ5k/nmmatoCDo2ROKFIGNG3USyKYdl3fwtu/b7ArYRaXilXij7RsMqj+IBqUdd9XsxxtO8of/Nd7uWcf8SeDMGTVN1NtbTWywI50ItLzl5k147DGIioKdO9UZgZYli7Tw0h8vER4bzvzH5vNsk2dxc3YzOqwHsuifi3y36yIj2vjwXPsqRoeTuZAQ1aDIyQn+/BO8vOx6eJ0ItLwjIUGVdD5xAjZsgEaNjI7I1M6Fn+PDHR8yu/tsirsXZ/VTq6lYrCIFXR1/5fOfx67xwfoTPFqvDO/2qmvuM5qYGOjVC65dU9cHqlWzewj6YrGWN0gJzz8Pf/8N335r+3nXDiz1umBUXBS/nfoNv+t+ANQsVTNPJIFDl8N5ecVhGlcswaxBTXB2MnESSEpS1wMOHYIVK+ChhwwJQ58RaHnDmTPw66/wwQdqpoV2n2u3rjFtxzQSLYks6L2AZuWbceWVKxRxK2J0aLnmQmg0zy05SPkSBfn+mRa4uzobHVLGpFQ1rNavh3nz1PUBg+hEoOUNtWrBsWN6rUA6wm6H8dk/nzFn/xwSLYm82OxFpJQIIfJUErgRHc+IRQdwEoLFI1tQsrDJr3GsWKEKGr7xhiqEaCA9NJRLihS5/w9q6tSpVKhQgcaNG1O7dm3GjBmDRc9nz10bN8L8lOqVVarYZc61o7gVf4sPt39I1dlVmb57OgPqDuD0uNPM6TnH3GPmOXA7IYlRiw8QciuO70e0oHKpwlnvZLT+/VUV3E8+MToSnQhsbdKkSRw+fJgTJ07g7+/P9u3bjQ4pb1m6VF0TSEgwOhLTSEhOYO7+uVSbXY33tr1H1ypd8R/jz9K+S6nqUdXo8HJdUrKF8cv88L8SxZzBTWlc0eTThffuVSXK3dxg9GhTNCjSQ0N2kpCQQFxcHB4e1pe8zfMWLYLgYJg8Wd2fOVPVX89M2bJq+x9+UFNF3Uw+DGAn8UnxNP6mMadunKKzT2f+7+H/o0WFFnY7/sqDgZy8dtNuxwO4EBrD9jOhfNinPt3q5qCpzZYtqmFQVt55R/WXSN3+s8/U793q1bBjR9b7f/aZKindt6+6KLx2rfWx2kjeTASdOmW9Ta9e8Npr/20/YoS63bih+smmtW1bjkOZMWMGP/74I5cvX6ZHjx40btw4x6+VZ23dCmfP/pcINmyA/fsz36dOHbW9iwuUKmX7GE3ueMhx6pWuRwGXAoxsPJIGpRvQvXp3uw4BRd5OYPKqo7i5ONm1qqeTEEx6uCbDWlnR3e/aNTWMWLasWoW+eHHW+0ycqBJB6vapQzr792dv/08+UWUj1qyB8uZa3JY3E4GJTJo0iddee43ExEQGDBjAihUrGDRokNFhmcOZM1C9uhreSeuvv4yJx0GtOLaCwasG88+z/9CmYhveaPuGIXFsPxOKRcKy51vRNAfNXuxGShg4UNXzOXxYvcFPnJj9/e/d/tNP1S27WrXK/rZ2kjcTgbWf4NNu7+n5QGcAGXF1daV79+7s2LFDJwJQi2hatYIhQ2DuXKOjcThXb13lys0rtKjQgt41e/PFI1/QpOz9DY/saeupEEoWdqORt8nH6IWAGTNUxzhnE08vtSPjr1LkE1JKdu/eTTUDVg2a0g8/QEQEPPWU0ZE4lJvxN3nH9x2qz67OiLUjkFJS2K0wr7R+xdDFYMkWybYzoXSq6WXeBVxSqoq0AM2bwyOPGBuPidg0EQghugshTgshzgkhJqfzfHEhxDohxBEhxHEhxEhbxmNLt2/fxtvb+87tyy+/BNQ1gsaNG1O/fn2SkpJ4yeD5wqZgsagLws2aqQqhWpYSkhOYs28O1WZX46OdH/FE7SdYN3idaaaB+gVEEHk7kS51ShsdSsY++EBV9ty82ehITMdmQ0NCCGdgHtANCAIOCCF+l1KeSLPZWOCElLK3EMILOC2E+ElK6XBzATNaHzB16lT7BuIINm2C06dVwxiTvJGZlZSSX0/8yptb3uR8xHk6+XRierfpNC+fbjVhw/ieCsHZSdC+hn2LpWXbokUwdaqaEPLww0ZHYzq2vEbwEHBOSnkBQAixAngCSJsIJFBUqI81RYBwIMmGMWlmMGMGlCsHTz5pdCSmdvXWVZ5d+yybzm+inlc9/hjyBz2q9zDNWUBavqdCaF7Zg+IFXY0O5X5//aXm63frBgsW6A8f6bBlIqgABKa5HwS0vGebucDvwFWgKPCUlPK+j9ZCiNHAaIBKlSrZJFjNTo4dU6fmH32k5/5nQkpJr2W9OHXjFHN6zGFM8zE4O5nzwubVyFhOXb/Fmz1qGx3K/Q4fVit469VTtahcTZioTMCWiSC9tHtvO7RHgcNAF6AasFkIsVNKedeKFCnlAmABqA5lNohVs5dZs9Rc6hdeMDoSU4qMi6SgS0EKuBRg/mPzKeFeglqetYwOK1NbT4cA0KW2ya4PBASoBkUeHvDHH1CsmNERmZYtLxYHAWm7gnijPvmnNRJYLZVzwEXAhB8rtFwRGqpmCw0frheBpSMiNoKG8xsyZdsUAFp6tzR9EgA1bdTboyDVS5uogF1kpEoCt2+relQVKhgdkanZMhEcAGoIIaoIIdyAQahhoLQCgK4AQogyQC3ggg1j0ox04YJaUfnyy0ZHYiqWlNFQj4IejG42mv51+hscUfbFJSbzz7kwutQuba5rFyNHqgWLa9aoYSEtUzZLBFLKJGAcsAk4CayUUh4XQrwohHgxZbMPgTZCCH9gC/A/KeUNW8WkGaxlSzh3TpWH0AA4dPUQTb5pwqGrhwB4p8M7dq0N9KD2XggjNjGZzmYbFpo2DZYvh86djY7EIdh0ZbGUcgOw4Z7Hvk7z9VUgT6zquHTpEr169eLYsWN3Hps6dSpFihTh2LFjbN++neLFixMXF8fgwYOZMmWKgdEa4Px5dXru7m50JKaQZEni/3b9H1O3T6V04dLEJMYYHVKObD0VgrurE62rmmSob/t26NBBnQXoM4Fs0yuL7WT69OkcPnyYw4cPs2TJEi5evGh0SPYjpZoq2r270ZGYwrnwc7Rf1J53tr5D/zr98R/jT4fKHYwOy2pSSnxPh9C2mqc5OoFt2qQKSK5caXQkDidv1hoysbi4OAAKF3aAxhm56fPPITHR6CgMJaVkwaEFvPLXK7g5u7Gs3zIGNxhsdFg5dj40msDwWF7oYJKyKd26wcKFarqoZpW8mQhMVIY61euvv860adM4d+4cEyZMoHRpk42p2pIQ0KWL0VEY6nr0dUb9PooNZzfwcNWHWfTEIryLeRsd1gPZclJNG73v+kBUlGoU5JWyyjgiIuvGQU5Od28vJZQsqe6Hhakm7xk5cwYqVlRtSkc6bJUaQ+XNRGCAjGZMpD4+ffp0BgwYQHR0NF27dmX37t20adPGniEa4/x5VV108mQok4OmIXlAkiWJ9ovaE3QziNndZzP2obE4CccflfU9FULtskWpUOKeYneTJsHff6t5/ACDB6thm8xUrHj39pGRqpMXqA8RR49mvn/btrBzp141nEN5MxEYUIa6VKlSRERE3PVYeHg4VapUueuxIkWK0KlTJ3bt2pU/EsHs2aqn8OuvGx2J3d2Kv0Vht8K4OLkwu/tsfEr4UMcrb8yYiopN5ODlCF7okNL6MixMvXlXqwbDht09W2fcOHjiicxfMG3P73HjID7+v/tvv61ePyNOTtC7t04CDyBvJgIDFClShHLlyrFlyxa6du1KeHg4f/75Jy+//DJbt269s11SUhL79u1j/PjxBkZrJ1FRasz2qadM15HJ1q7eukrr71vzepvXGffQOHrU6GF0SLlq59lQki1SrSaOjYXHH4fAQDVMc++UzV69rHvxe7cfOPDBgtWy5PjnpyaydOlSpk2bRuPGjenSpQtTpky503/g9ddfp3HjxjRs2JAGDRrQr18/g6O1g++/h+hoNVSQT0ipKqCUK1KO3jV7m65KaG7xPRVCiUKuNKlQTJ0B7NkDX3yhpwc7KH1GkIvq1q1716f/VIuz0880r0lKUsNCHTpA06ZGR2MXh68fZuyGsfzU7yd8Svgwt2fe7LxmsUi2nw6lY00vnN94HVatgi+/1NVkHZg+I9Bs47ff4PJl63rBOqhkSzKf7vqUh759iAsRF7hy84rRIdnUkaBIwmISeO7Q76rB0Msv56uzvrxInxFotjFzJlSposaO8+bbgnkAACAASURBVLALERcYvmY4/wT+w4C6A/j6sa8pVcgkq2xtZOupEB47vYv6a/8P+vVTQ0KaQ8sziUBKaa6iV7kkdczZoRw4AP/8oxrQ5NHm4FJKFvotZOKmiTgJJ37o+wNDGwzNk7+D97q+4W9mrP8S0bq16jKXR/+P85M8kQjc3d0JCwujVKlSeeoPUUpJWFgY7o52AW7GDChaFJ591uhIbCI4Opjn1z3PujPr6OzTmcV9FlOpeP5omBR67jJvfvMmt8uWx23tWtVbQnN4eSIReHt7ExQURGhoqNGh5Dp3d3e8vR1sBepbb6l543mwEUhsYizNv21OaEwoMx6dwYSWE/LE4rDs8g2Hk20H8/S0lyjh6Wl0OFouEY429NC8eXN58OBBo8PQ8rEfj/5Ik7JNqFc6H1W3jI6GwEBeOBjD0aAodk/ukqfOvvMDIcQhKWW685nzz0cZzfZu34ZRo+DkSaMjyVXJlmReXP8iq06sAuDphk/nryQAMGECsl07DvtforPZmtBoD0wnAi33HDmiGoRnVg7AASUkJ+Af4s+xkGNZb5xXTZ3KqXc/JdipIF3N1oRGe2B54hqBZhKtW8OVK5BHSmzfir+FRFKsQDF8h/tSwKWA0SHZ399/q6JvlSqxslobCtwIoE01fW0gr9FnBFruSC0dXKRInij+FRoTSuclnRmwcgBSyvyZBH78UdX4nz8fUOsHWlcrRUE3PV00r9GJQMsdgwblmQ5kAVEBtFvUjuOhx5nQckL+HA/39VXTfzt3huef50JoNJfCbqsic1qeoxOB9uCOHIG//oKOHY2O5IGdCD1Bm+/bEBwdzOZhm+lV08rKmXmBvz/07Qu1asHq1eDmhu+plCY0tXQiyIv0NQLtwYSEqDIDnp4werTR0TyQ/Vf20+OnHrg5u7Fj5A4almlodEj2FxQEPXuqIb4NG6BECQC2ng6hRukiVCxZyOAANVvQZwRazsXEqNrx167B+vUqGTiovy/8TZclXSjhXoJdI3flzyQQFaWSQFQUbNyouoYB0fFJ7L8YroeF8jCdCLScSUpSLQUPHYLly6FlS6MjyrFfT/xKz596Uq1kNXaN3EW1kiZpxm5PCQmq6fvJk6qsdMP/EuGus6EkJsv7exNreYYeGtKsJyVMmADr1ql+xFm1ITQxKSXf/fsdLb1bsm7wOkq4lzA6JGO88w5s2QJLlqiZQmn4ngqhqLsLzSp7GBScZms6EWjW++yz//oQjx1rdDQ5IqUkNimWQq6F+HXgrzgJJwq55uPx71degdq1Yfjwux62WCRbT4fSoaYXrs56ACGv0v+zmnWkhBMn1HTRTz81Opocm/z3ZDov6cztxNsUcSuSf5PA9u2QmAhly6ZbLfb41ZuE3oqni54tlKfpMwIt+6RUi8UWL1ZvHk6O+zmiTcU2JFoScXdxsBLfuenMGejaFaZMgXffTXeTLaeCEQI61fKyc3CaPTnuX7JmX8ePqwvCFy6oZODmZnREVouIjWDd6XUAPFH7Cb589Mt8VUL6PjVrqgv9mbSZ3HoqhMYVS1CqSD5cWZ2P5OO/As0qt25BXJzDdqO6GHGRNgvbMGjVIEJiQowOx1gXL8L+/errJ59UawbSEXorniNBUXpYKB/QQ0Na5pKSwMUFWrWCw4cdcjhoX9A+ei/vTZIliY1DN1K6cD5+YwsLgx49VH+B8+ehQMaf9LedTllNrKeN5nk2/asWQnQXQpwWQpwTQkzOYJtOQojDQojjQojttoxHs1JiIjz2GHz0kbrvgElg1YlVdFrSiaIFirJn1B46VO5gdEjGiYtTU30vXVJDQpkkAVCricsUK0C98nmv05x2N5v9ZQshnIF5QA+gLjBYCFH3nm1KAF8Bj0sp6wFP2ioezUpSqpIRf/0FFSoYHY3VpJR8sfsLnvzlSRqXbczeUXup5VnL6LCMY7HAsGHwzz+wdCm0b5/p5onJFnaeuUHnWroJTX5gy494DwHnpJQXpJQJwArg3pVHQ4DVUsoAACllPh+8NZH331ezg6ZOhREjDA7GOkmWJMZuGMtrm1+jf93++A73xatwPp/18tprqmnQF1/AwIFZbn7gUji34pP0sFA+YctEUAEITHM/KOWxtGoCHkKIbUKIQ0KI4aRDCDFaCHFQCHEwLzaoN53vv1eJ4Nln4b33jI7GasPXDGf+wfm80eYNfh7wMwVdCxodkrFmzYIZM9Rq8ExmCKW19VQIbs5OtKvuuPWjtOyz5cXi9M4nZTrHbwZ0BQoCe4QQe6WUZ+7aScoFwAJQzettEKuW6s8/4YUX4NFH4euvHbLJzMjGI+lYuSMvNH/B6FCMt2qVevPv2xe+/DLb/5++p0JoWbUkhQvo+ST5gS3/l4OAimnuewNX09nmhpQyBogRQuwAGgFn0OzPz09NJ2zQAH75BVxdjY4o245cP8K+K/sY3Ww03ap1y3oHe4uOVlVaM1K+vGrxmbpdpUrqYm5kJGTnLPje7atWJTrgCoWGDSOh+UNcn7UAGRGXrVBDbsZxPjSGoS0rZ/Ob0xydLRPBAaCGEKIKcAUYhLomkNZaYK4QwgVwA1oCM2wYk5aRy5fVDKGSJeGPP6BoUaMjssrMfTPxvejLkAZDKOKW/rx4w5w7B23bqt4NGfnzT3UWtmkTDBgAR4+qhPzjjzB+fNbHuGd7GRJC95XnqNd9Evu96xExb5/VYeuy0/mHzRKBlDJJCDEO2AQ4AwullMeFEC+mPP+1lPKkEOJP4ChgAb6TUh6zVUxaJqKiVBOSX39Vn04dRHRCNEXcivBVz6+IiIswXxJISFAJ1mKBhQszXpHdoIH6t0UL9Wae0guAbt3U/azcs31ggjNBEbF0GDaIKT4lrQ67dNEC+HgWtno/zTEJKR1ryL158+by4MGDRoeRdyQn/7daOO3XJmeRFib/PZkNZzewe9RuihUw8Vz3VavUFNxWrex2yLWHr/DyisNsmNCeunodgAYIIQ5JKZun95zjrRDSco/FAkOHqnLS4DBJAOCD7R8wffd0OlbuaM7KocnJkPqBpX9/uyYBgH8vR1DIzZmaZUx2hqSZkk4E+ZmU4OUFpR1rLHhf0D6m7ZjGsIbDmNtzLi5OJpzZMn06tG4Np04Zcni/wEgaehfHRfcQ0LLBhH9Bml3ExYG7O8yebXQkVolOiObpNU/jXcybOT3mmHfV60svqSRbu7bdDx2XmMyJqzcZ3aGq3Y+tOSb9cSE/+u03qFULzp5V88rN+maajtf+eo3z4edZ2ncpxd2LGx3O/bZtg9u3oVgxGDXKkBD8r0SRZJE0qaRbS2rZoxNBfrNnj2o6X66cw9UQWn9mPd8c+obX27xuzuJx27bBI4/A5HTrK9qNX0AEAE0q5dP+y5rVdCLIT86ehd69wdtbNZ4vZMKLrBkIiQlh1O+jaFSmER90/sDocO53/Dj06QPVq6vyHAbyC4ikUslCeOpmMlo2WXWNQAhRGIiTUibbKB7NVkJCVB16IWDjRjV+7UB+Of4LUXFRbBm+hQIuJnuDu3pV/WwLFlQ/Ww9jh2T8AiJpWdX6tQNa/pVpIhBCOKFWBA8FWgDxQAEhRCiwAVggpTxr8yi1B3P7tjoTuHoVfH3Vp1YHM/ahsXSv3p1qJasZHcrdbt1SC8YiImDHDqhsbFmGq5GxXL8ZR5OKelhIy76shoa2AtWAN4GyUsqKUsrSQHtgL/CpEOJpG8eoPYjkZBgyRM1pX77c7vPZH9SFiAv4B/sDmC8JJCaqchD+/mpFdpMmRkeEX0AkAE0r6wvFWvZlNTT0sJQy8d4HpZThwCpglRDCcSqT5TdSqtLDa9fC3LmqO5WDefWvV9kTuIdLEy/h7uJudDj/kVJVaf3rL1W2+9FHjY4IUBeKC7g4UbusXk2sZV9WiaBoZvO0pZTh6SUKzUQ8PNTK4bFjjY4kRxb0WsDx0OPmSgIA330HixbBlCmqb4NJ/BsQQYMKxXFz0fNAtOzLKhEcQvUQEEAlICLl6xJAAFDFptFpORcfr8oST5umPr06mMCoQMoVLYdXYS86Fe5kdDj3GzpUDQ2NGWN0JHfEJyVz7OpNnmmty0dr1sn0Y4OUsoqUsiqqgmhvKaWnlLIU0AtYbY8AtRzYtk1dED56VN13oAVjALcTb9Pth24MWXVv1XIT2LNHVWotVEitHjbRz/bktVskJFloqheSaVbK7vljCynlhtQ7UsqNQEfbhKQ9sPLloVGj/0oTO5jX/3qd02GneaGZyTqMBQaqBWMmHWb793LqQjKdCDTrZHcdwQ0hxDvAj6ihoqeBMJtFpT2YmjVh/Xqjo8iRjWc38tXBr5jUahJdq3Y1Opy7VawI//wDnubs4+sXGEm54u6ULW6y6yma6WX3jGAw4AWsSbl5pTymmUlICLz4IgQEGB1Jjty4fYNnf3+W+qXr83HXj40OJ30NG5q2cY9fQIQeFtJyJFuJIGV20MtSyiZSyqZSyokpU0g1M5k/H775BmJjjY7EalJKXlj/AmG3w/ix74/mmyX0zjswfLjq4WBCIbfiCIqI1fWFtBzJNBEIIRYIIRpk8FxhIcSzQoihtglNs0p8PHz1FfTsqSqLOpglR5aw+uRqpnWZRqOyjYwO527R0TBvnkqwTuaclpm6kEwnAi0nsrpG8BXwbkoyOAaEAu5ADaAYsBD4yaYRatmzfLkaGpo0yehIrHYx4iITNk6gQ+UOvNr6VaPDud/SpRAZaeqfrV9AJK7OgnrlTViaWzO9TBOBlPIwMFAIUQRoDpQDbgMnpZRn7BCflh1SwsyZUL8+dDXZBdZs+Prg1wghWNpnKc5OJmuXabGon22LFqrjmEn5BURQt3xx3F1N9vPTHEJWReeeALyllPOAbUKI/agLxVII8YaU8ld7BKllYds2OHJErXY10bz27Prk4U8Y0XgElUuYcCHUxo2qfPeyZab92SYlWzgaFMVTLRxzurBmvKwGPN8Afk9z3w11ZtAJMM+Syvxuxgw1pXGICRdgZeJk6EmCbgbhJJyo41XH6HDSN2OGauAzYIDRkWTo1PVbxCYm60JzWo5llQjcpJSBae7vklKGSSkDgMI2jEvLrrNn1ZqBMWNUPXwHIaVkxNoRdP+xOxZpzpk4+PvDli0wbhy4mre2ol9gyoViXXpay6GsLhbf9RFDSjkuzV3H6mySV82eDS4upqp5kx1CCH7q9xPB0cE4CXPOxGHmTFVKYvRooyPJlN/lCDyLFMDbw3E+CGjmktVf4D4hxPP3PiiEeAHYb5uQNKtMmKDKIJcrZ3Qk2Xbt1jWklFQvWZ22ldoaHU76YmJg5Up45hkoae5uX36BkTSpVILMKgVrWmayOiOYBPwmhBgC/JvyWDOgANDHloFp2VSjhro5iPDYcFp824JB9Qfx+SOfGx1OxgoXhpMnTbtuIFVETAIXb8QwsLm+UKzlXFbVR0OklG2AD4FLKbcPpJStpZTBtg9Py1BSEjz3HPz7b9bbmoSUkpf+eIngmGAG1zdxhZLUst3e3qYtJ5HKLzC10Jy+PqDlXHZLTPhKKeek3HxtHZSWDadPq85jgYFZb2sSy/yX8fPxn5nacSrNyjczOpyMLV0KDz8M4eavouIXEImzk6Cht15IpuVcdquPamZTr54qLufmZnQk2RIQFcDYDWNpU7EN/2v3P6PDyZyTk5ol5GH+6Zh+AZHULluUQm76T1nLOXMPgGrpi4hQTekLFgRn868ktUgLI34bQbJM5oe+P+DiZPI3rWHD1EIyk198TbZIDqdcKNa0B6ETgSN66SVo2dJhWlDO2DODrZe2Mqv7LKp6VDU6nMxt3apaUDqAcyHRRMcn0aSi+c9cNHOzaSIQQnQXQpwWQpwTQkzOZLsWQohkIYR5l2+aRWAg/PILdOpk+k+sAEeDj/KW71v0qd2HkY1HGh1O5s6eVbWapk83OpJs8QtQF4r1imLtQdksEQghnIF5QA+gLjBYCFE3g+3+D9UXWcvKvHnqTGD8eKMjyZZPd32Kh7sHC3otMP8899TFeSNNnrBS+AVEUqKQKz6lChkdiubgbDlY+xBwTkp5AUAIsQJ4Ajhxz3bjgVVACxvGkjfExMCCBdCvH1Q2YYG2dCx6YhHnws/hVdjkC9EjI2HRIhg82GEW5/0bEEGTinohmfbgbDk0VAFIO7cxKOWxO4QQFYC+wNeZvZAQYrQQ4qAQ4mBoaGiuB+owlixRF4pNXBc/lX+wP1FxURRwKUC90vWMDidr332nEu3EiUZHki1RsYmcDYnWjeq1XGHLRJDex5R7r27OBP4npUzO7IWklAuklM2llM29vEz+ydJWLBaYNQseesjUdfEBEpMTeWLFEzz5y5NGh5I9SUkwZw507AhNmhgdTbYcDVKF5nSPYi032HJoKAhIu+7dG7h6zzbNgRUpp7aeQE8hRJKU8jcbxuWYNm6EM2dMXRc/lauzK8v6L8PVybwVO++yZo1akzF7ttGRZNu/lyMRAhpW1AvJtAdny0RwAKghhKgCXAEGAXcVzJdSVkn9WgixGFivk0AGZsxQJQ9MXBcf4MbtG3gW8qSVdyujQ8m+mTOhWjXo1cvoSLLNLzCCGqWLUMzdQZKtZmo2GxqSUiYB41CzgU4CK6WUx4UQLwohXrTVcfOkmzfh8mXT18UPuhlErbm1mLNvjtGhZN/+/bB7t6ri6gCL80DVbPILiNTDQlqusekSTynlBmDDPY+le2FYSjnClrE4tGLF4NQpNZZtUqmrh+OS4uhevbvR4WRfbCy0b+8wU0YBLtyIISo2Ua8o1nKNydf6a9y6pea2m7ycxJx9c9hycQvf9PqGGqUcpyw2HTvCjh1GR2EVv4CUjmT6jEDLJbrEhNnNmKHWDERGGh1Jhk6EnuB/f/+PXjV78XzT+/oYmdeuXRAVZXQUVvMLiKBoAReqexUxOhQtj9BnBGbXrZs6EyhhzmGAZEsyz659liJuRfiu93eOs7gpLg4efxx69ICffjI6Gqv4BUTSuFIJnJwc5GetmZ5OBGbXurWp1w3M3jebfVf28VO/nyhTpIzR4WSfuzts3qyG3BxITHwSp67fZFzn6kaHouUhemjIrKSEjz6C8+eNjiRD58PP87bv2/Sq2cvcHccy0qwZ1L2v/JWpHQ2KwiKhiS40p+UinQjMats2eOcdVRbZpN7Z+g6uzq58/djXjjMkBLBpk5olFBZmdCRWS21N2djbnEOFmmPSQ0NmNWMGeHrC0KFGR5Kh+Y/N58j1I1QoViHrjc0iOVmdaV24oKblOph/L0dS1bMwHoUdozOd5hj0GYEZnT0L69fDiy+acgw7PDacxORESriXoKNPR6PDsc6rr8LOnfDee6ZenJceKSWHAyNorNcPaLlMJwIzSq2L/9JLRkdyHyklz/z2DJ2WdMIiLUaHY50ZM1ThvokTYfRoo6OxWlBELDeiE/SKYi3X6aEhszF5XXwhBKOajCLsdhhOwoE+R/z6qzob6N8fvvjC6Ghy5N+UjmR6RbGW23QiMBsT18WXUiKEoE/tPkaHYp1du+Dpp9U03B9+ACcHSmBp+AVEUsjNmVplihodipbHOOZfRF5l8rr4I9eOZPo/jtHP947Tp+GJJ9Tq7N9/N+U1l+zyC4igoXdxXJz1n62Wu/RvlJmk1sU3YQeytafWsuTIEuKS4owOxTrTp6vrLX/+CaVKGR1NjsUlJnP86k1dX0izCZ0IzKRxY3jzTdPVxY+Mi2TMH2NoWKYhk9tNNjoc63z1lRoaqlIl621N7NiVKJIskiYV9fUBLffpRGAmNWrAxx+brsroq5teJSQmhIWPL8TV2QGmXCYlweTJEBoKbm7q5+rgdMVRzZZ0IjCL2bNh3z6jo7jP5vObWXh4Ia+1eY1m5ZsZHU72HDmifp6bNhkdSa7xC4ygYsmCeBUtYHQoWh6kE4EZ3L4N06bBypVGR3KX6IRonl/3PDVL1WRKxylGh5N9zZqpi8RPP210JLnm38uRNKmozwY029DTR82gUCFV8iAhwehI7vL2lrcJiApgx8gdFHR1gNk2P/2kykuPGgUVKxodTa65FhXL9Ztxev2AZjP6jMBoiYlgsUCRIlCypNHR3PFPwD/M2T+HsS3G0q5SO6PDyZqvryokt2yZ+nnmIanXB/SKYs1WdCIw2rffQr16cOOG0ZHcxbuYN8MbDefjrh8bHUrW/P2hb1+oVQtWr3bYBWMZ+fdyBG4uTtQp53hF8jTHoIeGjGSxqNo3xYubbo575RKVWdxnsdFhZC0oSHUZK1oUNmxQP8s8xi8wkgYViuPmkrcSnGYe+jfLSBs3wpkzagGZSer5+13zo/fy3ly7dc3oULIWFQU9e8LNmyoJ5KHrAqkSkiz4X4miqb4+oNmQPiMw0syZUKECDBhgdCR3nA0/y6kbp3B3cTc6lMwlJKgCcidPqlXDDRva/JDJFsnhwEgSkux3DSIgPIaEJIteP6DZlE4ERvH3h7//hk8+MVVd/IH1BtKvTj9cnEz8qyElPPccbNkCS5ZA1642P6TFIpn082F+P3LV5se6l7OToJluTanZkIn/2vO4mTNVATST1MXfdG4TQTeDGNV0lLmTAKjGPb/9ptZeDB9ul0N+tuk0vx+5ykudqtG+hpddjpmqVBE3yhQz+Rma5tBM/hefR4WEqDnvI0eaYsro0eCjPPnLk1T1qMqwRsNwczZ5G8SaNeHYMbtdE/hh72W+3n6eoS0r8fqjtRyrP7OmZYO+WGyEr7+G+Hh4+WWjI+Hqras8tuwxihYoyvoh682dBP74Q82yAqhUyS4X2DefCGbK2mN0rV2a9x+vp5OAlifpRGCEjRvVlMfatQ0NIzohml7LehEZF8kfQ/7Au5i3ofFkaeVKWLpUJVE78AuIYPzyf2lQoThzhjTRfQC0PEsPDRlh504IDzc0hGRLMoNXDeZI8BHWDV5H47KNDY0nWxYuVFNFC9i+8NrlsBieW3KQ0kXd+e6ZFhRy038qWt6lP+LYk5Tq06yLC5QubWAYkol/TmT9mfXM7TGXnjV6GhZLlsLC1DTRwEBVntvD9rNnwmMSGLHoABYpWTyyha74qeV5Nk0EQojuQojTQohzQoj7OpoIIYYKIY6m3HYLIRrZMh7Dbd+uxrb9/AwNY9a+Wcw9MJdXWr3CmBZjDI0lU7Gxqs3kH3+ozm12EJeYzHNLDnA1MpbvnmlOVa8idjmuphnJZue7QghnYB7QDQgCDgghfpdSnkiz2UWgo5QyQgjRA1gAtLRVTIYrVgy6dDH02kB4bDhTt02lb+2+TH/ExP2HLRYYNgx274aff4a2bW1+yGSL5OUVfvgFRjJ/aFOaVTZ+Rpem2YMtBz4fAs5JKS8ACCFWAE8AdxKBlHJ3mu33Aia/WvmAmjaF5csNDaFkwZLsGbWHyiUq4yRMPDL46quwahV88QU8+aTNDyel5MP1J9h0PJgpvevSvX45mx9T08zClu8EFYDANPeDUh7LyChgY3pPCCFGCyEOCiEOhoaG5mKIdrRmDVy8aNjhL0deZv6B+UgpqeNVh0KuhQyLJUszZ6rbhAmqDpMdfLfzIot3X+K5dlUY2dax+xtrmrVsmQjSm3At091QiM6oRPC/9J6XUi6QUjaXUjb38rLvqs5cERmphjmmGNfla96Beby55U2CY4INiyFbVq2CV16Bfv3gyy/tslZg/dGrfLThJI81KMdbPevY/HiaZja2TARBQNqln97AfYVahBANge+AJ6SUYTaMxzjffQcxMXb7dJueTx/+lH3P7aNskbKGxZClf/6BoUOhdWv48Uc1S8jG9l0I45Wfj9DCx4MvBjbCyUkvGNPyH1smggNADSFEFSGEGzAI+D3tBkKISsBqYJiU8owNYzFOUhLMmQMdO0KTJnY9tJSSD7d/SEBUAE7CiVqetex6fKutXKlmVa1dq+ow2di5kFs8v/QgFUsW5NvhzXF3tX3i0TQzslkikFImAeOATcBJYKWU8rgQ4kUhxIspm70HlAK+EkIcFkIctFU8hlmzRk19NOBs4JNdn/DetvdY7m/sBepsmzlTzRLy9LT5oUJuxvHMwgO4uTizeORDlChk4tIammZjQsp0h+1Nq3nz5vLgQQfKF23bwvXrqgGNHYY6Ui33X86Q1UMY2mAoP/T9wbw1cmJiVLP5adOgenX7HDI+iacW7OFCaAw/j25NA++819VM0+4lhDgkpWye3nN63Xx2vPkmbNt2/+OffAKdOsHeveoT/7ffQv36sG4dfPwxJCfDgQOqUJodk8CugF2MWDuC9pXa8/3j39s8CZy4epOpvx8nMQdN4ytdOc/UDZuZV7IZh+q3sUF09wuLTuBKZCzfDW+uk4CmoRNB1k6fhk8/hQYNoNw9c8tdUn58zs5qsVjqm72bm7oP8NRT8Oyzdgv332v/0mdFHyoXr8yap9ZQwMX25RFmbTnD8atRNM1B85TwqrV4/ZNfiXcvhL3W8BZ1d+V/3WvTubZxZT40zUx0IsjK7NnqjX3zZihTJv1tWrSATZv+u//oo+pmR8mWZD7f/Tnvbn2X0oVLs2HoBkoVKmXz4waE3eavE8GM6ViNN7pbuWJ62zZo2dIuF4Y1TcuYiZeWmkB4OCxerKY0ZpQETCAxOZGHf3iYyVsm83itxzny4hGql7TPePvi3ZdwFoLhrX2s2/H6dZUs333XJnFpmpZ9+owgMydPQtGipmggkxlXZ1faeLfhmUbP8EyjZ+x2YfhWXCIrDwbyWMNylC1uZSvF+fNVA/oXXrBNcJqmZZtOBJlp21aVPzZRc/lUUXFRjN84njHNx9C6Yms+6vqR3WNYeTCI6PgkRrWzsiRDXJxKBL16QY0atglO07Rs00NDGQkKUovBTJgEAIQQ7Anaw+Hrhw05frJFsnj3RZpX9qChdwnrdl62DEJDDV1prWnaf3QiSI+UqhlKjx5GR3KXhOQEvtzzJfFJ8RQrUAz/Mf6Gppb8NQAADXNJREFU9RPYfCKYwPBY688GpFQLxxo2hM6dbROcpmlW0UNDGXnrLaMjuMvJ0JMMXT0Uv+t+VCxWkSfrPYm7i5Xj8rlo4a6LeHsU5JF6VtYu8vUFf3/VdtKsi9w0LZ/RiSA9QqjOWCYgpeSrA1/x2ubXKOxamDVPraFP7T6GxuQfFMX+S+G881gdnK0t0jZjhmrTOXiwbYLTNM1qemjoXgEB8N57qleuwa5HX+exZY8xbuM4Ovl0wn+Mv+FJAGDhPxcp7ObMwBYVs944rdOnVdvJMWPA3bizGU3T7qYTwb3mzFHlIW7fNjSMdafX0WB+A7Ze2sqcHnPYMGQD5Yoa3zUr+GYc645c5cnmFSnmbuWF9Fu3oH17lQg0TTMNPTSUVnS0qhc0YABUtPLTbi6xSAvvb3ufD3Z8QOOyjfmp30/U9aprSCzp+WHPZZKlZGRbH+t3bt4cduzI9Zg0TXsw+owgrcWLISoKJk40LASB4HjocZ5p9Ax7Ru0xVRKIS0zmp32X6VanDJVLFbZu5z174MYN2wSmadoD0WcEqSwWVSW0VSt1s7OzYWdxdXbFp4QPy/ovw9XJ1XSlo1f/e4WI24k8a+2U0eRkVXyvXj3YmG5bak3TDKQTQar16+HcOVUX384SkxN55MdHqOZRjb+H/42bs/mapEgpWfjPReqVL0bLKiWt29nZGf78E+LjbROcpmkPRCeCVDNmqOsC/fvb7ZCpTYFcnV1Z/MRiKpeobLdjW2vH2RucC4nmy4GNcnamUtc8Q1yapt1NXyMAOHxYlUQeP/6/HgM2FpMQw6BVg/h89+cAdPTpiE8JH7scOycW7rqIV9EC9GpY3rod9+6FgQPhyhXbBKZp2gPTiQBUyYNCheC55+xyuEuRl2i7sC2/HP/FLsd7UOdCbrH9TCjDW1XGzcXKX5kZM1Qvh+K6E5immZUeGgI1r71jR/CwvsOWtXwv+jLwl4EkWZLYMHQD3at3t/kxH9T3uy7h5uLEkJaVrNsxIABWrYJXXoEi9uo/pmmatXQiANUlq2VLmx5CSsnsfbN59a9XqVmqJmsHraVGKfOXYI6ISWD1v0H0a1KBUkWsbHs5Z476d9y43A9M07Rck7+HhuLi1JqB8+dte5ikOEauHcnETRPpVbMX+57b5xBJAGDZ/gDikyzWTxlNXZzXvz9UsvJMQtM0u8rfieDQIfjmG7h82WaHuHLzCh0WdWDJkSVM7TiV1U+tpmiBojY7Xm5KSLKwdM8l2tfwpGYZK2NOXZynew5omunl76Ghtm1VA5qSVs6Lt0KSJYkbt2+YomqotTb4XyP4Zjyf9m9o3Y6pi/NatjRkcZ6madbJv2cEMTHq31Klcr0uvu9FX4atGYZFWqhcojKnx512uCQgpeT7XRep5lWYjjW8rNv5jz/U4jx9NqBpDiH/JoKnnoI+ufvmbJEWQA0H7Qncw5Wbau68q7M5211m5uDlCPyvRDGybRWcrO05MHeu3RfnaZqWc/kzEZw5oz61NmmSKy+3/8p+uv3QjS/3fAnAkAZDODn2JBWLG1PBNDd8v/MixQu60r+pt/U7L16s+hLbaXGepmkPJn8mglmzwM0NXnzxgV7mWMgx+v7cl5bfteTw9cMUL6AWTTk7OTvkWUCqwPDb/HXiOkNaVqKgm7P1L1CuHLRrl/uBaZpmE/kvEYSHq0+sQ4dCmTI5eonz4ecZtmYYDec3xPeiLx90+oALEy7wfLPnczdWgyzefQknIXimtY91OwYHQ7duqmSHpmkOI/+du3/3neo+9vLLVu965eYVPtzxId/7fY+rkyuvt3mdN9q+QalCpWwQqDFuxSXy84FAHmtYjrLFrWwnef68ukhcqJBtgtM0zSbyVyJITFSrXbt0gUaNrNr19I3TNP6mMcmWZF5o9gJvt3/bFK0jc9svB4OIjk/i2bZWLiD7//buP0aKuw7j+Pu5O07gigHbUhEOCpUaLEqpJ2otTdOIBZIG0WBaUy1Wg8ZCqoZoA02kNY2mqYY0GIhVtDZqJaFUEpvo1WjaRrT8EMuP4yxFEIQc4FUKodhw+/GPmSN3sLsW2O3MdZ5Xctmd2Zm7h0/Y+9x8Z2e+ANdfnzSDhuIdaJoNZHV9x0qaKalT0m5J95Z5XZIeSV9/UdJ19czD2rXJdQNlZiDrKfWw55U9bNi/4cy6+U/N544n7wDg6kuvZun0pXQu7GTF7BVvySbQUwp+8qd/0DZuBFNah5/fzi+/nMw34CZgNuDU7YhAUiPwA2AGcADYKGl9ROzss9ksYGL69SFgZfpYH8uXU3r3VWxva2XXjjV0HOmg42gHu47uovPfnZw6fYqRLSPpWtwFwIQRE+gp9fT+e7jvxvvqFi0P2nd2sb/7NZbMmnR+O0bA3LnJOZf29vqEM7O6qefQ0DRgd0TsAZD0BDAH6NsI5gA/i2SGlj9LGi5pVEQcqnWYDc9tY8qWTRx7Ww+NU6ZyDXANIJpoYBANaqaBFhpo4JbSM5SaBvGZ9n18cNcLzFh0MwBfWfcIU1/aUvXnnBhyCV9btOLM9pcfO8L9878NwJLHH2D8oT1V9z8wsrXf9icHD2X5vMUAPLTy64w43l11/x3jJ/fbfueV7+Wns5Lba696+As0po2tnImlEssmT2fGg7OSFVOmwF13JedTurth+vTyO54+nXwkN8O5ns3swtWzEYwG9vdZPsC5f+2X22Y00K8RSFoALAAYe4E3MGseO4YffepWJu/8K01NwxikoTQ3DCU5cOlv4juHUWpsYtDod/HqaxOYeEVyC+UYM4bu149V/TmnhrT02/7U24eeWf5v6zi6m6tfnHXqslH9tu8ZPPjM8vFx44nj1W+V3dPa2m/7xtGjzyy/Mm4CDaVS1f0/csP7aGpMh3cmTYKRI5PnjY3VZxm7+ebkk1hmNuCod7rEmn9jaR5wS0R8MV3+LDAtIhb12eY3wHci4vl0+ffANyJic6Xv29bWFps2bapLZjOztypJmyOirdxr9TyzdwDoe2ntGODgBWxjZmZ1VM9GsBGYKGm8pGbgNmD9WdusBz6Xfnrow8CxepwfMDOzyup2jiAiTktaCPwWaARWR8QOSV9OX18FPA3MBnYDJ4HP1yuPmZmVV9cLyiLiaZJf9n3XrerzPIC765nBzMyq89U/ZmYF50ZgZlZwbgRmZgXnRmBmVnB1u6CsXiQdAfZd4O6XAUdrGKdenLO2nLO2nLN23syM4yKi7ATkA64RXAxJmypdWZcnzllbzllbzlk7ecnooSEzs4JzIzAzK7iiNYIfZh3gDXLO2nLO2nLO2slFxkKdIzAzs3MV7YjAzMzO4kZgZlZwhWkEkmZK6pS0W9K9WeepRNJeSdskbZWUmxl4JK2WdFjS9j7r3iGpXdJL6WP16dPeBBVyLpP0r7SmWyXNzjhjq6Q/SOqQtEPSPen6XNWzSs681XOwpBck/S3NeX+6Pm/1rJQz83oW4hyBkvko/w7MIJkMZyNwe0TsrLpjBiTtBdoiIlcXwki6EThBMsf05HTdQ0B3RHw3ba4jIuKbOcy5DDgREQ9nma2XpFHAqIjYImkYsBn4BDCfHNWzSs5Pk696CmiJiBOSBgHPA/cAnyRf9ayUcyYZ17MoRwTTgN0RsSciXgeeAOZknGlAiYhnge6zVs8BHkufP0bySyJTFXLmSkQciogt6fPjQAfJXN25qmeVnLkSiRPp4qD0K8hfPSvlzFxRGsFoYH+f5QPk8D90KoDfSdosaUHWYf6PK3pnlEsfR2acp5qFkl5Mh44yH8LqJelKYCrwF3Jcz7NyQs7qKalR0lbgMNAeEbmsZ4WckHE9i9IIVGZdLjpxGR+NiOuAWcDd6VCHXZyVwFXAtcAh4HvZxklIugRYC3w1Il7NOk8lZXLmrp4R0RMR15LMez5N0uSsM5VTIWfm9SxKIzgAtPZZHgMczChLVRFxMH08DKwjGdbKq650HLl3PPlwxnnKioiu9A1YAh4lBzVNx4jXAj+PiCfT1bmrZ7mceaxnr4j4D/BHknH33NWzV9+ceahnURrBRmCipPGSmoHbgPUZZzqHpJb0pBySWoCPA9ur75Wp9cCd6fM7gV9nmKWi3l8GqblkXNP0pOGPgY6I+H6fl3JVz0o5c1jPyyUNT58PAT4G7CJ/9SybMw/1LMSnhgDSj2QtBxqB1RHxYMaRziFpAslRACTzSf8iLzkl/RK4ieS2uV3At4CngDXAWOCfwLyIyPREbYWcN5EcdgewF/hS79hxFiTdADwHbANK6eolJOPvualnlZy3k696vp/kZHAjyR+3ayLiAUmXkq96Vsr5OBnXszCNwMzMyivK0JCZmVXgRmBmVnBuBGZmBedGYGZWcG4EZmYF50ZgVmPp3SQXZ53D7I1yIzAzKzg3ArMakLRUyXwXzwDvyTqP2floyjqA2UAn6QMkty2ZSvKe2kJy736zAcGNwOziTQfWRcRJAEm5u4+VWTUeGjKrDd+rxQYsNwKzi/csMFfSkPTusbdmHcjsfHhoyOwipXP6/grYCuwjuWOn2YDhu4+amRWch4bMzArOjcDMrODcCMzMCs6NwMys4NwIzMwKzo3AzKzg3AjMzAruf69MACHgiVR3AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -576,22 +576,23 @@ " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0. , 0. , 0. , 0. ,\n", - " 0.0952381 , 0.0952381 , 0.0952381 , 0.0952381 , 0.19047619,\n", - " 0.19047619, 0.19047619, 0.28571429, 0.47619048, 0.57142857,\n", - " 0.76190476, 0.85714286, 0.95238095, 0.95238095, 1. ]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3179, 0.1553, 0.0608,\n", - " 0.0189, 0.0252, 0.0058, 0.002 , 0.0014, 0.0084, 0.0102, 0.075 ,\n", - " 0.1346, 0.3083, 0.1204, 0. ]), replications=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0.2 , 0. , ..., 0. , 0.10526316,\n", - " 0. ],\n", + " 0.16666667, 0.16666667, 0.16666667, 0.16666667, 0.25 ,\n", + " 0.25 , 0.25 , 0.41666667, 0.58333333, 0.75 ,\n", + " 0.83333333, 0.83333333, 0.91666667, 0.91666667, 1. ]), pvalue=array([0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 1.097e-01,\n", + " 4.070e-02, 1.130e-02, 2.700e-03, 5.100e-03, 4.000e-04, 1.000e-04,\n", + " 1.000e-04, 1.800e-03, 1.960e-02, 4.800e-02, 2.120e-02, 6.490e-02,\n", + " 2.500e-02, 0.000e+00]), replications=array([[0. , 0. , 0. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [0. , 0. , 0.16666667, ..., 0.91666667, 1. ,\n", + " 1. ],\n", + " [0. , 0.16666667, 0.33333333, ..., 1. , 1. ,\n", + " 1. ],\n", " ...,\n", - " [0.95833333, 0.95 , 1. , ..., 0.85714286, 1. ,\n", - " 0.95238095],\n", - " [1. , 1. , 1. , ..., 0.95238095, 1. ,\n", - " 0.95238095],\n", - " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " [0. , 0. , 0. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [0. , 0. , 0. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [0. , 0.18181818, 0.18181818, ..., 0.90909091, 0.90909091,\n", " 1. ]]))" ] }, @@ -612,7 +613,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3dd3xb1fn48c+RLcuWR7x30qQlUAJfSIsJFEoZZYRRKNAS9iwpYZT5bVgps/zaUspKaEpoCJQ9AmGkpaxCgTISGkpCCt8QIN5WvLV1dc/vD1vGcbziaF3peb9efsWSru55ci09ujr3POcorTVCCCGsz5boAIQQQkSHJHQhhEgRktCFECJFSEIXQogUIQldCCFSRGaiGi4tLdVTp05NVPNCCGFJq1ev3qy1LhvusYQl9KlTp7Jq1apENS+EEJaklPpqpMeky0UIIVKEJHQhhEgRktCFECJFJKwPfTihUIiGhgb8fn+iQ7G87OxsamtrsdvtiQ5FCBEnSZXQGxoayM/PZ+rUqSilEh2OZWmtaW9vp6GhgWnTpiU6HCFEnIzZ5aKUWqqUalNKrR3hcaWUuksptUEp9R+l1HcnGozf76ekpESS+XZSSlFSUiLfdIRIM+PpQ18GzB7l8cOB6f0/c4E/bk9AksyjQ46jEOlnzISutX4T6Bhlk2OAB3Wfd4FCpVRVtAIUQoiUEQzAE7+D9e/FZPfR6EOvAeoH3W7ov6956IZKqbn0ncUzZcqUKDQdGw0NDVxwwQV88sknmKbJUUcdxa233sojjzzCqlWrWLhwYaJD3EJeXh5utzvRYYg0oLXG7XbT29ub6FAsx/HRq0x65DoyW78gcOylOHbeK+ptRCOhD/fdfthVM7TW9wL3AtTV1SXlyhpaa4477jjmzZvHihUrCIfDzJ07l2uuuYZddtkl6u0ZhkFmZlJdmxZiK5FE3t7eTigUwm63S7feOGW2fUnRYzfi/Pg1ghXTqJ+3hLLDT41NW1HYRwMwedDtWqApCvtNiNdee43s7GzOOussADIyMrj99tuZNm0aN910E/X19cyePZsvvviCk08+meuuuw6Px8MJJ5xAQ0MD4XCYBQsWMGfOHFavXs1ll12G2+2mtLSUZcuWUVVVxQEHHMA+++zD22+/zUEHHcT999/Pxo0bsdlseL1edtppJzZu3MimTZu44IILcLlcOJ1OlixZwre//e2Btg3DYPbs0S5vCLF9tNZ4vV5cLhehUAiHw0Fubm6iw7IE5feQ9/xd5L10LzrTTvcJ19K6zxwqa6eQnZ0dkzajkdCfAy5USj0G7AV0a6236m7ZZn+8BD5fs9272cK3ZsK8O0bdZN26deyxxx5b3FdQUMCUKVMwDIP333+ftWvX4nQ62XPPPTnyyCP56quvqK6u5sUXXwSgu7ubUCjERRddxIoVKygrK+Pxxx/nmmuuYenSpQB0dXXxxhtvAPDhhx/yxhtvcOCBB/L8889z2GGHYbfbmTt3LosXL2b69Om89957nH/++bz22mtcfPHFzJs3j9NPP51FixZF9xgJQV8i9/l8bN68mUAgIIl8W2hNzrvPUvD4zWR0teDd9yf0/PRqeu15FBUWUlBQELOmx0zoSqlHgQOAUqVUA3AdYO+LWy8GVgJHABsAL3BWrIKNB631sF8lI/cfcsghlJSUAHDcccfx1ltvccQRR3DFFVcwf/58jjrqKPbbbz/Wrl3L2rVrOeSQQwAIh8NUVX19rXjOnDlb/P74449z4IEH8thjj3H++efjdrt55513+OlPfzqwXSAQAODtt9/m6aefBuC0005j/vz50T8QIi1prfH7/WzevBm/309WVpYk8m2Q+dVaJj28AMdn7xOcuhsdF/6J0A51+P1+crKyBnJHzNofawOt9UljPK6BC6IWUcQYZ9Kxsssuuwwky4ienh7q6+vJyMjYKtkrpdhxxx1ZvXo1K1eu5KqrruLQQw/l2GOPZZddduFf//rXsO0MfpMcffTRXHXVVXR0dLB69WoOOuggPB4PhYWFrFkz/LcU6b8U0ebz+Whvb8fn82G32yWRbwPl7qBg+a04X38IM6+QrrNuxbvfHLBlEAqFUEpRWVmJzRbb2VZkLpchfvjDH+L1ennwwQeBvjPryy+/nDPPPBOn08nLL79MR0cHPp+PZ599ln333ZempiacTiennnoqV1xxBR9++CE77bQTLpdrIKGHQiHWrVs3bJt5eXnMmjWLiy++mKOOOoqMjAwKCgqYNm0aTz75JNB35vTRRx8BsO+++/LYY48B8PDDD8f6kIgU5/f7aWxspL6+HsMwyM3NJSsrK9FhWYMZxvnqMirm74fzHw/jOfgs2n7zT7z7nwy2DMLhMMFgkOrq6rgMfpCEPoRSimeeeYYnn3yS6dOns+OOO5Kdnc0tt9wCwPe//31OO+00Zs6cyfHHH09dXR0ff/wxs2bNYubMmfz617/m2muvJSsri6eeeor58+ez++67M3PmTN55550R250zZw4PPfTQFl0xDz/8MH/+85/Zfffd2WWXXVixYgUAd955J4sWLWLPPfeku7s7tgdEpKxAIEBzczP19fUEg0Hy8vIkkW+DrE/fpey62RT+5RpCU2bguuElek65EZ1bCHx9HaKyshKHwxGXmFRfj0n81dXV6aELXKxfv56dd945IfGkIjme6UVrvcWPaZoj3ufxeOjt7SUzMzNuySZpBH3YvBMfR698PeQ/+wec763AKK6m58Rf4d/zKBjSDerxeCgqKqK0tHR7I96yfaVWa63rhntMBkALYSFaa3p7e3G73YTDYUzT3OIHxr6+orUmIyMDp9OZdtdiMhv+S8lvfkKGu3O79qMzHfQecynuIy5AO3K2etzn85Gbmxvzi6BDSUIXwiK8Xu/AMMKsrCyUUthstoGL9emWnLeVrdtF8e1nQGYWXaf9GtQEe5xtNgK7/IBw2fDV7sFgkIyMDCoqKuL+N5GELkSSCwQCtLe34/F4ZBjhRAV9FN95FrbedtqvXk5o6m4xacYwDAzDYMqUKWRkZMSkjdFIQhciSRmGQWdnJ11dXWRkZEginyjTpOi+S7F/sYbOC5fELJmbponf76empiZhF5cloQuRZEzTpLu7m46OvklO07GvO5ryn/k9Oe8/T/cJ1+Lf4/CYtePz+SgrK0voB68kdCGSRGT0icvlwjAMcnJyYl6Ikupy3n6S/OfvxPODk/Ecfl7M2vF6veTn51NYWBizNsYjqRN6fX39QLl7NDgcDiZPnjzqNnfeeSdLlixBa825557LJZdcAsD111/PkiVLKCsrA+CWW27hiCOO4O2332bevHk4HA4effRRdthhB7q6upgzZw5/+9vfhj2zCoVCLFiwgKeffhqHw4HT6eSGG27g8MMPZ+rUqaxatSrqQ51EcvP7/bhcLvx+Pw6HI/2GEsZA1qfvUrj0fwnsvC/dp9+y1bDCaInMdVNeXp7wb1JJndADgQBOpzNq+/N6vaM+vnbtWpYsWcL7779PVlYWs2fP5sgjj2T69OkAXHrppVxxxRVbPOe2227j6aef5ssvv+SPf/wjt912GzfddBNXX331iH/cBQsW0NzczNq1a3E4HLS2tg5M1CXSSygUor29nd7eXim3j6KMlo0U33UORvk36LjwXsiMzWLphmGgtY5LWf94JD6CJLJ+/Xr23ntvnE4nmZmZ7L///jzzzDOjPsdut+Pz+fB6vdjtdj7//HMaGxvZf//9h93e6/WyZMkS7r777oGzsIqKCk444YSo/39E8gqHw7S3t/Pll1/i9XpxOp1SpRklyt1Jye2no5Wi49IHBio3o800TQKBAFVVVdjtsfnA2FaS0AfZddddefPNN2lvb8fr9bJy5Urq679ejGnhwoXstttunH322XR29hUmXHXVVcydO5c77riDCy+8kGuuuYabbrppxDY2bNjAlClTYjqFpkheWmt6enr46quv6OzsJCcnh+zs7IR/VU8ZRpDiu88lo72Rzl8sJVw+NSbNROaJLysrIydn68KiRJGEPsjOO+/M/PnzOeSQQ5g9eza77777wIQ68+bN4/PPP2fNmjVUVVVx+eWXAzBz5kzeffddXn/9dTZu3Eh1dTVaa+bMmcOpp55Ka2trIv9LIklEEsBXX31Fa2srdrsdp9OZFF/TU4bWFC6bj+PTf9F19m0Ed5wVs6Z8Ph+FhYVMmjQpZm1MhLyahjjnnHP48MMPefPNNykuLh7oP6+oqCAjIwObzca5557L+++/v8XztNbcfPPNLFiwgBtuuIEbbriBU089lbvuumuL7XbYYQc2bdokazKmkUAgQFNTEw0NDSilyM3NTUjRSarLe3ERzreeoPeYy/Dtc1zM2vH5fGRnZ1NaWpp036wkoQ/R1tYGwKZNm1i+fDknndQ3HXxz89eLMD3zzDPsuuuuWzzvgQce4Mgjj6SoqAiv14vNZhtYUm4wp9PJOeecwy9+8QuCweDAvh966KFY/rdEAhiGQVtbG5s2bRqYzTBZ+lpTTfYHL1Dw1P/Du/eP6f3xZTFrx+v1kpOTQ1VVVVJ+u0rqUS4Oh2PMkSnbur+xHH/88bS3t2O321m0aBFFRUUA/PKXv2TNmjUopZg6dSp/+tOfBp7j9Xp54IEH+Pvf/w7AZZddxvHHH09WVhaPPvroVm3cfPPNXHvttcyYMYPs7Gxyc3O58cYbo/S/FIkWKQxqb29HKSWFQTFm3/hviu69mOAOdXSdfVtMhidGuszy8/MpLy9PymQOMn1uSpPjGV9aa9xuNy6XC9M0yc7OTto3fqrI2NxA6Y1HoR05bF7wAmZB9Gc3jBR8RabCTfSHs0yfK0SM+Xw+XC7XQJFJPFanSXfK10vxHWegQgHa5z8Rk2RumiZer5fS0lKKiooSnszHIq86IbZDMBgcKAySmRDjKGxQdM88Mpv+j/bLH8Ko2TH6TYTD+Hw+ysvLE17SP15Jl9C11kn/KWgFiepKSxeGYdDV1UVnZycZGRnk5eUlOqS0MumR68j++HW6zvwdwV1+EPX9G4YxUDSUn58f9f3HSlIl9OzsbNrb2ykpKZGkvh201rS3t5OdnZ3oUFJSb28vLpcLrbVc8EyA3JeXkvvqMtyzz8N7wClR338oFCIUClFbW5tURUPjkVQJvba2loaGBlwuV6JDsbzs7Gxqa2sTHUZKMU2T9vb2gQpPGUsef441r1DwyHX4vnMYPSdcHfX9B4NBTNOktrbWkidESZXQ7XY706ZNS3QYQmzFMAxaWloG1oqUs/L4y9y0jqLF5xOaMoOu8xaCLbofqH6/H5vNRm1trWXn1UmqhC5EMvL5fDQ3Nw9UeYr4s3W1UnLHGeicfDouWYZ2RG8WVuj7G9vtdqqrqy09Qsm6kQsRY1pruru7aWtrIzs729JvdCtTAS/Fd5yJ8nSz+epnMIuqorp/n8+Hw+GgqqrK8t1o8goVYhimaeJyueju7pZJtBLJNCm892LsX31Mxy+WYnxj17GfM06R6s+8vDwqKipS4m8sCV2IIYLBIC0tLQSDQekvT7D8p35DzuqVdJ90PYHvHBq1/UaqPwsLCykrK0uZv7EkdCEG8Xg8tLS0YLPZorpalth2zjceJX/lIjwHnobn0J9Fbb+R6s/i4uKUGyItCV0I+s7YOjs72bx5s/SXJ4GsT95i0oNX4t91f7pPuSlqE25FCoasVP25LeRVK9JeOBymtbUVj8cjXSxJILNpA8UL52JUfJPO8xdHbT1Qv98PYMmCofEa11UApdRspdSnSqkNSqkrh3l8klLqeaXUR0qpdUqps6IfqhDRFwgEqK+vl/HlScLW20Hx7aejM+10XPog2rn9SzVGLn7a7XYmT56csskcxpHQlVIZwCLgcGAGcJJSasaQzS4APtFa7w4cANymlLLmyHyRNnp7e9m0aRNASr/JLSMUoOjuc8jobKHjF0sJl03e7l1G+ssLCgqoqalJ+QVGxtPlMgvYoLXeCKCUegw4Bvhk0DYayFd9pzd5QAdgRDlWIaJCSviTkNYULr0Cx2fv0zHvHkI77LHduwyFQgSDQSoqKsjPz0+Lb1/jSeg1QP2g2w3AXkO2WQg8BzQB+cAcrbU5dEdKqbnAXIApU6ZMJF4htov0lyenvOfuwPmv5fQc97/49zpmu/cXCATQWjN58mRLzskyUePpQx/uFT90btbDgDVANTATWKiU2qrzS2t9r9a6TmtdV1ZWts3BCrE9DMOgqalJ+suTTM67z1LwzO/x7nM87h9dvF37iowvt9vtTJkyJa2SOYwvoTcAgzuzauk7Ex/sLGC57rMB+AL4dnRCFGL7BYNBGhoaMAxD+suTiP3/PqDwvssI7LgXXWfdul3DE03THCgWsvqcLBM1noT+ATBdKTWt/0LnifR1rwy2CfghgFKqAtgJ2BjNQIWYKL/fT0NDAzC+hcJFfGS4NlF81zmES6ro+MV9YJ/43yYUCuHz+aiqqqKsrCwlyvgnYsyPMK21oZS6EHgJyACWaq3XKaXO6398MXATsEwp9TF9XTTztdabYxi3EOPi8XhoamoiKysr5Uc4WInydFN8++koM8zmSx5A5xVPeF9+vx+lFFOmTEn7D+xxfSfRWq8EVg65b/Gg35uA6E20IEQU9PT00NraKos2JxsjRNE955HZ+gXtVzxKuGqHCe0mMr48NzeX8vJy+RsjlaIiBWmt6erqwuVyyUyJSWjSwwvIXvcmnef8geDO+0xoH5EFnFNxPpbtIQldpBStNZs3b6azs1OSeRKyf/kxua//Bffsn+Pbb86E9hEMBjEMg+rqalmcewhJ6CJlmKZJW1sbvb29MiwxSeW+shQzK4feCQ5PjCwTN3ny5LTvLx+OJHSREsLh8BZrforkY+tpJ+fdFXj3OwGdO2mbniv95eMjR0VYXigUorm5mVAoJHOYJzHnm4+gjACeg7dt7r7IfCxFRUWUlpbKN69RSEIXlhYMBmlsbERrLQVDySxs4HztQQI774tRs9O4nxaZv7yyspKCgu2feTHVyRUjYVl+v5/6+nqUUmlX4m012f/+O5kdTXgOPnvcz/H7/RiGQW1trSTzcZIzdGFJbreb5uZmGWNuEbmvLMUoqcX/nUPG3FZrjd/vJysri8rKSikI2wZyhi4sp7e3l+bmZlkqziIy69fj+O+/8P7wDLCNPlVxpL88Nzc3LeYvjzZ5NwhL8Xq9tLS0kJOTI2PMLSL31fvR9mw8Pzhx1O0ixUJlZWUUFhbKxc8JkIQuLCMQCNDU1ITD4ZBkbhHK00XOO8vxfu/YUedrkWKh6JCELiwhFArR2NiI3W6XbhYLcb75GLagb9ShipFioSlTppCVJStXbg95Z4ikZxgGjY2NKKWkT9VKzDC5rz1AYMe9MKbsstXDg4uFKioqZCnAKJDvrSKpmaZJS0sLpmlKqbfFOD56lUzXpmHPziOLURQVFVFVVSXJPErkDF0kLa01ra2tBAIBKRqyoNxX7idcVIn/u7O3uF+KhWJHztBFUorMmuh2uyWZW1Bm0way172J58DTIfPrbrJwOEwgEJBioRiRhC6SUmdn58AUuMJ6cl+9H52ZhfeAUwbuM00Tv99PVVWVfEjHiCR0kXR6enrYvHkzTqdTxiJbkPL1kvP2k/hm/QizoBT4umCosrJShiXGkCR0kVQ8Hg+tra2yOIWFOd96ApvfMzBvSySZl5eXk5+fn+DoUpu8Y0TS8Pv9UjhkdaZJ7qvLCH7zO4S+OXNgaGJpaSmFhYWJji7lybtGJIVgMEhTUxNZWVlSOGRhjnVvktmyEc/BZ6O1xuPxUFxcTFFRUaJDSwuS0EXCGYZBU1OTFA6lgNxXlhIuKMM36yi8Xi+FhYWyiHMcSUIXCWWaJs3NzWitpXDI4jLavsTxn9fwHngq3qBBfn4+ZWVlkszjSBK6SBitNS0tLQQCAUnmKSD31WVgy6B975/gdDopLy+XZB5nktBFQmitcblceDweGWueApTfg/PNx/F8ZzYZ5ZOpqKiQC9sJIEdcJERnZyfd3d2SzFNEzjtPY/P14D74LKqrq2VulgSRhC7iTgqHUozWOF+5n8CUXSnd70eSzBNIErqIK7fbPVA4JMk8Ndg+foOsps/IOO4SMmWUUkJJQhdx4/f7B9YClf7V1GAYBnmvLkMXlJJ58CljP0HElLyrRFxECoccDod8JU8RhmEQbtpI7sevoo44F7KyEx1S2htXQldKzVZKfaqU2qCUunKEbQ5QSq1RSq1TSr0R3TCFlUUKh2w2m1SBpoiBaXDXPI8COOq8RIckGMcCF0qpDGARcAjQAHyglHpOa/3JoG0KgXuA2VrrTUqp8lgFLKwlHA5L4VCKGZgGt7gQ+8vLYJ8fQ/mURIclGN8Z+ixgg9Z6o9Y6CDwGHDNkm5OB5VrrTQBa67bohimsyDRNWltbCQaDksxThGEY+Hy+vmlw338OejvgmIsSHZboN56EXgPUD7rd0H/fYDsCRUqpfyilViulTh9uR0qpuUqpVUqpVS6Xa2IRC0uIrDjk8XhkMYMUEQgEMAyDyZMnk5+XByvuhqm7wm77Jzo00W88CX24sWV6yO1MYA/gSOAwYIFSasetnqT1vVrrOq11XVlZ2TYHK6yjvb2drq4uKRxKEV6vl8zMTCZPnkx2djasexs2ftR3di7DT5PGeK5QNQCTB92uBZqG2Waz1toDeJRSbwK7A59FJUphKV1dXXR0dJCbmytjzS0uMgVuQUEB5eXlXw83XXE35BXCQTJUMZmM5wz9A2C6UmqaUioLOBF4bsg2K4D9lFKZSiknsBewPrqhCitwu920tbVJ4VAKCIfDeDweSktLt5ybZXMj/PNpmH0O5OQmNkixhTHP0LXWhlLqQuAlIANYqrVep5Q6r//xxVrr9UqpvwH/AUzgPq312lgGLpKPz+ejubmZnJwcKRyyuFAoRDAYpKqqautl415YDNqEH52fmODEiJTWQ7vD46Ourk6vWrUqIW2L6AsGg9TX12O322WsucX5/X4Aqqur+/rLB+vthLN3gp33hhuHflEX8aCUWq21rhvuMXnnie0WCoVobGwkIyNDkrmFaa3x+Xw4HA6qqqq2/luGgnDj8eDpgpOvTUyQYlTy7hPbRQqHUoNpmvh8PgoKCigrK9u6y0xruGsefPQ6/PJB+PasxAQqRiUJXUxYpHAoFArJWHMLC4fD+Hw+ysrKKCwsHP5i9pO3wktL4ZQFcPBp8Q9SjIskdDEhWmva2trwer0y1tzCgsEghmFQXV1NXl7e8Bu9tRzumw8HnAin3xDfAMU2kYQuJqS9vZ3e3l5J5hbm9/ux2WxMnjx55O6yTz+A354KM74HV9wvRURJThK62GZSOGRtWmu8Xi85OTlUVlaOfCG7bRNcdzQUVsB1z8r0uBYgCV1sk97eXlwulxQOWVQkmU+aNInS0tKR6wW8vbDgKPB74bevQpFMoGoFktDFuPl8PlpaWmTFIQvzer0DI1lG/EAOG3DLifDVJ3DzSvjGjPgGKSZMEroYl0AgQGNjo6w4ZGFer5fc3NzRkznAny6H91fCLxZD3aHxC1BsNznNEmOKFA5lZmZK4ZBF+Xw+srOzqaysHP3b1YqF8OxdcPxlcNTP4xegiApJ6GJU4XCYpqYmlFJkZWUlOhwxAYFAgKysLKqqqkZP5u//Ff54MXzvaPjZ7+IXoIgaSehiRKZp0tzcTDgclipQiwoEAiilqKqqGr2r7IuP4ZY58M3d4cqHQbrVLEkSuhhWpHDI7/dvPUGTsIRgMAhATU3N6F1lHS19I1py8uHG5yFnhAIjkfSkQ1RsJbJ8XG9vL7m5Mt+1FYVCIUzTpLa2FrvdPvKGfi9cdwx0b4Y//BNKh64uKaxEztDFVrq6uujs7JQqUIsyDINQKER1dfXo1z1ME249Az77AK56BKZ/N35BipiQhC62IIVD1hYOhwkEAtTU1IzdVbbsWvjnU3Du72GfY+IToIgpSehigNfrpbm5GafTKYVDFmSaJn6/n6qqqrFnv/z7Mnjs/8GRP4fjL41LfCL25F0rgL7REE1NTVIFalGR+cwrKytHnjUx4qN/wB1z4buHwAV3y4RbKUTeuWKgcEiWj7OmyPwsZWVlW6//OVRPR9+qQzXT4donIHOUC6bCcuTdm+YMw6CxsRGl1OijIURS0lrj8XgoLS2lsLBw7Cf87c/Q2wG/exXyxrG9sBQ5Q09jpmnS0tKCaZpSOGRBkWReXFxMUVHR2E8Ih+H5e+B/fgDfmhn7AEXcSUJPU1prWltbpXDIwrxeL4WFhZSUlIxvRNJ7L0Drl3DMRTGPTSSGJPQ0pLXG5XLhdrtlrLlFeb1e8vLyxp45cbAVC6G0Fvb9cWyDEwkjCT0NdXZ20tXVJcnconw+H06nk4qKivEn803r4d+vwI/mQYZcOktVktDTTE9PD5s3b5bCIYvy+/1kZWVRUVGxbcNLVywEuwMOPzd2wYmEk4SeRjweD62trVI4ZFHBYHB8MycO5emGlx+AA06EwrLYBSgSTt7VacLv99PU1ITD4ZBkbkGGYRAOh8eeOXE4f18Gfo9cDE0D8s5OA8FgkKamJrKysqRwyIIGz8+yzYuMmGZfd8uM78GOe8QmQJE0JKGnOMMwaGpqwmazSeGQBUVK+quqqiY2vHTVS9C0Qc7O04Qk9BQWDodpbm5Gay3Lx1lQpKS/oqJi7PlZRrLibiiuhO8fH93gRFKShJ6iIoVDgUBAqkAtKJLMS0pKmDRp0sR20vh/8MFf4Yifg10+0NPBuBK6Umq2UupTpdQGpdSVo2y3p1IqrJT6SfRCFNsqUjjk8XhkrLlFeb1eJk2aRHFx8cR38tyivjHnR/48eoGJpDZmQldKZQCLgMOBGcBJSqkZI2z3W+ClaAcptk1nZyfd3d2SzC3K5/ORm5tLaWnpxGsFfG546X74wU+hpCq6AYqkNZ4z9FnABq31Rq11EHgMGG55k4uAp4G2KMYntpEUDllbIBCYWOHQUK/8Bbw9cjE0zYznFVMD1A+63dB/3wClVA1wLLB4tB0ppeYqpVYppVa5XK5tjVWMwe1209LSIsncoiZcODSU1vDcQpi+B+y8d/QCFElvPAl9uMygh9y+A3ggN18AABMhSURBVJivtQ6PtiOt9b1a6zqtdV1ZmVSsRZPf76e5uZmcnBwpHLKgUCiEaZpUV1dvf63Amtfgq0/6zs7lgz2tjOeV0wBMHnS7Fmgask0d8Fj/WWEpcIRSytBaPxuVKMWoIoVDDodj+87sREKEw2GCwSCTJ0+OzvDSZ++GSaVwwJzt35ewlPEk9A+A6UqpaUAjcCJw8uANtNbTIr8rpZYBL0gyj4/BhUNSBWo9kYWdq6urozMvfcuX8N7zMOdKyJJ57tPNmBlAa20opS6kb/RKBrBUa71OKXVe/+Oj9puL2IkUDpmmKYtUWFBkrHllZSW5ubnR2enz9wAKjpoXnf0JSxnXKZ3WeiWwcsh9wyZyrfWZ2x+WGItpmrS2thIMBsnJyUl0OGIbDV4LtKCgIDo79Xvhb/fBvsdCWW109iksRa6eWdDgwiFJ5tYUWT5uXGuBjtfrj0BvJxxzYfT2KSxFEroFtbe3S+GQhU1o+bixaN03b8u0/+lbBFqkJUnoFtPV1UVHRwe5ubky1tyCIotyb9PyceOx9i3Y+B8ZqpjmJKFbiNvtpq2tTQqHLCoQCGCz2aisrIx+rcCKuyG/CA46Jbr7FZYiCd0ifD6fFA5ZWCgUQms9sRWHxuJqgLeWw2HnQLZ0w6UzyQwWEAgEpHDIwgzDIBQKUVNTE5tFRl5YDNqEH50f/X0LS5GEnuRCoRBNTU1kZGRI4ZAFDS4cism89EE/rLwX9v4RVE0be3uR0iShJzFZccjaTNMcKByK2YikN56AbpfMqigASehJK1I4FAqFpArUgiJVoGVlZdErHNq6kb6LoVN2hu/8MDZtCEuRhJ6EtNa0tbXh9XqlcMiivF4vRUVFFBYWxq6R/74Hn62Coy+UoYoCkISelNrb2+nt7ZXCIYvy+Xzk5+dv34pD4/Hs3eAsgENOj10bwlIkoSeZzs5OOjo6JJlblN/vx+FwUF5eHttk3tEC/3wSDj0TcvJi146wFEnoSaS3t1eWj7OwQCBARkYGVVVVsa8VePFPYITg6Ati246wFEnoScLn89HS0kJ2drYUDllQpHCouro69rUCoSC8uBjqZkPtjrFtS1iKZI4kEAgEaGxslMIhi4p54dBQby3v63L5sQxVFFuShJ5goVCIxsZGMjMzpXDIgsLhMIFAgJqamtgUDg1nxd1QvUPfGboQg0hCT6BwOExTUxNKKSkcsiDTNPH5fFRWVsZveOnKJfDJO32FRNI1J4aQV0SCmKZJc3Mz4XA4fmd2Imq01vh8PsrKysjPz49Pox++Anef33dmfrTM2yK2Jgk9ASKFQ5G5sYX1xKVwaLBN6+Gmn8Dkb8M1j0OGdM+JrUlCTwApHLI2r9dLfn4+JSUl8Rle2uWCa48EuwNuegFyYzSVgLA8+ZiPs56enoEVh4T1+Hw+srOzY184FBH0ww3HQkcz3PoPqPhG7NsUliUJPY78fj+tra1SOGRRfr8fu90en8Ih6Jt867ZzYN3bcO0TsPNesW9TWJp0ucRJZF5zh8MhhUMWFAwGUUpRVVUVv1qBh26E1x+Bs26BH/w0Pm0KS5PMEgemadLS0gIgY80tyDAMwuEw1dXV8SkcAnj1YfjL9X1ztZx4ZXzaFJYnCT3GIiNagsGgjGixoEjhUMxWHBrOurfhD2fDbvvDxX+SqXHFuElCj7Guri56e3tlXnMLihQOVVVVxe/v17wRrv8xlH8DfrUc7FJwJsZPEnoMud1uXC6XJHMLiqw4VF5eTl5enKandXf1DU80Tbj5RSgojk+7ImVIh26MBAIBWlpayMnJkYugFqO1xuPxUFxcHL/CISPUVzjU/Dn85mWomR6fdkVKkYQeA4Zh0NzcTGZmpsyeaEFer5dJkyZRUlISnwa17ivp//ercMWyvr5zISZATh2jzDRN2traME1TJtyyIJ/PR25uLmVlZfGrFXjqNvjrfXDSNXDoGfFpU6SkcSV0pdRspdSnSqkNSqmtxlAppU5RSv2n/+cdpdTu0Q/VGtrb2/F4PDKixYL8fj9ZWVlUVFTEr5vsrWfgvl/C/ifAGTfGp02RssZ81SqlMoBFwOHADOAkpdSMIZt9Aeyvtd4NuAm4N9qBWkFPTw+dnZ0yR4sFJaRw6LPV8NtTYKdZfV0tcq1FbKfxvIJmARu01hu11kHgMeCYwRtord/RWnf233wXqI1umMkvsoSclPVbT6RwqKamJn6FX64G+NWPoLAcblgBDhkJJbbfeBJ6DVA/6HZD/30jOQf463APKKXmKqVWKaVWuVyu8UeZ5EKhEM3NzbIeqAUNXnEobtc8fG5YcBT43XDjC1BUEZ92Rcobz+nIcKebetgNlTqQvoT+/eEe11rfS393TF1d3bD7sJpwOExzczNKKSnrtwIjhPPNR7G5O9BaEwqFKM8vwBHPC9hrXoMv1/aNNZ+2a/zaFSlvPBmoAZg86HYt0DR0I6XUbsB9wOFa6/bohJfctNa4XC6CwaD0m1uB1kz6yzXkvvFwYuPItMNF90DdYYmNQ6Sc8ST0D4DpSqlpQCNwInDy4A2UUlOA5cBpWuvPoh5lkurs7KSnpyd+lYRiu+T+7U/kvvEwvUdcQMvsCyguLo7fWPMtKJD6BBEDYyZ0rbWhlLoQeAnIAJZqrdcppc7rf3wx8CugBLin/4KgobWui13Yied2u9m8ebMsVGER2av/RsETN+OrO5KWwy9iUlERxWVlMvGVSClK68R0ZdfV1elVq1YlpO3tFQgE2LRpE9nZ2VIJagH2Lz+m5JZjMWp24quLHqCosjp+y8cJEWVKqdUjnTDLVbxtFAgEaGxsJCsrS5K5Bdg6mii+40zMvGLqz11I+eRvMGnSpESHJURMSELfBsFgkMbGRmw2W/wWOhATpvweSu44E+V303DZo1TuPFO6yERKk4Q+TsFgkIaGBmw2m8zRYgVmmKLFF5BZv56WC5ZQsffBMh2DSHmS0MchFAoNnJlLMreGgsdvInvNy7SffCOlh58m36hEWpCEPoZIMgckmVtEzmsPkvfSEtwHn03haVfLtQ6RNiShjyKSzLXW8VtPUmyXrI//QeFD1xKYeTDOSxdjk2Qu0ohMPDICwzBobGzENE1J5hZhq19P0aKfE679NlnXPY1NullEmpGEPgzDMGhqakJrLRfSLMJsb6bk9jNQ2blk3vJXVG5BokMSIu6ky2WIyPJx4XBYzswtwvD0Ur7wZ2S6O1B/eBPKJ4/9JCFSkJyhDxKZOTEUCkkyt4iAz0fx/ZeT/cUa1JUPwY4pPeOEEKOShN4vHA7T1NREMBiUbhaL8Pl8FL94F3mrXoSf/Ra+f1yiQxIioaTLha/PzIPBIDk5snJMstNa4/V6KV2zkkkv3AWzz4Gf/m+iwxIi4dI+oZumSXNzM4FAQJJ5EtNaEwwGMQwDgNLmTyi8/39h5kF9c4vLRFtCpHdCN02TlpYW/H6/LFCRhMLhMMFgEK01SimcTif5+flkdzSQeefZUPlNWPAU2KXgSwhI44QeSeY+ny+tkrmtq438Z36PzdeT6FC2ojVobWKafVM6K6Ww2zPJyMgkI8P29XS3/32v74z85hchvyiBEQuRXNIyoZumSWtrK16vN62SuQr4KL7rbOybPsEoS56hfbovkwOgbDZsNhs2pUCpYRe0Jb8ErnwYqr8V1ziFSHZpl9C11rS1teF2u9NrKlXTpHDJxdi/WEPnRX/G/93ErWdpmiaBQADTNLHZbOTl5ZGXl4fD4ZCFtoXYDmn17tFa097eTm9vb3olcyB/+W/JWfUi3Sf+KuHJ3Ov1UlxcPJDEZeUgIaIjrRJ6V1cXnZ2dadXNApDzz8fJf2EhngNOxXPY3ITFERluWF5eTmFhYcLiECJVpU1hUW9vLy6Xi5ycnLQ6I8xa/w6Fy36Jf5cf0H3qzQkb3qe1xuPxUFpaKslciBhJi4Tu8/loaWkhJycHmy0t/ssAZLR8TvHCczEqptF5/mLITMzsg5Ez8+LiYoqKZFSKELGS8tktsqizw+FIq4UOlLuDkttPR9sy6Lj0QXRu4hZG9nq9TJo0iZKSkrT6diREvKV0H3pkgQq73Z5eoydCAYrv+hkZ7c1snv844bIpCQvF6/WSl5dHWVmZJHMhYixls1xksq2+4pQ0WuhAawqX/RLHZ+/Red4iQtP3TFgokaKtiooKSeZCxEFKdrlE5mdJxznN856/C+fbT9Fz7BX49v5xwuLw+/1kZWVRUVGRVtcthEiklHunaa1pbW3F7/en3TS42e8/R8Hy3+H93nG4j74kYXH4/X4yMzOpqqpKq+sWQiRaSiV0rTWbN2/G7Xan3Vhz+4bVFN17CYEdZ9F19u8TNjwxGAxis9moqqpKr+sWQiSBlEro6Vo4lOGqp/iuswkXVdJ50Z/BnphupmAwiGmaVFdXp9d1CyGSRMok9J6eHlwuF06nM60uwClvD8V3nIEyQnRc+iBmfnFC4jAMg3A4TE1NDVlZMp2tEImQEgnd4/HQ0tKC0+lMrwtwYYOie84js+VzOi68F6N6h4SEYRgGgUCAmpqatLsILUQysXz28/v9NDc3k52dnV7JXGsmPbyA7LVv0H36bwjO+H5CwgiHwwPJPN0uQguRbMaVAZVSs5VSnyqlNiilrhzmcaWUuqv/8f8opb4b/VC3FgqFaGpqSr/CISD35T+T+9qD9B5xPt79T0pIDKZp4vP5qKqqSrvrFkIkozETulIqA1gEHA7MAE5SSs0YstnhwPT+n7nAH6Mc51YMw6CxsTH9CocAx7//TsGj1+Pb4wh6f3JVQmKITINbWVlJXl5eQmIQQmxpPKe1s4ANWuuNAEqpx4BjgE8GbXMM8KDWWgPvKqUKlVJVWuvmqEe86iX04svQhkG1NlEqjbpZ+mW6viL0jf+h42d3oAFMM+4xeL1eysrKKCgoiHvbQojhjSeh1wD1g243AHuNY5saYIuErpSaS98ZPFOmTHB+EWcB4dqdCPr9E3t+CvBPm0nnMZcRtmVCKJSQGEpKSmTmRCGSzHgS+nBjAPUEtkFrfS9wL0BdXd1Wj4/LjO+Ref3y1J2EZpzyEx2AECLpjKe/ogEYvKJwLdA0gW2EEELE0HgS+gfAdKXUNKVUFnAi8NyQbZ4DTu8f7bI30B2T/nMhhBAjGrPnQmttKKUuBF4CMoClWut1Sqnz+h9fDKwEjgA2AF7grNiFLIQQYjjj6orWWq+kL2kPvm/xoN81cEF0QxNCCLEt0m/MnxBCpChJ6EIIkSIkoQshRIqQhC6EEClC9V3PTEDDSrmAryb49FJgcxTDiTWJN7Yk3tiSeGNrW+P9hta6bLgHEpbQt4dSapXWui7RcYyXxBtbEm9sSbyxFc14pctFCCFShCR0IYRIEVZN6PcmOoBtJPHGlsQbWxJvbEUtXkv2oQshhNiaVc/QhRBCDCEJXQghUoTlEvpYC1YnG6XUl0qpj5VSa5RSqxIdz1BKqaVKqTal1NpB9xUrpV5WSv1f/79JszTRCPFer5Rq7D/Ga5RSRyQyxsGUUpOVUq8rpdYrpdYppS7uvz8pj/Eo8SbdMVZKZSul3ldKfdQf6w399yfrsR0p3qgdW0v1ofcvWP0ZcAh9i2p8AJyktf5k1CcmkFLqS6BOa52UhQ5KqR8AbvrWhN21/77fAR1a69/0f2gWaa3nJzLOiBHivR5wa61/n8jYhqOUqgKqtNYfKqXygdXAj4EzScJjPEq8J5Bkx1gppYBcrbVbKWUH3gIuBo4jOY/tSPHOJkrH1mpn6AMLVmutg0BkwWoxQVrrN4GOIXcfAzzQ//sD9L2hk8II8SYtrXWz1vrD/t97gfX0rbeblMd4lHiTju7j7r9p7//RJO+xHSneqLFaQh9pMepkpoG/K6VW9y+SbQUVkRWn+v8tT3A843GhUuo//V0ySfEVeyil1FTgO8B7WOAYD4kXkvAYK6UylFJrgDbgZa11Uh/bEeKFKB1bqyX0cS1GnWT21Vp/FzgcuKC/y0BE1x+BbwEzgWbgtsSGszWlVB7wNHCJ1ron0fGMZZh4k/IYa63DWuuZ9K1jPEsptWuiYxrNCPFG7dhaLaFbbjFqrXVT/79twDP0dRslu9b+vtRIn2pbguMZlda6tf+NYgJLSLJj3N9f+jTwsNZ6ef/dSXuMh4s32Y+x1roL+Ad9/dFJe2wjBscbzWNrtYQ+ngWrk4ZSKrf/whJKqVzgUGDt6M9KCs8BZ/T/fgawIoGxjCny5u13LEl0jPsvhP0ZWK+1/sOgh5LyGI8UbzIeY6VUmVKqsP/3HOBg4L8k77EdNt5oHltLjXIB6B/ScwdfL1j96wSHNCKl1DfpOyuHvvVbH0m2eJVSjwIH0DeFZytwHfAs8AQwBdgE/FRrnRQXIkeI9wD6vq5q4Evg55E+1ERTSn0f+CfwMWD23301ff3SSXeMR4n3JJLsGCuldqPvomcGfSenT2itb1RKlZCcx3akeP9ClI6t5RK6EEKI4Vmty0UIIcQIJKELIUSKkIQuhBApQhK6EEKkCEnoQgiRIiShCyFEipCELoQQKeL/Az7Ii5hcih2zAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -626,7 +627,7 @@ "source": [ "plt.fill_between(g_test.support, \n", " *np.percentile(g_test.replications, \n", - " q=(2.5, 97.5), axis=1),\n", + " q=(2.5, 97.5), axis=0),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(g_test.support, g_test.statistic, color='orangered', label='Observed')\n", "plt.legend()\n", @@ -649,7 +650,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -676,22 +677,22 @@ "FtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", - " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0.01 , 0.045, 0.103, 0.193, 0.297, 0.41 , 0.521, 0.646,\n", - " 0.775, 0.869, 0.931, 0.971, 0.997, 1. , 1. , 1. , 1. ,\n", - " 1. , 1. ]), pvalue=array([0. , 0.0409, 0.013 , 0.0082, 0.0718, 0.1941, 0.3569, 0.4831,\n", - " 0.2651, 0.0693, 0.0267, 0.0136, 0.008 , 0.002 , 0.0042, 0.0211,\n", - " 0.0604, 0.1262, 0.2283, 0. ]), replications=array([[0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0.01003009, 0.01484624, 0.015 , ..., 0.01778243, 0.0167364 ,\n", - " 0.0079096 ],\n", - " [0.05616851, 0.05408271, 0.068 , ..., 0.07217573, 0.06276151,\n", - " 0.0519774 ],\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0.016, 0.06 , 0.117, 0.205, 0.303, 0.426, 0.558, 0.701,\n", + " 0.809, 0.881, 0.941, 0.974, 0.997, 1. , 1. , 1. , 1. ,\n", + " 1. , 1. ]), pvalue=array([0. , 0.4534, 0.3764, 0.1065, 0.193 , 0.2546, 0.4801, 0.2192,\n", + " 0.0436, 0.016 , 0.0133, 0.0077, 0.0072, 0.002 , 0.0033, 0.0174,\n", + " 0.0567, 0.1236, 0.2276, 0. ]), replications=array([[0. , 0.01911469, 0.06136821, ..., 0.98591549, 0.99295775,\n", + " 1. ],\n", + " [0. , 0.017294 , 0.0671414 , ..., 0.98168871, 0.99186165,\n", + " 1. ],\n", + " [0. , 0.01306533, 0.05829146, ..., 0.99296482, 0.99798995,\n", + " 1. ],\n", " ...,\n", - " [0.98996991, 0.95015907, 0.998 , ..., 0.95711297, 0.96025105,\n", - " 0.96497175],\n", - " [0.99498495, 0.97348887, 1. , ..., 0.9832636 , 0.98221757,\n", - " 0.98418079],\n", - " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " [0. , 0.01838611, 0.06945863, ..., 0.97957099, 0.98876404,\n", + " 1. ],\n", + " [0. , 0.01799775, 0.06974128, ..., 0.95500562, 0.98312711,\n", + " 1. ],\n", + " [0. , 0.02002002, 0.06406406, ..., 0.98598599, 0.995996 ,\n", " 1. ]]))" ] }, @@ -712,7 +713,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -726,7 +727,7 @@ "source": [ "plt.fill_between(f_test.support, \n", " *np.percentile(f_test.replications, \n", - " q=(2.5, 97.5), axis=1),\n", + " q=(2.5, 97.5), axis=0),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(f_test.support, f_test.statistic, color='orangered',\n", " label='Observed')\n", @@ -750,7 +751,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -776,23 +777,23 @@ "text/plain": [ "JtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009]), statistic=array([ 1. , 1.00908174, 1.05374078, 1.14810563,\n", - " 1.27226463, 1.27420999, 1.53186275, 1.97472354,\n", - " 2.85388128, 3.86597938, 6.30252101, 12.29508197,\n", - " 26.51515152, 208.33333333]), pvalue=array([0.000e+00, 9.720e-02, 3.000e-01, 4.309e-01, 2.423e-01, 2.479e-01,\n", - " 1.459e-01, 6.450e-02, 1.790e-02, 1.160e-02, 4.300e-03, 1.500e-03,\n", - " 1.000e-03, 1.000e-04]), replications=array([[1. , 1. , 1. , ..., 1. , 1. ,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009]), statistic=array([ 1. , 1.01010101, 1.0460251 , 1.12485939,\n", + " 1.23304562, 1.17702448, 1.44675926, 1.90694127,\n", + " 2.70562771, 3.65853659, 6.57894737, 11.9047619 ,\n", + " 23.33333333, 104.16666667]), pvalue=array([0.000e+00, 1.153e-01, 2.979e-01, 4.629e-01, 2.510e-01, 3.736e-01,\n", + " 1.873e-01, 7.440e-02, 2.090e-02, 1.270e-02, 2.500e-03, 9.000e-04,\n", + " 7.000e-04, 1.000e-04]), replications=array([[1. , 1.01295642, 1.05392157, ..., 1.34796238, 4.11483254,\n", + " 1. ],\n", + " [1. , 1.01375661, 1.05622933, ..., 0. , 0. ,\n", + " 1. ],\n", + " [1. , 1.01805869, 1.0725327 , ..., 0.85416667, 1.92735043,\n", " 1. ],\n", - " [1.01425439, 1.01754386, 1.01853871, ..., 1.02073171, 1.01914414,\n", - " 1.01380898],\n", - " [0.74425287, 1.06879607, 1.06864989, ..., 1.08279431, 1.09167672,\n", - " 1.05635492],\n", " ...,\n", - " [1.15625 , 1.02112676, 2.55890411, ..., 0. , 1.86213992,\n", - " 0. ],\n", - " [2.5 , 2.68518519, 5.49411765, ..., 0. , 4.18981481,\n", - " 0. ],\n", - " [1. , 1. , 1. , ..., 1. , 1. ,\n", + " [1. , 1.02508179, 1.10458284, ..., 0. , 0. ,\n", + " 1. ],\n", + " [1. , 1.01360544, 1.06175772, ..., 0. , 0. ,\n", + " 1. ],\n", + " [1. , 1.0190583 , 0.89433294, ..., 1.38990826, 0. ,\n", " 1. ]]))" ] }, @@ -813,7 +814,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -827,7 +828,7 @@ "source": [ "plt.fill_between(j_test.support, \n", " *np.percentile(j_test.replications, \n", - " q=(2.5, 97.5), axis=1),\n", + " q=(2.5, 97.5), axis=0),\n", " color='grey', alpha=.2, label='95% CI')\n", "plt.plot(j_test.support, j_test.statistic, color='orangered',\n", " label='Observed')\n", @@ -851,7 +852,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -882,21 +883,21 @@ " 0. , 106.08611111, 106.08611111, 106.08611111,\n", " 106.08611111, 212.17222222, 212.17222222, 212.17222222,\n", " 318.25833333, 530.43055556, 636.51666667, 848.68888889,\n", - " 1060.86111111, 1273.03333333, 1273.03333333, 1273.03333333]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.3985, 0.2023, 0.0788,\n", - " 0.0232, 0.0451, 0.0097, 0.001 , 0.0029, 0.031 , 0.0352, 0.1081,\n", - " 0.2332, 0.3624, 0.1898, 0.0815]), replications=array([[ 0. , 0. , 0. , ..., 0. ,\n", - " 0. , 0. ],\n", - " [ 0. , 0. , 0. , ..., 0. ,\n", - " 0. , 0. ],\n", - " [ 0. , 0. , 0. , ..., 77.81536443,\n", - " 0. , 0. ],\n", + " 1060.86111111, 1273.03333333, 1273.03333333, 1273.03333333]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4019, 0.2029, 0.0831,\n", + " 0.0258, 0.0465, 0.0119, 0.0022, 0.0029, 0.03 , 0.035 , 0.1135,\n", + " 0.2295, 0.366 , 0.192 , 0.0864]), replications=array([[ 0. , 0. , 0. , ..., 1184.41840317,\n", + " 1263.37963005, 1263.37963005],\n", + " [ 0. , 0. , 0. , ..., 1370.56882369,\n", + " 1423.28300921, 1423.28300921],\n", + " [ 0. , 0. , 0. , ..., 1402.53431485,\n", + " 1697.80469693, 1771.62229245],\n", " ...,\n", - " [1197.29622961, 1501.02714205, 1245.41812316, ..., 1634.12265299,\n", - " 1482.57903984, 1393.33205578],\n", - " [1473.59535951, 1626.11273722, 1512.29343527, ..., 1711.93801742,\n", - " 1575.24022983, 1486.2208595 ],\n", - " [1841.99419939, 1751.19833239, 1690.21031 , ..., 1867.56874628,\n", - " 1667.90141982, 1486.2208595 ]]))" + " [ 0. , 0. , 0. , ..., 1008.49372145,\n", + " 1191.85621626, 1283.53746367],\n", + " [ 0. , 0. , 145.62569697, ..., 946.56703029,\n", + " 1092.19272726, 1237.81842423],\n", + " [ 0. , 0. , 0. , ..., 1386.73502302,\n", + " 1456.07177417, 1456.07177417]]))" ] }, "execution_count": 26, @@ -914,9 +915,17 @@ "execution_count": 27, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/IPython/core/pylabtools.py:132: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -929,10 +938,10 @@ ], "source": [ "plt.plot(k_test.support, \n", - " k_test.replications, \n", + " k_test.replications.T, \n", " color='k', alpha=.01)\n", "plt.plot(k_test.support, \n", - " k_test.replications[:,0], \n", + " k_test.replications[0], \n", " color='k', label='Simulations')\n", "plt.plot(k_test.support, k_test.statistic, color='orangered',\n", " label='Observed')\n", @@ -957,7 +966,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -988,21 +997,21 @@ " -7.29078772, -3.30243845, -5.12513538, -6.94783231,\n", " -8.77052924, -8.18621202, -10.00890895, -11.83160588,\n", " -11.8073359 , -10.70116577, -11.28365896, -10.90433326,\n", - " -10.7870093 , -10.85579328, -12.67849021, -14.50118714]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4021, 0.2052, 0.0869,\n", - " 0.0273, 0.0449, 0.0112, 0.0021, 0.0027, 0.0314, 0.0342, 0.1121,\n", - " 0.2296, 0.364 , 0.1906, 0.0819]), replications=array([[ 0. , 0. , 0. , ..., 0. ,\n", - " 0. , 0. ],\n", - " [ -1.82269693, -1.82269693, -1.82269693, ..., -1.82269693,\n", - " -1.82269693, 2.58715172],\n", - " [ -3.64539386, -3.64539386, 1.38442619, ..., -3.64539386,\n", - " 1.34537542, 0.76445479],\n", + " -10.7870093 , -10.85579328, -12.67849021, -14.50118714]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4044, 0.2031, 0.082 ,\n", + " 0.0252, 0.0439, 0.0095, 0.0018, 0.003 , 0.0297, 0.0311, 0.1075,\n", + " 0.2343, 0.368 , 0.1923, 0.0826]), replications=array([[ 0. , -1.82269693, -3.64539386, ..., -10.41220534,\n", + " -11.35903971, -12.34026217],\n", + " [ 0. , -1.82269693, -3.64539386, ..., -11.48333139,\n", + " -12.7406209 , -14.01340988],\n", + " [ 0. , 3.16139752, 1.33870059, ..., -9.26068377,\n", + " -9.43106958, -10.2142652 ],\n", " ...,\n", - " [-12.6454847 , -10.97749319, -9.06137052, ..., -9.76660799,\n", - " -11.65668151, -12.27644449],\n", - " [-12.99868847, -12.18440487, -10.31450566, ..., -9.88914623,\n", - " -12.23107585, -13.08710202],\n", - " [-14.8213854 , -13.40917683, -12.13720259, ..., -11.1724894 ,\n", - " -13.45720087, -14.42277641]]))" + " [ 0. , 2.81684923, 2.91591525, ..., -13.01696279,\n", + " -14.25036009, -13.37017019],\n", + " [ 0. , -1.82269693, 2.03555805, ..., -6.22315255,\n", + " -8.04584948, -9.22525239],\n", + " [ 0. , -1.82269693, -3.64539386, ..., -14.16457779,\n", + " -15.98727472, -17.80997165]]))" ] }, "execution_count": 29, @@ -1020,9 +1029,17 @@ "execution_count": 30, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/IPython/core/pylabtools.py:132: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1035,10 +1052,10 @@ ], "source": [ "plt.plot(l_test.support, \n", - " l_test.replications, \n", + " l_test.replications.T, \n", " color='k', alpha=.01)\n", "plt.plot(l_test.support, \n", - " l_test.replications[:,0], \n", + " l_test.replications[0], \n", " color='k', label='Simulations')\n", "plt.plot(l_test.support, l_test.statistic, color='orangered',\n", " label='Observed')\n", @@ -1104,7 +1121,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 33, @@ -1155,7 +1172,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 35, @@ -1180,7 +1197,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -1189,22 +1206,22 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 59, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1229,12 +1246,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEWCAYAAABBvWFzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3hUVfrA8e+bTkIgARJKEnpvIlU6AgoIiKAiiAVWF7GsZVexrmLbFf2toisWsIMUAcMCYkOaiPQmVUIJCTWEBEgjZc7vjzuBJDNJIGQm7f08zzzJvfecmXdGnDfnnHvOEWMMSiml1NXyKOkAlFJKlQ+aUJRSShULTShKKaWKhSYUpZRSxUITilJKqWKhCUUppVSx0ISiSpyI9BSRfS567kkiMvMq6u8SkT7FGFKJEZH6ImJExKukY1HlkyYUVSQiMkpE1otIsoicsv/+kIhIPuVbichPIpIgIokisllEbgIwxvxqjGnm3nfgNMYvROS1nOeMMa2MMStd8ForRSRNRJJyPBYX9+so5U6aUNQVE5F/AO8CbwG1gJrABKA74JNPtcXAz/ayocCjwDmXB1u6PWKMqZzjMbSkA1LqamhCUVdERKoCrwAPGWPmG2POG8tWY8wYY8wFJ3VqAA2A6caYdPvjN2PMGvv1PiISm6P8YRF5SkR22FtAn4pITRH5XkTOi8gyEQl2VjdH/f75xD9PRE6IyFkRWS0ireznxwNjgIk5Wws5n0tEfEVkiogcsz+miIhvzjhE5B/2FttxERlXxM843+cSkevs8XvmKD9cRHbYf/cQkWdE5ICIxIvINyJSLZ/XqSMii0TkjIhEichfc1ybJCLzRWSu/TPfIiLX5Km7QETiROSQiDya41pnEdkkIudE5KSIvF2Uz0GVPZpQ1JXqCvgC/7uCOvFAFDBTRG4RkZqXUedW4AagKTAU+B54DqiB9e/20fyrFuh7oAlWK2kL8DWAMWaa/fc3C2gtPA9cB7QDrgE6Ay/kuF4LqAqEAfcBU7MTXxE4fS5jzDogGeibo+ydwCz7748CtwC9gTpAAjA1n9eYDcTay90G/EtE+uW4PgyYB1SzP/9CEfEWEQ+sFud2e3z9gMdFZIC93rvAu8aYKkAj4JsifQKqzNGEoq5UDeC0MSYz+4SIrLWPi6SKSK+8FYy1YNz1wGHgP8Bxe+ugSQGv819jzEljzFHgV2C9vRV0AYgEri1K8MaYz+ytqgvAJOAae6vrcowBXjHGnDLGxAEvA3fnuJ5hv55hjFkKJAEFjQ29Z//csh+vXuZzzQZGA4hIIHCT/RzAA8DzxpjYHO/xtrwD8SISAfQAnjbGpBljtgGf5Hk/m+2t0AzgbcAPK6F2AkKMMa/YW5sHgenAqByxNxaRGsaYJHsSVBWAJhR1peKBGjm/oIwx3YwxQfZrTv9N2b/gHjHGNALqYf2V/VUBr3Myx++pTo4rX2ngIuIpIm/Yu4POYSU4sJLk5agDROc4jrafyxafM9ECKYXE+agxJijH45+X+VyzgBH27rYRwBZjTHZc9YDI7CQF7AGysMau8r6XM8aY83neT1iO45jsX4wxNi61ZuoBdXImQ6zWY/Zr3IfVstwrIhtFZEgBn4EqRzShqCv1O3ABqzukSIwxMVjdMK2LIZ5kwD/7wD62EJJP2Tux4u6P1Z1UP7tadmiFvNYxrC/TbHXt59zKGLMb68t/ELm7u8BKAoPyJCo/e0svp2NANXsLJ1tdIGe5iOxf7N1c4fZ6McChPK8RaIzJvmtvvzFmNFa34mRgvogEFMd7V6WbJhR1RYwxiVhdPR+IyG0iUtk+ENwOcPqlISLBIvKyiDS2l60B/AUojq6QPwE/ERksIt5YYxq++ZQNxEqG8VhJ6F95rp8EGhbwWrOBF0QkxP4eXgSKPMflKs3CGi/phTXOke0j4HURqQdgj9Uh+duT+lrg3yLiJyJtsVoWX+co1kFERthbo49jfXbrgA3AORF5WkQq2Vt+rUWkk/017xKREHurJtH+XFnF+N5VKaUJRV0xY8ybwN+BicAprC/ij4Gnsb6k8krHag0sw7pVeCfWl9PYYojlLPAQVv//UawWS2w+xb/C+sv+KLAbx4T2KdDS3o2z0En914BNwA7gD6xB/declLtc70vueSibr6DubKAPsNwYczrH+XeBRcBPInIe6z12yec5RmP9dzmGNS71kjHm5xzX/wfcgTWwfzcwwj6mk4V1o0Q74BBwGuvzzx6LGgjsEpEkezyjjDFpV/DeVBklusGWUiovEZkENDbG3FXSsaiyQ1soSimlioUmFKWUUsVCu7yUUkoVC22hKKWUKhZlbhnrGjVqmPr165d0GEopVaZs3rz5tDEmvzlaxaLMJZT69euzadOmkg5DKaXKFBGJLrzU1dEuL6WUUsVCE4pSSqlioQlFKaVUsShzYyjOZGRkEBsbS1pa+Vvdwc/Pj/DwcLy9vUs6FKWUKlC5SCixsbEEBgZSv359xPmW5mWSMYb4+HhiY2Np0KBBSYejlFIFclmXl4h8Zt++dGc+10VE3rNvPbpDRNoX9bXS0tKoXr16uUomACJC9erVy2XLSylV/rhyDOULrFVH8zMIayvWJsB44MOrebHylkyyldf3pZQqf1zW5WWMWS0i9QsoMgz4yr497DoRCRKR2saY466KSZVRK1fC8uWFl3v0UahRA377DX78EZ5/Hnx94fvv4fffC6+fs/yWLdYxwLx58McfBdf19c1d/tgxeOwx6/jTTyG6kCkA1avnLu/hAePGWcfvvgvx8QXXb9AgV3lTuzZZt40gy5aFx+v/wqRfAMDH0weA1IxURAQ/Lz8AzjQOI2nYIGzGRpW33iOtXWuS+vbApKZS7Z2PMRh8PH0I8rNWqD+ZdBJfLz+C/KpijGFP02ASenfBpKYSMXUGp3t1JLF9SzzjE4j4KhIMVPGtQkhACMYYos5EUa1Sdar7VyMjK4PfWweRcG1zvBPO0nDGEmJvvI6zTevhH3OCegtXYIBQ/xBCAkJIz0pnX/yfhAWGUa1SMCkZKfzSPpiEphEExJyk0aI17B/Wg/N1qhP05xHqL9sMGOpWrUsN/xokpSex9/Q+mlRrTFW/qiSkJrCoew3O1a5Gtf2xNF6+jW0je5EaFECtbVHUW7MbUi8Q7lkb3wwPks7GkZgQQzWCwMOXPxvW4fOeIXTefpCw42fI8vJgzpAuDFr1B82jjlEjIQmAQO8aeHp4cyErmdTMc1TxCSWjclX2hQfx8Y11GbTqD6olJpHm68PcoV0YuWQ9jaJPEnQu1frvGt6WMx99Sa+mLp2beHWMMS57YO21sDOfa0uAHjmOfwE65lN2PNY+FJvq1q1r8tq9e7fDuZJw4sQJM3r0aNOgQQPTvn17c91115lvv/32qp+3tLw/l7LZjMnKsn5ft86Ynj2NOXDAOp461RgwRqTgx759Vvm33rKOz5+3jv/+98Lr5i1fpcql2EaPdihrsz+yj7OqBJqNRzeaVYdXmaNDepuzDeqYL7d9aT7Y8IE5cm1DYxMxWUKu+jmPT4QHm/YftzfXfHiN2dDE36xr6m+a/beZafxeY3Mg1NtkCbnK5z3e2KyK8XnVx3i94mX2VsfMbINhkvU454PJouD689v55ir/Zjfr98Bn7HULqG8TcSj/xI3WcdNHHOvbREwWXPz8bCIO5Ufdah33ufdS/Zzl8x7nLd9rrHU8ekTu+rac9cHYEJMlYnqNxdw/FPNTA6tsk0cwc1ti0gXr314+DxuXyv/UEHMgyDoOeBbzR0j2axT8yFl+bzVMoq8Ve7xf7nLnvX3NG9/vKfL/YsAm48Lve2OMaxeHtLdQlhhjHLZ6FZHvgH8bY9bYj38BJhpjCtxkqGPHjibvTPk9e/bQokWL4gq7SIwxdOvWjXvvvZcJEyYAEB0dzaJFi/jb3/52Vc9dGt5fsTt/HjZuhPXrYcMG6+ebb8Jdd8GOHTB+PEydCh06QEYGeHmBC7v/9sTt4ffY34k9F0vsuVjOXjhLcnoyyRnJpGSkXPx9/f3rCQ0I5aUVL/HK6lfIejELD/Fg/OLxTN8yvcDX8PX0Jfm5ZDw9PHlpxUv8cnA1T3WYyZ8nz/PjkfeJTd6Jh3jiIR4InogIHngi4oHggb9XEEPqPQPAupOzuWBLpnft+wFYc+JLkjJO56rnm2Gj4bEEqiSnUyXlAiGpXjQxEXhdSCMu9QCe4kM1vwgOdO7D4prHCDh7hpt/WMtvXdtxpG4YtU6eoe+qDfb9kQVfzwCq+FjbxiekxeLj6U+AdzV297qJ32qcodaJU/RcsYbV/fsSHxpC3UNH6LhuPWJ/Bh8Pf/y8AsHA+Yw4fD0D8PH0Z/OA4eyrmkrEwUNcu/Y3fhk2nNQqVWi0axctt26xv7rg7VEJb08/jLGRlnkeH89KeHr48Nvwuzjpd4GGu3bQfOM65t4+lrMXbNywZD591q2kcnISVVOS8M3KcPrfpdGT8zC+mTz723y6RO/hxafeJqiSNzetWUrthJMQXA2pXg2/0FpUqlULn9BqeNcMIrRePfyrViHTlkmmLbPQf2M+nj54iMfF8r6evogIGVkZZJnCN7TMLl9UIrLZGNOxyE9wGUryLq9YcuxZzaX9qsuk5cuX4+PjczGZANSrV++qk0m5kJUFO3daSSP7sXu39TceQOPG0LcvRNj/ObRtC+tybKZYxFumUzJSiD0XS8zZGOvnuRjuansX9YPqs2D3Au5ffD/bHthGvaB6LNq3iGd+sb6sQwNCCfYLJsAngADvAIL9ggmvEo6/tz8eYg079m/Yn0relbAZGx7iwYSOExjSdAgB3gEE+ATg7+2f6/eMDG92Hkvi/eUH2RaTwPbYHpxJ7sxj+7fh6SF4egwGBmPL+QaMIfBCMkGp56maep6g1POcTPucoNTzXJ99Lu1hfq/fjj/b9qdyWjLLPryPqT3uZEanwTQ6fYT/fjzB4XNJ9/TCcOmLadlZL7Z2upmGp2MY9MN/WO7bna2pbehyeDsDv19T6Oc8OyuENS160uVwHH2/+5mvgq5nc0QIQ3fu5PolPxZa/71Kzdgc0YqhO0/Ra8l3vBE2lJhgX/6y7jA9Vy4utP4LIV2JCa7NX9bt47pVS3j1mrvxDg4my782Z8MacbpqMLbgYEz16nhWr45Xjer41gyhUq0QAmqHsKtRffx8vYFRAFzcqnNs30JfG8DLwwsvj8v/Ks1b3tvTG2/Kx7SAkmyhDAYeAW7C2qL0PWNM58Kes7AWysuLd7H72Lmrjj2nlnWq8NLQVgWWee+99zh06BDvvPNOsb42lNEWysKF4OcHAwdCUhJUrQo2G1SrBl26XHp06mSNH1yhTFsmhxMPE+IfQlW/quyO2837G94n5lzMxQQSn+o47rBk9BIGNx3MluNb+GzrZzzb41nCqoRxKvkUSelJhAWG4euV35b0lyc908ae4+fYFpPI9phEtkefIe5YHFXTkghOO08r3wzaVMqiiXcG9UilessmeGaPfwwYAL17w3PPwYUL1meYnypVrM/zvvvghResz/eRR2DECOjfH1JS4JdfrM+3WjXrERxc5AStyrYy3UIRkew9r2uISCzwElhp2BjzEbAUK5lEASnAOFfFUhIefvhh1qxZg4+PDxs3bizpcFzn/HnYtMlqdaSkwCuvWOdfeQVCQ62EUrmylWBatIBGja6o6yrLlsXCvQtZcXgFsediubPNnYxsNZI/4/+k1QetmDViFqPbjOZM6hm+2fUN4VXCiagaQbeIbkRUibh4HFElgrAqYRcHodvXbk/72pfuVA8NCCU0ILTgYGw2OHcOzpyxHvHxmPh44lOz+K1DX7bFJNLiw//jeHIm73S1/tpd9sUjNDx1BA9jy/95hw69NKBes6aVKMAa6H/3XSsZZyeE7OTgLDF4eMAHH1w69ve3nlspN3HlXV6jC7lugIeL+3ULa0m4SqtWrViwYMHF46lTp3L69Gk6dnTpHwQl4+RJePFF626qnF1X7dvDyy9bCSMyEmrVulTnCr/Y0jLT+HLbl/zf7/9H1JkoqvhWoV7VeiSlW3fM1A+qz+fDPqdrRFcAetTtwemJp4v2foy5lOSWLIG9e+HJJ63jCRNgxYpLScSWOzEIkBRUm8cemE4lb08+jj9OsyqVaDKmPe0igqjtPw5JT8/dSigoMXz1Ve7YHn20aO9JqRJQLmbKlwZ9+/blueee48MPP+TBBx8EICUlpYSjcoGMDLjtNmtAvW9fuP12511X9eoV6ekT0xL5cOOHvLv+XU4mn6RjnY7Mu30ew5sPx9PD82I5f29/xrYbe/lPbLNBTAxERcH+/bl/xsZat+V6eVkJ5Ycf4MknSc+0keBXhZSIphyrV4lDNl8OGT8S/QI5W6kyleuEEtYonAbN6vJd20Y0qxmI16vW1Ktrsl/3xReL9DkoVRZpQikmIsLChQt54oknePPNNwkJCSEgIIDJkyeXdGjFa+JEWLMGZs2C0QU2Qq/YBxs/4OllT5OUnsSARgOY2H0iPSJ6s3DrMV5YuPuynsP/fCK1D+3lUMsO2Ly86fTzfLovmUm1k7F4Z6RfLJfh40t8zXDia9cjvk8nln2zmQw/f7x7jSO97wT2ffAbu46dI92vN3TsTUigL+0igmgXEUS/iCDahFcl0E/HIpTKSRNKMapduzZz5swp6TBcZ/58mDLF6oYppmSyJ24PtSrXIrhSMLUq12JI0yFM7DaR1qHXsGBzLH2/WUVsQirB/t54eXogNhs1z8YRceYoEfFHqRt/lPD4Y3zUfyxRtRpy09afuX/Bm9z6+OccqRGOnMkkOLA2MfU7Elu9DkeqhxFbrQ6nqtTAeORYKOLQeeC8/eA8DaoHMLZbfdpFBHFNRBB1qvrpqgVKFUITirp8XbrAQw/BW28Vy9MdOXuE1h+2ZlLvSfyz9z8Z0WIEQ5vewoLNsfztq5XEJqRyTVgVpnnspcWaH5GoKDhwwLr7KZufHzRuTO/bmll3R51oDQ8PZEGXLtagNP2LJValVOE0oajCpaZadxxFRFiTDYvIGMP3Ud+z7cQ2nuv5HHWr1uWLYV8wsPFAMrJsLNgcy/sroqxEEl6VV4e1pk9yDNLxYevusDZtYPBga95KkybWo04d6+6mbLVq5b4ZQCnlNppQVMGMgXvusQbjIyOLNFs9IyuDOTvn8ObaN9l5aicNghrwxHVPUMm7EqNaj7EnkpW5E0nldCQ8FAi11uXq1w88PQt9LaVUydGEogp3/fVWN9MVJpPk9GQ+2fIJb6972+reCm3NV7d8xajWowBP5mw44tgiaRaCLFgAY8bAr79C585w442ueV9KqWKlCUXlLzPTupX2oYeuqFpcchzvb3if9ze+z5nUM/Ss25MPbvqAm5rcRKbNOO/aahZiLQYiAjfcYK2827KlS96WUso1NKEo544ftwa5p0yBm2667GrJ6ck0fb8piWmJDGs2jKe7P03XiK5kZNmYuzEm/0Ty1VfWsu0//2zNDH/zTZe9NaWUa2hCKUYnTpzg8ccfZ+PGjfj6+lK/fn2mTJnC+++/z/Lly639J/z8+Oabb2jQoAH169cnMDAQESE4OJivvvqKekWcEFisMjJg5Eg4evSyJijuOLmDxfsW83yv5wnwCeCdAe9wXfh1NK/RnIwsW/5dWyKQkAAPPghz50KvXtbSJiGleL8HpVS+NKEUE2MMw4cP59577704F2Xbtm3MnTuXY8eOsWPHDjw8PIiNjSUgIOBivRUrVlCjRg1eeuklXnvtNaZPL3gJdLd4+mlr8uLs2dDK+VI2xhgMBg/x4OcDPzP5t8mMu3YcdQLrMLbd2MITCcDq1dZy9cePw+uvW6+rA+9KlVmu3AK4QlmxYgXe3t65lq9v164dAQEB1K5dGw/7ra3h4eEEBwc71O/atStHjx51W7z5+uYbeOcda/LiqFFOixxOPMx1n17HV9utdacmdJxA9OPR1AmsczGRXP9/K3nm2z+oHuDD52M7sfDh7lzfPNRKJhkZ1uq4118PPj7WmmDPPafJRKkyrly2UPp80afQMkOaDuHJbk9eLD+23VjGthvL6ZTT3PbNbbnKrhy7stDn27lzJx06dHA4P3LkSHr06MGvv/5Kv379uOuuu7j22msdyv3www/ccssthb6OS+3eDX/5C3Trlu/kRZuxMXbhWPae3kugTyAAAT4B+GRVKrxFAtbExDFjrNWJx42zVtMNDHTHu1NKuVi5TCilSXh4OPv27WP58uUsX76cfv36MW/ePPr16wfA9ddfz8mTJwkNDeW1114ruUDPn4dbb4WAAKuV4uPjtNi0zdNYFb2K6UOnc2vLW/OfkJg3kYC1EOO111p3jn3zjbWwpFKq/HD1HsPF/ejQoYPDXsmlYc/1ZcuWmZ49exZa7q233jKPPPKIMcaYevXqmbi4OJOSkmJGjhxpnnjiCad1XP7+bDZjbrvNGE9PY1asyLdYdGK0CfxXoOn3ZT9zISPTzF4fbbq/8Yup9/QSc/N/fzXL95w0NpvNsWL2XvE2mzEvv2xMdLRr3odSKl+4YU95HUMpJn379uXChQu5BtU3btzIqlWrOHbM2tnYZrOxY8cOhzu5KlWqxJQpU/jqq684c+aMW+MGrO15Fy2Cf/8b+vRxWsQYwwNLHiDLZPFc13fo+59V+Y+R5LR5s7VkSlSUNcfkxRehbl3XvyellNtpQikmIkJkZCQ///wzjRo1olWrVkyaNIkdO3YwdOhQWrduTdu2bfHy8uKRRx5xqF+7dm1Gjx7N1KtYK6vI2rSBHTsubSrlxIwdM/gh6gf+1fffvPvTOVLSswpOJNlCQ61utKQkFwWvlCotXLqnvCsUtqd8eeSy93f8uHV7cCFjGSeSTtByaktahrRkXNMveXXJXqbc0Y5brg1zXuHAAfjoI5g82Vq4MeeOiEqpEuGOPeW1hVKRTZ5s3Wl14kSBxZ775TlSMlL41/VT+c9P++nVNIRh7eo4FjQGvvwS2rWDTz6xdkQETSZKVRCaUCqyt96ClSsLXe79jf5vMPe2uXyxKh1j4PVbWjt2cSUmWptujR1r7S2/fTs0a+ay0JVSpY8mlIpoxQo4fRq8vaFj/i3g5PRksmxZhAaE4pneieV7T/GPG5sSUc0/d8HVq+Gaa2DBAmvG+/LlOvCuVAWkCaWi2b0bhg6Fhx8utOiE7ybQ96u+nElKY9Ki3bQJq8rYbvUvFcg5493bW2e8K1XB6cTGiiTn5MW33y60+I0Nb+Rk8kkm//AnCSnpfDGuE16e9r9BTp2Cm2+2ZryPHQvvvacz3pWq4DShVBTGWMuq7N8Py5ZBWD53aOVw9zV38/uBeEYvWscDvRrSOqzqpYvVqkH16tYqwSNHujBwpVRZoV1exaRy5coO5yZNmkRYWBjt2rWjefPmPPjgg9hsthKIDmvBx/nzC5y8mO3vP/6dqRumkpaRxXORf1C3mj+P929qXTTG6ury8oLvvtNkopS6SBOKiz3xxBNs27aN3bt388cff7Bq1Sr3B7F6NUycCCNGFDh5EWD5oeW8s+4dDiUe4r/L93PodDKvD29NJR/7uMi8edaS9tHRbghcKVWWaEJxk/T0dNLS0pwuXe9Sx4/DHXdAo0bw+ecFzglJTk/m/kX307haY+5s8SQfrzrIiPZh9GySY8OrkBBrnkl4uBuCV0qVJeVzDKWQLh0Ahgy59Nd6nz7WwPLYsdbttLflXr6elSuLHMo777zDzJkziY6OZtCgQbRr167Iz3XFsndePHfOGjepUqXA4i8sf4FDiYdYfs9KXll0gCqVvHlhcJ593a+/3noopVQe2kJxsewur1OnTpGcnHxxN0e3ELH2Npk+Pd+dF7OtjVnLu+vf5aGODxF9rC7bYhJ5cUhLqgXYl7GPi7MWdjx3zg2BK6XKovLZQrnSFkXO8jVqXFWLJD/e3t4MHDiQ1atXMyqfnRCLVVaWNXA+eXKhRdMy07hv0X1EVI3gsU4vMfz9LY7Lq7z8srU+16hR0LJl/k+mlKqwtIXiJsYY1q5dS6NGjVz/Ynv2QOvWsHXrZRV/ddWr7D29l48Hf8zkpdHY8i6vsnevlUzGj9dkopTKl0sTiogMFJF9IhIlIs84uV5VRBaLyHYR2SUi41wZjyulpKQQHh5+8fG2feLgO++8Q7t27WjdujWZmZk89NBDrg8mMxOCg62l4wux5fgWJv82mbHtxpKZ2pZfnC2vMnEi+PvDpEmui1kpVea5rMtLRDyBqcANQCywUUQWGWN25yj2MLDbGDNUREKAfSLytTEm3VVxuUp+80smufNLOHuZ+DZtrGVQLmOV38o+lbm52c1M6jmZWz/Y4bi8yvLlsHgxvPHGZSUopVTF5coWSmcgyhhz0J4g5gDD8pQxQKBYfSuVgTNApgtjKt/eeQcefNC6u+syl4xvWr0p397xLR8sP0FCSjr/HtHm0vIqWVnwj39AvXrw2GMuDFwpVR64MqGEATE5jmPt53J6H2gBHAP+AB4zxjj8qS8i40Vkk4hsiouLc1W8ZVv25MWTJ63B+ELsjtvN6AWjiUuO4/cD8czdFMP9PRrkXl5lxgzYts2aXe/n58LglVLlgSsTirM/kfNuDzkA2AbUAdoB74uIw2QJY8w0Y0xHY0zHkJCQvJdVerq1F0nDhoVOXsy25fgWfo3+ldSMTJ7Pu7wKQHIyPP88dO5s3dmllFKFcGVCiQUichyHY7VEchoHfGssUcAhoLkLYyqfvv8ejh2DKVOgatXCywN3tb2L/X/bzzfrz3Ew7/IqYI2bHDtmrUqsOy4qpS6DKxPKRqCJiDQQER9gFLAoT5kjQD8AEakJNAMOujCm8mnmTGtJlBtvLLTogTMHiNwTCUB0fAYfrTrguLwKWK2SnTuhe3dXRKyUKodcdpeXMSZTRB4BfgQ8gc+MMbtEZIL9+kfAq8AXIvIHVhfZ08aY066KqVxKTLRaEw88UOjYic3YuH/x/Ww9vpUedXvxzIK9zpdXiYuzElQhs+uVUionl86UN8YsBZbmOfdRjt+PAYX/WV0GHD58mCFDhrBz586L5yZNmkTlypXZuXMnq1atomrVqqSlpTF69Gheeuml4nnhBQvgwnPq6KMAACAASURBVAW4665Ci07fPJ2Vh1cyfeh0vtt2jm0xiUy5o92l5VXA2gu+SxeYMwduuaV4YlRKVQg6U95N3nrrLbZt28a2bdv48ssvOXToUPE88cyZ0LRpgXvDA8ScjeGpn5+iX4N+DGpwJ2/9uM9xeRWA2rWtW4979y6e+JRSFYYmFDdLS0sDICAg4OqfLCEB1q2zWicFDJwbY3hgyQNkmSymDZnGi//b5bi8SrbQUGs+i7uX2VdKlXnlc3HIUrR8fbannnqK1157jaioKB599FFCi2PWeXCwdSeWyXs3dm4zd8zk+6jveXfgu+yJrcQve0/x/E0tci+vkpFhbRH82GOFtnaUUsoZbaEUE4e/9POcz+7yOnHiBL/88gtr164tnhcODrb2d8/HiaQTPPbDY3SP6M7drR/gpUW7aBNWlXHd6+cuOH261X129GjxxKWUqnDKZwulBJavr169OgkJCbnOnTlzhgYNGuQ6V7lyZfr06cOaNWvo1q3bFb/ORTt2wIQJMG2atbJwPh5Z+ggpGSl8evOnTP5hHwkp6XwxrtOl5VUAzp6Fl16yWmo331z0mJRSFZq2UIpJ5cqVqV27Nr/88gtgJZMffviBHj165CqXmZnJ+vXrr34Z+/h4SE2FWrXyL5ISz/aT23m5z8sknKvBnI1OllcB+Ne/rOf7z390EqNSqsjEFNL/Xtp07NjRbNq0Kde5PXv20KJFixKK6JLdu3fz8MMPX2ypPPXUU4wZM4axY8devG04PT2dfv368d577+XbTZbX1by/lIwUbDZPbv7v72TaDD8+3iv3jPjDh6FZM2si45dfFuk1lFKln4hsNsa4dIC0fHZ5lZCWLVuyYsUKh/NffPFF8b7QiRPW/vD+/vkWmfXHLG5pfgv+3v7834/7OHg6mRn3dc6dTACefRY8PeH114s3RqVUhaNdXmXRc89BkybW8vJO7Dq1izHfjuGDjR+w98S5/JdXWbfOmsD45JMQHu6GwJVS5Zm2UMqa1FSYP9+6tdnT02mRVqGt+O0vv9GuZnvunL7Z+fIqxsDf/26NwUyc6IbAlVLlXblpoZS1saDL5fC+liyB8+fzXWolOjEagG4R3Zi36QTbYhJ5cUjL3MurABw8CPv2wWuvQeXKrghdKVXBlIuE4ufnR3x8fLlLKsYY4uPj8cu5udXMmVCnjtOlUVYcWkGj9xqxeN9ijiWm8uYPe50vrwLQqBFERVmTOZVSqhiUiy6v8PBwYmNjKY+7Ofr5+RGePb5x+jQsXQqPP+7Q3ZWcnsz9i++nQXAD+jboy2Ozd+a/vMrOndCihS6vopQqVuUioXh7eztMICyX5s2DzEyn3V0vLH+BgwkHWTV2FSv3nmPZHifLqwCcOQM9esDdd8N//+umwJVSFUG5SCgVxsyZ1qz4tm1znY5LjuO/G/7L+PbjuSakK/1mrHK+vApYrZJCZtcrpVRRaEIpKw4ehLVr4Y03HGazL9y7kCyTxUOdHuLf3+9xvrxKNhEYOdJNQSulKpJyMShfISxfbiWDO+90uDR/z3waV2tMSnJY/surgNVV9u67bghWKVURaUIpK+6/H2JiICIi1+kzqWdYfmg5tzQbwfORO6lbzZ/H+zd1rL9iBXz9tTWPRSmlXEC7vMqSsDCHU4v2LSLTlklGUqf8l1ex2eAf/4C6da07xJRSygU0oZQFTz8NsbHWoHye8ZO0zDQ61O7Mks2VGH6tk+VVAGbMgK1bYdYsyDmnRSmlipF2eZUFAQHWYpBOViee0HECDzSfTWYWPNTHyZL4ycnW2l+dO1srCiullItoC6UsePFFp6cTUhOo4luFuZtiaF83iCY1Ax0L/ec/1jbB33yje50opVxKWyil3d691hiIE/ctuo92H3Yh6lQSd3SKcCxw/Di8+aa1kGT37i4OVClV0WlCKc2SkqBDB3jmGaeXR7UeRZjPYAJ8PBnS1sl6Xf/8J6SnW3NXlFLKxTShlGYLF0JKSr77vA9qNJzoI10Z0rYOAb55ei8zM62B/L/9zVoIUimlXEzHUEqzmTOhfn3o1s3h0pI/l3DoeHVSM7K4o7OT7i4vL/j+eyuxKKWUG2gLpbQ6cQJ+/hnGjAGP3P+ZUjNSGTV/FG+vm0yT0MpcGxGUu+7mzXDkiDUI7+3txqCVUhWZtlBKq7lzrcH4MWMcLv144EeSM5IJSOrEHYMici9PbwyMH2+1TLZt0zu7lFJuowmltJo5E9q3t/YtyWP+7vn4ewYRKG0Y0T7PXvAiEBlptXA0mSil3Ei7vEqjvXth0yan+55cyLzA4j8X45fVhQEtw3Nv7ZuZabVQ6ta1JjIqpZQbuTShiMhAEdknIlEi4vTeVxHpIyLbRGSXiKxyZTxlxtdfW+MmTma2Lzu4jHMXzuF1oavj3JMXXoCBAyEjw02BKqXUJS5LKCLiCUwFBgEtgdEi0jJPmSDgA+BmY0wr4HZXxVOmrFkD/ftD7doOl+bvmY+3VKZh4HX0aFzj0oXDh2HKFKhZUwfilVIlwpVjKJ2BKGPMQQARmQMMA3bnKHMn8K0x5giAMeaUC+MpO375BRISHE5nZGUQued/+GR24o5uDfDwyDFG8uyzVqvm9dfdGKhSSl3iyi6vMCAmx3Gs/VxOTYFgEVkpIptF5B5nTyQi40Vkk4hsiouLc1G4pYQxVmKoXt3h0orDKzh7IYGArO7c3jFHd9fx49ZdYY8+6rBfilJKuYsrE4qzW4xMnmMvoAMwGBgA/FNEHHaHMsZMM8Z0NMZ0DAlxsjx7eZGebt3V9dVXTi/vj4/CiyD6NbiBsKBKly4sXGglorvvdlOgSinlyJVdXrFAzj+Xw4FjTsqcNsYkA8kishq4BvjThXGVXgkJcM01UKuW08utqt5GndQwxnRukvtCZCQ0bQotWzqtp5RS7uDKFspGoImINBARH2AUsChPmf8BPUXES0T8gS7AHhfGVLrVrGl1Xd14o8OlTFsmczfGUD3An/4tQy9dSEiwtvcdPlznnSilSpTLEooxJhN4BPgRK0l8Y4zZJSITRGSCvcwe4AdgB7AB+MQYs9NVMZVq58/Dvn35Xn5g8d/4Yv+93NKuDr5eObb4XbLEmn8yYoQbglRKqfy5dKa8MWYpsDTPuY/yHL8FvOXKOMqEefPgvvtg+3Zo29bhckZqXXyyWjOqc93cFxYvtvaa79jRTYEqpZRzuvRKaTFzJjRpAm3aOFwyxnDsWDf61ulF07y7Mn75JURFOSwgqZRS7qbfQqVBTAysXGktteJkHGTW1pX8eeoUo5ztylipktMkpJRS7qYtlNJg9mzrtl8nKwvbjI0Hvx8Nfo0Y3DbPyjQvvQTBwfD4424KVCml8qctlNJg5kzo2tXpzoqrDv/O+cyT9Ay/icp5d2XcsgX++MNNQSqlVMG0hVLSduywksL77zu9/PavM8B48VTvOx0vLl5s7ZmilFKlgLZQStrMmdZ2vSNHOlwyxrA8ehHVvdrTu3H93BezVxTWwXilVClxRd9GIhJgX0VYFYesLJg1y1py3smSMgt3/UaK7TiDmwzPvStjVpbVPaYLQSqlSpECE4qIeIjInSLynYicAvYCx+17l7wlIk0Kqq8KsX8/nDvndCMtgHfWzADjwQt986yZuW6ddWdYw4ZuCFIppS5PYWMoK4BlwLPATmOMDUBEqgHXA2+ISKQxZqZrwyynmjeHkyfB07HRl5aRyYaTSwn370iTkDq5L0ZGWnue3HSTmwJVSqnCFZZQ+htjHLb/M8acARYAC0REd3MqCpvNmnNSqZLTy5+uX80FYrm91aO5LxhjJZT+/aFqVTcEqpRSl6ewMZRAEamW3wPAWcJRl2HBAmjdGo4ccXp5xuafAQ+e7JlnSfodO+DgQWsxSKWUKkUKa6FsxtrDRIC6QIL99yDgCNDApdGVZ1WqWEvOh+XdcwxizqRw8kQPXuk5jDpV8ixlHxlptWxuvtlNgSql1OUpMKEYYxoAiMhHwCL7Yo+IyCCgv+vDK8cGDLAeTszbHAvAuK6Oi0Ty7bfQo4e11L1SSpUil3vbcKfsZAJgjPke6O2akCqA3bshPt7ppSyb4b31/yEj6A1qVskzPBUVZU2C1O4upVQpdLkz5U+LyAvATKwusLsA59+IqnDjx0NyMmzd6nDp1/1xnEuF1rWC8fbMk1AiI62fmlCUUqXQ5bZQRgMhQKT9EWI/p67UwYPw229wxx1OL3+zKYZ6vrfy89hIx4v33ANz5kD9+q6NUSmliuCyWij224Qfc3EsFcOsWdbPOx3X5opPusD3u3dx73Xtcu/KmK1mzXwTkVJKlbTCZspPExGnm23Yl2H5i4g4rrmunDPGWrurd2+oW9fhcuTWoxzzep1lp5wsR790KXz8sbXsilJKlUKFtVA+AP5pTyo7gTjAD2gCVAE+A752aYTlyebN1r7xTz7pcMkYw+frN5Lu8SdDm/3Fse7cudaSK+PHuyFQpZS6coXdNrwNGCkilYGOQG0gBdhjjPnTDfGVLzNngo8P3Habw6UtRxLZk7AMfODWlrc61v3iCzh92umOjkopVRoUmFBEZBgQboyZCqwUkQ1YA/JGRCYaY+a7I8hyITPT2plxyBAICnK4PHfjEdK819ImtC2NqzV2rC/idEVipZQqLQq7y2sisCjHsQ9WS6UP8KCLYiqfli2DU6ecriycdCGTyB07SZXdjGx1u2Pd++6Dp592Q5BKKVV0hSUUH2NMTI7jNcaYeGPMESDAhXGVPzt2QI0aTlcIXrL9GGey1gBwa4s83V3JyVbLJjnZHVEqpVSRFZZQgnMeGGMeyXGo/S9XYuJEiI4GX1+HS3M2xmAqraNlSEtahLTIffHHHyE1FUaMcFOgSilVNIUllPUi8te8J0XkAWCDa0IqhzIzrZ/+/g6X9p04z+aYwyRm7XBsnYA1O75aNejVy8VBKqXU1SnstuEngIUiciewxX6uA+AL3OLKwMqVYcMgNBQ+/9zh0tyNMaR7b8Fg47aWee7+Sk+HJUvgllusfeeVUqoUK+y24VNANxHpC7Syn/7OGLPc5ZGVF8ZA165ON8O6kJlF5NZYRjQbzYT+99AmNM8c0pUrITFR1+5SSpUJl7v0ynJAk0hRiMALLzi99PPukySkZDCqcz2uqeVkSCoyEgIC4IYbXBykUkpdvctdHFIV1fLlVteVE3M3xuAbuJ4v9zxNUnpS7os2GyxcCIMG5btNsFJKlSaaUFxp3z7o1w8+/NDhUmxCCmuiTtM8LJ3NxzcT4J3nLux16+DECe3uUkqVGTrS60pffw0eHjBypMOleZusXRmnDnuRsKB/I3mXVImIgJdegsGD3RGpUkpdNZe2UERkoIjsE5EoEXmmgHKdRCRLRBwXuSqrslcW7t8fatfOdSnLZpi3KYbrGlYmPNjfMZmAlVAmTXI6mK+UUqWRyxKKiHgCU4FBQEtgtIi0zKfcZOBHV8VSIn7/HQ4dcrrUyq/74zh2No3D5g1unHGjY91Dh2DRIrhwwQ2BKqVU8XBlC6UzEGWMOWiMSQfmAMOclPsbsAA45cJY3G/GDGsio5MxkG82xVClUibb4lbSvEZzx7ozZ1pzTxIT3RCoUkoVD1cmlDAg5zpgsfZzF4lIGDAc+KigJxKR8SKySUQ2xcXFFXugxS4jA+bNg5tvhsqVc12KT7rAz7tP0rzBAdIy0xwnM4K1EOTvv1s7NCqlVBnhyoTibOMOk+d4CvC0MabAbQiNMdOMMR2NMR1DysIS7j//DPHxTrf5jdx6lIwsw3lZQ82AmnSP6O5Y38cHunRxQ6BKKVV8XJlQYoGIHMfhwLE8ZToCc0TkMHAb8IGIlP0lXWbNguBgGDAg12ljDHM2xtAmwo9fY35iePPheHrk2Tv+yy/hmWd0q1+lVJnjyoSyEWgiIg1ExAcYRe69VTDGNDDG1DfG1AfmAw8ZYxa6MCbXMwYOH4Zbb7VaGjlsOZJI1KkkmkYcIDkj2Xl318cfw08/gaen4zWllCrFXDYPxRiTKSKPYN295Ql8ZozZJSIT7NcLHDcps0RgzRqnd2jN3XgEfx9PYi+soHql6vSu3zt3gePHrbGTV191U7BKKVV8XDqx0RizFFia55zTRGKMGevKWNwmIwO8vR32PUm6kMmSHccZ2Lo6n0R9x8hWI/HyyPPxL7Q3znR2vFKqDNKlV4pTQoJ1Z9bMmQ6Xlmw/Rkp6FnXrHOB8+nnn3V2RkdC0KbR0mK6jlFKlni69UpxSU+H226FVK4dLczfF0Di0Mg9e159mNZfSt0Hf3AUSEmDFCvjHP6xuM6WUKmM0oRSnOnWsQfU89p04z9YjibwwuAW+Xr4MajLIse6SJdbOjtrdpZQqo7TLq7icPg0bNlh3eeUxd2MM3p5CndBonv/leRLTnMyAj4yEsDDo1MkNwSqlVPHThFJcZs60JiPu35/rdPaujDe0rMme+C18sOkD/Lz8ctdNSYEffrCWW/HQ/yRKqbJJv72Ky6xZcO211qB6Dtm7Mo7sGME/uv2Do38/6phQkpLg3nth9Gg3BqyUUsVLx1CKQ1QUbNwIb73lcGnuxhjqVPWjR+MaAPh7+zvWDw11ugmXUkqVJdpCKQ6zZ1s/77gj1+nsXRlv6xjB3396nKGzh2LyjrFkZFhjLzabm4JVSinX0IRytYyxurt69bI2xcohe1fGEdfWZt7uefh5+TluprVihTX28v337opYKaVcQhPK1dq+HfbudVhZOHtXxh6NaxCTvI0TSSe4tcWtjvU7d7YWhOzb1/GaUkqVIZpQrtbs2eDlBbflnvm+Juo0x86mcUenCBbsWYCvpy+DmzjZHz4oCO65BypVclPASinlGppQrobNZiWUAQOgevVcl2atjybY35t+LUJYsGcBAxoPINA3MHf9HTtgyhQ4d86NQSullGtoQrkaR45Yg+p5ursOn07mp90nGd25LttPbib2XCy3tXCydteMGTBxotPJkEopVdbobcNXo359iI11uEPrs98O4eUhjO1Wn7fW/RNvD2+GNhuau64x8O230K8fVK3qvpiVUspFtIVSVFlZViLx9LSWq7dLSE7nm00xDGsXRkigL/P3zKd/w/4E+QXlrv/HH3DwIIwY4ebAlVLKNTShFNVPP0HdurB7d67TM9dFk5Zh4689G7L1xFYOJx52vlT9t99aqwrffLObAlZKKdfSLq+iCgqCHj2gUaOLp9Iysvjy92h6Nw2hWa1AzqY14rObP+PmZk6SRmSkVb9mTTcGrZRSrqMJpai6drUeOfxv21FOJ13grz0bAlDVryrjrh3nWPfAAesOr7ffdkekSinlFtrlVRR79kB0dK5TNpth+q+HaFG7Ct0bV+fP+D95f8P7nE0761g/MtL6qXufKKXKEU0oRfHss9C9e667u1b9GUfUqST+2rMBIsLS/Ut59PtHSctMc6wfGWmtTFy/vvtiVkopF9OEcqUSEqx1t0aOzLV3ybTVB6lVxY8hbesA8Ph1j3PosUPUrJxnjCQzE2rVcpi7opRSZZ2OoVypb7+F9PRcCWHn0bP8fjCeZwc1x8fLg+T0ZAJ8AqgXVM+xvpcXLFjgxoCVUso9tIVypWbNgsaNoUOHi6em/3qQAB9PRnWuy5nUM9R/tz6fbPnEef24ODcFqpRS7qUJ5UocP24tN3/nndYcEuBYYipLdhxnVOe6VK3kzZu/vUl8SjzXhV/nWD8hwdo3fsoUNweulFKupwnlSsyday2ZkmOr3s9/OwTAuO71OX7+OO+tf48xbcfQOrS1Y30ReO01a7kVpZQqZ3QM5UrMnm3dndW8OQDn0jKYvSGGm9rUJjzYn4e/e4oMWwaTek9yXj8oyFoMUimlyiFtoVyuqChrq94crZO5G2JIupDJX3s24GDCQaZtmcZf2/+VRtUaOdZPSYE5c+D8eTcGrZRS7qMJ5XJt3w4BATBqFAAZWTY+++0QXRpUo214EC+vehkvDy9e6PWC8/o//mglow0b3Bi0Ukq5jyaUy3XrrdYdWvZ945f+cZzjZ9MY36shu07tYsb2Gfyt89+oE1jHef3ISKhWzdp7XimlyiEdQ7kcmZnW/BH7Nr3GGKatPkjDkACubxbKbfMepLJPZZ7u/rTz+hkZsHgxDBuWa6l7pZQqT1zaQhGRgSKyT0SiROQZJ9fHiMgO+2OtiFzjyniK7LnnoEsXK7EAvx+MZ9exc/y1Z0NsZBHgE8DE7hOp7l/def2VKyExUfc+UUqVay5roYiIJzAVuAGIBTaKyCJjTM4NRA4BvY0xCSIyCJgGdHFVTEXWqpW1bpeX9XFNX32QGpV9GH5tGF4enswYPgNT0Da+335rjb/ccIObAlZKKfdzZZdXZyDKGHMQQETmAMOAiwnFGLM2R/l1QLgL4ym6e++9+Ov+k+dZsS+OJ/o3Zc/pHYgI7Wq1Q+wTHR3YbLBwIQwadLHLTCmlyiNXdnmFATE5jmPt5/JzH/C9swsiMl5ENonIpjh3L12ybh2cO3fx8JNfD+Hr5cHdXevx/PLnuXn2zWTaMguuf+KELlWvlCr3XNlCcfYnu9N+IRG5Hiuh9HB23RgzDas7jI4dOxbQt1TMMjJgyBAYMAC+/ppT59OI3HqU2zuGUy3Ah1m3zmJ//H68PAr4GCMjrYH4wYPdFrZSSpUEVyaUWCAix3E4cCxvIRFpC3wCDDLGxLswniu3bBnEx8MddwAw4/doMmw2xnWvh83YCPILolNYp4KfIyYG+veHqlXdELBSSpUcV3Z5bQSaiEgDEfEBRgGLchYQkbrAt8Ddxpg/XRhL0cyaBcHBMHAgKemZzFgXzQ0tarLp1FLafdSOo+eOFv4cc+bA//7n+liVUqqEuayFYozJFJFHgB8BT+AzY8wuEZlgv/4R8CJQHfjAPqidaYzp6KqYrkhKijWYPmoU+Pgw//fDJKZkMK5HBPd8N5pKXpWoHVi74Oew2axNuHTuiVKqAnDpxEZjzFJgaZ5zH+X4/X7gflfGUGRLlkBSEtx5J1k2w6drDtEuIog/Ev5H1JkoFo1ahIcU0sDr2hX69oV//9s9MSulVAnSmfL5mTULateGXr34efcJouNTeLx/ff624g66hndlSNMhBdfPzLT2nbevTKyUUuWdJhRnsveNf/hh8PRk+q+HiKhWiQOpkRw9f5SZI2bmP+8km5cXvP22e+JVSqlSQBeHdCbHvvGboxPYHJ3AnV1CmPzbv7mh4Q30qd+n4Pq7d8Onn7olVKWUKi20heLMnj3QtCl06MAnX2+hip8Xx7K+5XTKaV7v+3rBdY8ft2bFp6dbKxQHBbknZqWUKmHaQnHm//4Ptm4l+kwKP+w6wfAOVXhvw9sMbz684HknSUnWBMb4eGtQX5OJUqoC0YSSV1aW9dPfn0/XHMLLQ7iuaQZBfkG8ev2r+dfLzLQmQG7fDt98Ax06uCdepZQqJbTLK6/evaFzZxJefYN5m2IZ1i6MQc2u4WCTg3h6eDqvY4w1gL90KXz8Mdx0k3tjVkqpUkBbKDllZUGPHtC6NV+vjyY1I4u2jY5yIfNC/skEYPJkmDYNnn0Wxo93X7xKKVWKaELJydMT3niDC/fcyxdro+nQ0MZ93w1j0spJ+deZNctKJHfeCa+95rZQlVKqtNEur2zGwOrV0L07/9t6nNNJF3hn5HU84PkdbULbOK+TlASPP251k332mbXMilJKVVCaULLt2AF9+mCmTWP6+aY0q1mZHk1qIHJj/nUqV7a2961dG3x93RaqUkqVRvondbZZs8DLizVterL/VBIpge/w6up87uo6fhw+/NBq1bRsaa1IrJRSFZwmFLBWBZ4zBwYM4MM/Eqlc+TBrjv4PcbpHGPDBB/DUU9ZeJ0oppQBNKJa1a+HIEWIGDGPtgXgyA2cR4h/C49c97rz8yy/Dhg1Qt65741RKqVJMEwpY3V2VKvHfwJYYnx3sS1zLcz2fI9A38FIZY+D11yE62hp8b9my5OJVSqlSSBNKRgbMm0fqwMHM/zMRW+AcwquEM6HjhNzlJk+GF16AmTNLJk6llCrl9C6vZcvg9GmWtO5Dim09J1N2MH3odPy8/C6VyTnX5NlnSy5WpZQqxbSFMmsWJiiIf2VFkBEwmybVmnDvNfdeur5qFYwbp3NNlFKqEBW7hWIM7NnDvh43EsNqzqRHMfX62Xh72veA37MHbrkFGjWCyEida6KUUgWo2H9ui5Cxbj0PdryHakGxXFPzGka2GmldO3HC2tfEz8/avVHnmiilVIEqdgslK4ulO09wKBU+uf1dujaujId4XNrX5PRpq8urXr2SjlQppUq9iptQEhMxzZuzZ+B91GrVjL7NQ/HwsE9k/PJL2LYNFi/WfU2UUuoyVdwur6Qk4rr15kfPXWxIGUdUwv5L1x56CDZu1H1NlFLqClTchBIezjM3P0l8vTFMGfAeTas3tTbH2rcPRKB9+5KOUCmlypSKmVDi4zmy4neW7znJfd3a8eh1D0NiIrz4IkyZUtLRKaVUmVQxE8rMmdTt243AlIm0bXDGOhcUZK3PpQlFKaWKpEImlIyZX7O9VhC7auwj4vhJeOUVa8XhevV0rolSShVRxUsoBw7gvWkjX7c+z7jQYTS+61FrOfq4uJKOTCmlyrQKd9twxtez8AYWNzNs+3i/lUhWr4aaNUs6NKWUKtMqVkIxhnOffsruujBzbRi+f+yGRYt0rolSShWDCtXllbVtO9WPRGMQOmyNsbq6Bg8u6bCUUqpccGlCEZGBIrJPRKJE5Bkn10VE3rNf3yEiLp38sf0/k8kS6HXEwDPPwAMPuPLllFKqQnFZQhERT2AqMAhoCYwWkbzbHA4Cmtgf44EPXRUPNhv1IufjaSDt9hHW7otKKaWKjStbKJ2BKGPMQWNMOjAHGJanzDDgK2NZBwSJSG1XBLP2x2UEpWYSU7safjNm6b4mSilVzFz5rRoGxOQ4jrWfFfY/2wAABohJREFUu9IyiMh4EdkkIpviinh7r2/Ljjz22kwq/bpO55oopZQLuPIuL3FyzhShDMaYacA0gI4dOzpcvxwd6lWjw3NjilJVKaXUZXBlCyUWiMhxHA4cK0IZpZRSZYArE8pGoImINBARH2AUsChPmUXAPfa7va4DzhpjjrswJqWUUi7isi4vY0ymiDwC/Ah4Ap8ZY3aJyAT79Y+ApcBNQBSQAoxzVTxKKaVcy6Uz5Y0xS7GSRs5zH+X43QAPuzIGpZRS7qH3ziqllCoWmlCUUkoVC00oSimlioUmFKWUUsVCrHHxskNE4oDoIlavAZwuxnBKi/L4vvQ9lQ36nsqGGkCAMSbElS9S5hLK1RCRTcaYjiUdR3Erj+9L31PZoO+pbHDXe9IuL6WUUsVCE4pSSqliUdESyrSSDsBFyuP70vdUNuh7Khvc8p4q1BiKUkop16loLRSllFIuoglFKaVUsagwCUVEBorIPhGJEpFnSjqenEQkQkRWiMgeEdklIo/Zz1cTkZ9FZL/9Z3COOs/a38s++f/27i7EijoO4/j3wc2XzFKDYstABRG8Su1CeyO0rMQMoQslyd6uuqqIUvamLq2IiCCFXogys0xLhDDSi7rSysqW1NQs3d4Ugoq6Ufp38f8dnT3sboJzzpzZfT5wOHN+c2b3/+yeM789M7Mz0q2F+lxJ38S8FyQp6mMkbYr6bklT25RtlKQvJW0fRpkmStos6UD8zubXPZekR+K11ytpo6Sxdcsk6VVJJyT1FmptySBpVXyPQ5JWtTjTM/Ha2ydpq6SJHZMppTTsb+TT5x8BpgOjga+BWVWPqzC+bmBOTE8AvgNmAU8Dq6O+Glgb07MiwxhgWmQbFfP2APPJV8P8ELg96g8B62J6ObCpTdkeBd4Ctsfj4ZDpdeDBmB4NTKxzLvJlt48C4+LxO8C9dcsE3AjMAXoLtZZnACYD38f9pJie1MJMi4CumF7bSZla/ubrhFv8IHcUHq8B1lQ9riHG+wFwC3AQ6I5aN3BwoPGTrzkzP55zoFBfAawvPiemu8j/CawW55gC7AQWcLah1D3TxeSVr5rqtc1FbijHY+XRBWyPlVbtMgFT6b/ybXmG4nNi3npgRasyNc1bBmzolEwjZZNX4w3T0Be1jhMfOWcDu4HLU1zBMu4vi6cNlufKmG6u91smpXQa+AO4tBUZCp4HHgf+LdTqnmk6cBJ4LTblvSxpPDXOlVL6CXgWOAb8Qr5y6kfUOFNBOzJUuX65n/yJo9/4msbRtkwjpaFogFrHHS8t6SLgPeDhlNKfQz11gFoaoj7UMi0haQlwIqX0xbkuMkCtozKFLvImiJdSSrOBv8mbUgbT8bliv8Kd5M0kVwDjJa0capEBah2V6RyUmaGSbJJ6gNPAhkZpkHG0LdNIaSh9wFWFx1OAnysay4AkXUBuJhtSSlui/Juk7pjfDZyI+mB5+mK6ud5vGUldwCXA7+UnOeM6YKmkH4C3gQWS3qTemRrfsy+ltDsebyY3mDrnuhk4mlI6mVI6BWwBrqXemRrakaHt65fYSb4EuDvFNqkhxtG2TCOloXwGzJA0TdJo8s6nbRWP6Yw44uIVYH9K6bnCrG1A4+iKVeR9K4368jhCYxowA9gTH+n/kjQvvuY9Tcs0vtZdwK7CC7F0KaU1KaUpKaWp5J/3rpTSyjpnily/AsclzYzSQuDbmuc6BsyTdGGMZSGwv+aZGtqRYQewSNKk+LS3KGotIek24AlgaUrpn8Ks6jOVvVOsU2/AYvLRU0eAnqrH0zS268kfJ/cBX8VtMXlb5k7gUNxPLizTE1kOEkdsRP0aoDfmvcjZsyGMBd4FDpOP+Jjexnw3cXanfO0zAVcDn8fv633yUTC1zgU8BRyI8bxBPlKoVpmAjeR9QKfIf2E/0K4M5H0Zh+N2X4szHSbv32isK9Z1SiafesXMzEoxUjZ5mZlZi7mhmJlZKdxQzMysFG4oZmZWCjcUMzMrhRuKWckkPSnpsarHYdZubihmZlYKNxSzEkjqiWtQfAzM/N8FzIahrqoHYFZ3kuaSTy8zm/ye2guc60kxzYYNNxSz83cDsDXFeZUkdcx54szayZu8zMrhcxjZiOeGYnb+PgGWSRonaQJwR9UDMquCN3mZnaeU0l5Jm8hnfv0R+LTiIZlVwmcbNjOzUniTl5mZlcINxczMSuGGYmZmpXBDMTOzUrihmJlZKdxQzMysFG4oZmZWiv8AYNHSBh0coPQAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1252,23 +1269,25 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 42, "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "'GtestResult' object has no attribute 'pvalues'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mripley\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg_test\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msimulations\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhull\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpvalues\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m: 'GtestResult' object has no attribute 'pvalues'" - ] + "data": { + "text/plain": [ + "array([0.000e+00, 0.000e+00, 4.764e-01, 3.136e-01, 5.690e-02, 5.910e-02,\n", + " 2.610e-02, 8.900e-03, 1.000e-04, 1.000e-04, 4.000e-04, 1.000e-04,\n", + " 2.000e-04, 2.600e-03, 1.000e-03, 4.500e-03, 1.470e-02, 1.169e-01,\n", + " 2.012e-01, 0.000e+00])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "ripley.g_test(simulations[10], hull=state).pvalues" + "ripley.g_test(simulations[10], hull=state).pvalue" ] }, { @@ -1280,17 +1299,17 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0. , 0.04, 0.25, 0.55, 0.76, 0.88, 0.93, 0.96, 0.97, 0.98, 0.98,\n", - " 0.98])" + "array([0. , 0.16, 0.6 , 0.85, 0.95, 0.97, 0.98, 0.99, 0.99, 0.99, 1. ,\n", + " 1. ])" ] }, - "execution_count": 39, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1301,17 +1320,17 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0. , 0.2 , 0.51, 0.73, 0.9 , 0.96, 0.99, 1. , 1. , 1. , 1. ,\n", + "array([0. , 0.4 , 0.79, 0.97, 1. , 1. , 1. , 1. , 1. , 1. , 1. ,\n", " 1. ])" ] }, - "execution_count": 40, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -1329,12 +1348,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEWCAYAAABBvWFzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3iUxfbA8e9JIyGhdwhdpGMoFlRQARUsFAvNLl6v+rOLeq3gFSt6saGIgl0pIoiIgCBFQZEqPYLUUAOhJqTu/P6YDWy2JcDupp3P8+yT3fed2T0TZU9m5n1nxBiDUkopdabCCjsApZRSJYMmFKWUUgGhCUUppVRAaEJRSikVEJpQlFJKBYQmFKWUUgGhCUUVKhH5SURuC9J7GxE56zTr3iQiswIdU2ERkU9FZFhhx6FKNk0o6rSIyFYROS4ix1wetX2UfVpEtjjLJInI+NxzxpgexpjPQhe51/gaOJNPhEtcXxljrgjCZ10qIg6339sxEekY6M9SKtQi8i+ilE/XGmNm+yvg7H3cAnQzxvwjIjWBniGJrujaZYyJL+wglAo07aGoYDsXmGmM+QfAGLPHGDM696SIzBORu5zPbxeRhSIyQkQOichmEbnQeXyHiOxzHR5zretS/zdvQYjI1SKyQkSOON9rqMvpBc6fh3J7C+7v5YxjiYgcdv680C2OF52xHxWRWSJS9XR+Wf7eS0RmiMj9buX/EpHrnM+bicjPIpIiIoki0tfP5/xLRDY5y0517V06e2sPOn//+0VkuIiEuZy/U0TWi8hBEZkpIvWdx8X5326f8/e0SkRanc7vQRVPmlBUsP0B3Coij4tIBxEJz6f8+cAqoArwNTAOm5TOAm4G3hORuNOIIxW4FagIXA3cKyK9nec6O39WNMbEGWN+d60oIpWBH4F3nHH9D/hRRKq4FBsI3AFUB6KAwacRY37v9TUwwCWuFkB9ZyyxwM/OMtWd5d4XkZbuby4iXYBXgL5ALWAb9vfsqg/QAWgH9ALudNbtDTwNXAdUA34FvnHWuQL7uzwb+3vuBxw4vV+BKo40oagzMcXZkzgkIlO8FTDGfAk8AFwJzAf2ich//LznFmPMJ8aYHGA8UBf4rzEmwxgzC8jEJpdTYoyZZ4xZbYxxGGNWYb8ELylg9auBjcaYL4wx2caYb4ANwLUuZT4xxvxtjDkOTAAS/LxfbZffW+4jtgDvNRlIyO0RADcB3xljMoBrgK3O3122MWY5MAm4wcvn3wSMNcYsd9Z9CugoIg1cyrxmjEkxxmwH3uJkIvs38IoxZr0xJht42SWmLKAc0AwQZ5ndfn4PqoTRhKLORG9jTEXno7evQs4J7m7Yv1rvAf4rIlf6KL7X5flxZ333Y6fcQxGR80Vkrogki8hhZxwFHZaqjf0r3tU2oI7L6z0uz9PyiXGXy+8t95Ga33sZY45ie0r9nef6A185n9cHzndNUtjEUTO/9hhjjmF7Eq7t2eHW1twhsfrA2y6fkQIIUMcY8wvwHjAS2Csio0WkvJ/fgyphNKGokDHGZBljJmKHtAIxtp4KlHV57e3LM9fXwFSgrjGmAjAK+0UIkN+S27uwX6Su6gE7Cx5qwHwDDHBeFRYDzHUe3wHMd0tSccaYe728R572OHtHVcjbnrouz+s56+R+zr/dPifGGLMIwBjzjjGmPdASO/T1+Bm3WBUbmlBUUDknt68WkXIiEiYiPbBfNosD8PYrgetEpKzY+00G+SlbDkgxxqSLyHnYeYpcyYADaOSj7nTgbBEZKCIRItIPaAFMO/MmnLLp2GTwX2C8McbhPD7NGeMtIhLpfJwrIs29vMfXwB0ikiAiZbDDVouNMVtdyjwuIpVEpC7wEHb4EWwifip3bkZEKojIjc7n5zp7gpHYZJ8O5ASy8apo04Sigu0IdhJ3O3AIeB241xjj9WqsUzQCO6eyF/iMk8M/3tyHHWo7CjyPnZsAwBiTBrwELHQO5VzgWtEYcwA7R/EYdmjoCeAaY8z+04y7tnjeh3J9QSo65zy+A7phE0Pu8aPYSfH+2N7EHuA1oIyX95gDPIedY9kNNObkMFqu74Fl2KT9IzDGWXey833HicgRYA3Qw1mnPPARcBA7THYAeKMg7VIlg+gGW0opVyJigCbGmE2FHYsqXrSHopRSKiA0oSillAoIHfJSSikVENpDUUopFRDFbnHIqlWrmgYNGhR2GEopVawsW7ZsvzGmWjA/o9gllAYNGrB06dLCDkMppYoVEXFf7SHgdMhLKaVUQGhCUUopFRCaUJRSSgVEsZtD8SYrK4ukpCTS09MLO5SAi46OJj4+nsjIyMIORSml/CoRCSUpKYly5crRoEEDRCT/CsWEMYYDBw6QlJREw4YNCzscpZTyK2hDXiIy1rkV6Bof50VE3nFuQ7pKRNqd7melp6dTpUqVEpVMAESEKlWqlMiel1Kq5AnmHMqnQHc/53sATZyPu4EPzuTDSloyyVVS26WUKnmCNuRljFngtqWou17A58au/fKHiFQUkVq6ZajKwxgQgUOH4H//y798165wySUny/fuDe3awY4d8NFH+dd3L3/LLdCkCaxbB+Pct133wr38ffdBzZpkL/qdjO9/ICM7h/QsB+lZzp/ZOWRmO05s8bXy2gGkVa5GzQ1/0WjxfP7sdxfZ0WWpt3wR8avzv/9qcd9BZEVHU3f5QuqsWcavN9+NMYYmi+ZQ859EIsOiAch0HMcYB2XC7c7D6TnHyCaHn/sPxOCg5e8Lqbx3D3N79cQYBx3mzqX63mTKRdpNLo9kJSPIidcpGbs4FhPBrGu64jCGjgt+JyIzk3ldO2KMoeusX6l2LIfKZeymkPvStxAp0VQqUwuAXWmJHKgUx+wu54ExXDH7D47FRvNbx9aAodcPv1LJEUuVMvHgyGHfob+o5IijkilHWEYaR478w+HyZRl5h/0b9tFRUzkeXYb3b7sCceTwzLtTqJwRQUxEeYxxcDhzLzER5SgTHkeOyeJI5n521K7Eu7d2JcyRw3PvTmNbnSp8cv2FlE1L5+lRM6hoYol2lj+cuY+4iEpEhZcly5HO0awDrG1ck0+u70hsWgbPfDiT5c3r8m33tlRLOcoTY+ZQLrxinvLlI6sSEVaGjJxUUrMP8UebBnnK/9zxbGZd3ILG25K5d/xv5NRuwdHR39D57KDem3hmjDFBewANgDU+zk0DLnZ5PQfo4KPs3cBSYGm9evWMu3Xr1nkcC7WwsDBzzjnnnHhs2bIlYO9dFNoXchkZxpx7rjHDhtnX27YZI5L/w738mDH29e+/F6y+e/mffrKvJ00yRsQ4/DxyRMzbTz5nrh/zmRkyaJDJETHX3H+nqfX8/WbwlReYHDA5iPOB19ft/l3TRDwfbx7oUcHkgKkxuKoJH1LVvNQpukD1qz6OYSjmxU6YjDD7nKGYj9t6L+/62r381gonX08/K//67uUXxZ98vbJG/vXXV8GEP2fLb66ISax8sv6xCIwD+zA+HllysvzxcMz+aPs84rmTdf093MtvrGRf1324YPU3VsIwRE6UXxhvX58/qGD13cuPa2Ff39zbvj4aGWVe/Wn9af+TApaaIH7fG2OCuziks4cyzRjjsd2riPwIvGKcGy2JyBzgCWPMMn/v2aFDB+N+p/z69etp3tzbxnShExcXx7Fjx4Ly3kWhfUG1dy/MmAE//QRhYfC1c9+of/8bLr7Y/tUfYFk5Dg4fz+JQWhaH0jJJOrSftcnr2HlkN3uO7eVg+kGOZhzjWOZRUrNSOZ59jIycVMpl3EaUaURa2B8ciHqXmhnDiTS1ORzxHYcix+b7uSO7zqdV9eYs2Pkt49ePZubNv1AzriKfrBzLtI3TCJdwwsPCCZOwE8/DJfzE87e7v02ZiDJM2TCFxUmLeaXbKwCMWzOOtfvWnigfJmEn6zrfLzoimns63APAnM1zOJh+kBta3ADArH9msT9t/4nPDZMwj0e5MuXoXL8zAMt3LydMwkiomQBZWazesADH/mSy6tYhLDaWsombKT//D1Ju64eULUvFb6dReeI0Yo6kQUoKjgP7CTvq+e9lx99LMdWrUeGVEcR98hV7/l5OWFg4sR+OJXrFaqKq1YQqVTgWF0VE1epE16iDqVSJo3FRmEoVkUqVEOfOziKS53lEWARR4VEYY8jIySAiLIKIsAiMMWQ7sk+UA/LU8/a6OBKRZcaYDkH9jEJMKB8C84wx3zhfJwKXmnyGvDShlAA5ObB4sU0gP/0Ey5x/Q9SoAX36wAcFn05zTwyH0rI4dDyLvUcPkXR4D7uP7WZf6l72p+3jUEYyMY5zcaQ35kDm3yRHvUyVrAeJdrQhNWwh+8u8kue9hTAipCxRYbGUCS9LTEQcfZs8T0KNDiRnrGfBzvHc3+EJmlZtwI5j61m7fznly5SjXFQ54qLiKOf2vGxkWcKkCN/6lZVlf0ZGwv798PvvcOGFUKUK/PknfPopHDgAKSknHwcOwNGjJ9/jjz/g/PNh7FgYNAi2boX69e3w4SefQOXKJx9Vqng+b9MGoqIKo/UlXigSSmFeNjwVuF9ExgHnA4fzSyYF8cIPa1m368gZB+eqRe3yDLm2pd8yx48fJyEhAYCGDRsyefLkgMZQIvzyC4weDbNmwcGDtjfSsSMMGwY9ekBCgj3mZm7iPuas30vysSMcSssgNSOSlNRUth2fjiOzMWXMWWTJHg5EvkmOHCJHDmHkuNcQutSoRec6l0B4DDN3nM/1TRPoULsDDmlC0tHzaVC5No0q1aFKbGXKhJfx8xdpAx47sfMt1KvSnovqtw/EbykwsrLgn3+genX7Rb1zJ0yYkDchuD8/ehS++Qb694c1a6BnT/vf7LLLYNs2mDjx5Jd/rVrQsqVnYmjUyH5+//5w/fVQvrx9/a9/2Ycq0YKWUETkG+BSoKqIJAFDgEgAY8woYDpwFbAJSAPuCFYsoRATE8PKlSsLO4yiZft2+5fpfffZL6DERJg3D3r1sgnk8suhUiWf1Y9n5nDvxHFMSHyXjLDVOCSNRjE3cEn1J2hUtQy///0uV539MP2a9cIhtXlnRRVqxDWnTrlaxFeoRb2KtakVV5MacTWoGVeTamWrERl+8gbRIXR2+bRqwNlB+1WclqwsyM6GmBg4fhxmz/aeCFx7DA8+CI88Art2QfPmMGYM3HmnTSiPPmoTdqVKJ5OAe2Jo6fzDqV072yvJ7RnfeKN9FFTZsoH/fagir9htsKVDXkXY3r0wcyacfTZccAGsWgVt28Lkyfav3cxMiIjw2gtxZYzh02U/MnjGUFJylhETXoFbEwZSv0JdLoi/gMsaXgbAziM7qRZbjajwYjJEkph4MgF4SwoHDtgr1J591k4zR0XBk0/aHtz+/VDN5eqesDDvQ0fXX28TdkYGfPed/e/QsKFNTqmptseQz+9flUwlfchLFXe+5kIeeMB+kbVubb8Ic3sh+YyNG2OYvvEnHp7+PJsOLyOSyvxf2xd4tfujxEXFeZSvU75OoFvkX3a25/yB+/NateC552z5yy6Ds846ebnyuefmnW8Azx5D7hCbCLz8Mpx3nn1dqRIsWXIyceSXGMqUgQEDTr6OjISKFQPze1DKB00o6tTt3g2DB9sk4j4XctVVcM45tpyI3yEtd68sGMEz8x4j3FGNC6s9wcRbnqF2hfJBaoSLrCw7ebxpk00KN91kjz/1FOzZYyeTAdq3t70ub3J7DBdddPJY5842weT6/HM7fOXas/CXGB5//OTz8HDoENQ/LpU6Y5pQAiRYw11FTmYmXHed/WK98UabQPKZC/Elx5HD+LXjqV2uNllpzflmXl1q5jzMaz3+j1suaBz4SzR37LCTzRs32uSxcaN9bN1qe1tgx/4HDrTJMDIyb6/q0UdtD8Pb1UneEsMLL+R93bt3YNujVBGjCUWdml9+sZO148fDDTec0Vs5jINnfnmWWFpwbPe9tKxdk8n9X+Ss6p7DWwWS29OoX98mgqlT7XDTlCn2L/xhw+xVZgDlytk72tu3t1ckNWlih6eaNDn5fv/9b973v+2204tLqVJCE4o6Nd27w/r1duL9FB3POs7YFWP57K/PmH/7fDYnZ1I76xWS9pfl350b8dgVZ1MmItz/m7gOT+X2MHKf5/Y0Vq60w25HjtirnQ4dsj2JBx6AW2+1iaN69ZPzFUqpgNCEogpm9Wp7FVe3bqecTI5lHmPU0lG8segN9qbu5aK6F/H23CWMnZ9KxbJV+GpQAhc3qZr/G337re1N5A5PAcTF5e1pnHUW1HFO1t98s33kauVxf61SKoA0oaiCee45WLrU9gaiowtU5VD6Id5d/C5vLX6LlOMpdGvUjVHtv+DbReUY9csBLm9Rg9eub0PlWB9Xf2Vm2l5Fhw72prhWrexltE2anByi0p6GUkWGJhRVMF9+aYeUCpBMklOTGfHHCEYuGcmRjCNce/a1PNPpGY4cacCTk1aRlnmQl/u0ZsB5df1PvIeH25sja9a0r5s1g5deCkx7lFIBpwlF+Tdtmr2fIi6uwENGN0y8gV+3/coNLW7g6U5P07Rya16avo4v/1hKy9rlebt/W/8T7/Pm2WG12rXhhx/szZBKqSJPb5kNoD179tC/f38aN25MixYtuOqqq/j777958MEHadWqFa1bt+bcc89ly5YtADRo0IDWrVvTpk0bLrnkErZt21bILXDzyy/2rmv3q53c7DyykwemP8CBtAMAvHnFm6z7v3VMuHECUY5GXPveb3z5x3bu7tyI7+670HcyMQbeeMPuafL00/aYJhOlig391xogxhj69OnDbbfdxjjnRkwrV65k/Pjx7Nq1i1WrVhEWFkZSUhKxsbEn6s2dO5eqVasyZMgQhg0bxkcF2QQqFJKS7CR306Yn7/x2k+PIITwsnMMZh/l4xcdc3vhyejbtaRdbdBg+/nUzr89IpGLZSL4cdL7/ifejR+3qtBMn2suR3303SA1TSgWL9lACZO7cuURGRnLPPfecOJaQkEBsbCy1atUizHnTW3x8PJW83ATYsWNHdu7cGbJ4/crMtDctHj9u14OKy9ujSDmeQr9v+3HLZLtPSYtqLdj16C56Nu0JwL4j6dz2yZ8M+3E9lzStxoyHO/tPJomJdsnzSZNg+HC7Km65ckFrnlIqOEpkD+XSTy/Nt8w1Z1/D4AsHnyh/e8Lt3J5wO/vT9nPDhLw37M27fV6+77dmzRrat/dcvrxv375cfPHF/Prrr3Tt2pWbb76Ztm3bepSbMWMGvYvKndSPPWb3tZg40U6Eu3l4xsNMXj+ZJy56wu7SJkKlGJskZ6/byxOTVpGWmc1LfVox8Lx6/ifeJ0+2NwxGR9vVdC+7LFitUkoFmfZQgiw+Pp7ExEReeeUVwsLC6Nq1K3PmzDlx/rLLLqN69erMnj2bgQMHFmKkTl99Be+9Z5cZ8XIn/Nwtc/li1Rc8cdETDOsy7ESyOJ6Zw7NTVnPX50upWT6aaQ9czE3n1/edTHJy7FpZ111nl0hftkyTiVLFXbD3GA70o3379h57JReFPddnz55tOnXqlG+54cOHm/vvv98YY0z9+vVNcnKySUtLM3379jWPPPKI1zoha9+qVcbExBjTqZMxmZkepzOyM0yz95qZhm81NGmZaSeOr9152HR9c56p/+Q0M2zaWpOelZ3/Z332md0L/N//NiY9PZCtUEp5QQj2lNceSoB06dKFjIyMPJPqS5YsYf78+ezatQsAh8PBqlWrqF+/fp66MTExvPXWW3z++eekpKSENO4TDh+2vYUKFew6XZGRHkXeWPQGG/Zv4L2r3iMmMubExHvvkQs5cjyLLwadxzNXt/C/fEp6uv158812teJRo+xS60qpYk8TSoCICJMnT+bnn3+mcePGtGzZkqFDh7Jq1SquvfZaWrVqRZs2bYiIiOD+++/3qF+rVi0GDBjAyJEjCyF6bALp1MlOiLsuue60+eBmXlzwItc3v56rmlyVZ+K989l24r1Tk2pe3tjFpEn2/pIdO+zKvN27B6kxSqnCoDs2FgNBb19Ojr0r3QdjDNd8cw0Lti1g/f+t52hqeW76eDFpmdk8d02L/CfecyUm2nmT0aOhagHW7lJKBUwodmzUHkpp98svkJAAzpstvZm9eTbTN07nhUtfoHrZ2jwyfiXhYZL/xDvY3siwYfamxaZN7WXImkyUKpFK5GXD6hSEh9sv+Gq+h6u6NurK19d9zY0tb+SdOZvYsOcoH93agbOq53OvyNy50K+fnTcZMAAaNw5w8EqpokR7KKVV7lDnJZfYXkqc9+VQjmcdJ0zCGNB6ABt2p/L+3E30aVuHy1vU8P/eb7xhl7qvWtVuyKXJRKkSTxNKafXwwzB0qP3y9zFktWrvKuq/VZ8F2xaQme1g8MS/qBQbxZBrW/h+36NHba/k8cftVWOLF3u9OVIpVfJoQimNvvoK3nnHfvn7mf+IiYihc/3OtKreivfm2qGul/u0pmJZH/uXuC6h8vrruoSKUqWMzqGUNmvWwN1320uEX33Vb9EmVZrwbd9vWbPzcP5DXblLqJQpAz//DF26BCF4pVRRpj2UAInzMgcxdOhQ6tSpQ0JCAs2aNePee+/F4XAUQnROuTcvli/v8+ZFsBtk3fn9new6uqtgQ13Z2fDCC3YJleXLNZkoVUppQgmyRx55hJUrV7Ju3TpWr17N/PnzCycQY+COO2DzZp83L+Z6YvYTfLHqCw6lH/I/1LV/vx02i4iA6dNhwQKoWzfIDVFKFVWaUEIkMzOT9PR0r0vXh8Tw4XZYavhwO9zlw4JtC/h05acM7jgYR2Yd30Ndx4/b+ZJ777Wva9fWJVSUKuVK5hzKpZfmX+aaa2Dw4JPlb7/dPvbv91xld9680w5lxIgRfPnll2zbto0ePXqQkJBw2u912ubOtXeo9+1rr+7yITMnk3t/vJf6Ferz5EXP0P/D5b6HumJi4MknoV27IAaulCpOtIcSZLlDXvv27SM1NfXEbo4hYww88ohdQ+vjj/1e1TXi9xGsS17He1e9x9jfdnkf6nI4YN06+/zuu6FDUFdyUEoVIyWzh3KqPQrX8lWrnlGPxJfIyEi6d+/OggUL6N+/f8Df3ycRu6rvsWN+L+HdemgrL8x/gd7NetMgthMPz13ofajrq6/s1VwLF0LHjkEOXilVnGgPJUSMMSxatIjGobxj/Icf7MKPtWpBkyZ+iz7404OICMO7jfB9VVdaGjz9NLRvb+dPlFLKRVATioh0F5FEEdkkIv/xcr6CiPwgIn+JyFoRuSOY8QRTWloa8fHxJx7/+9//ADuHkpCQQKtWrcjOzua+++4LTUCLF0PPnnZl33x8v+F7fvj7B4ZeMpSpyzN9X9U1YgQkJcGbb9rl55VSykXQhrxEJBwYCVwOJAFLRGSqMWadS7H/A9YZY64VkWpAooh8ZYzJDFZcweLr/pKhQ4eGNpBc558P338PPXrkW3RTyiba1mxLt3p3cOMHf3of6tqzB155Bfr0gc6dgxS0Uqo4C+afmecBm4wxm50JYhzQy62MAcqJXf88DkgBsoMYU8l3+LC9Gx5sD8XHzYuuHrvwMX69/XeemrTO91Vdzz8PGRnw2msBDlgpVVIEM6HUAXa4vE5yHnP1HtAc2AWsBh4yxnj8qS8id4vIUhFZmpycHKx4iz9j7KXPF10EBdhKeF3yOmb9MwuA0Qu2+R7qWrMGxoyB//u/fOdilFKlVzATirfrU923h7wSWAnUBhKA90SkvEclY0YbYzoYYzpU87NvR6n3+uswZQoMGQKVK+db/NXfXmXgpIEs2baTkf7W6ho82O41//zzQQhaKVVSBPOy4STAdR2OeGxPxNUdwKvG7kO8SUS2AM2AP4MYV8n0yy/2Cqwbb7T3nRTA6GtHs2rPWp779h/fQ10zZsDMmfC//xUoSSmlSq9g9lCWAE1EpKGIRAH9galuZbYDXQFEpAbQFNgcxJhKpsxMuOkme/PimDF+b14EOJx+mNTMVKIjolm4vpz/ZenbtYNnnrHDXUop5UfQeijGmGwRuR+YCYQDY40xa0XkHuf5UcCLwKcisho7RPakMWZ/sGIqsX7+2V6F9dFHBdp/5LFZjzFv6zwm9F7of6gLoHp1uye8UkrlI6h3yhtjpgPT3Y6Ncnm+C7gimDGEytatW7nmmmtYk3uFFfaS4bi4ONasWcP8+fOpUKEC6enpDBgwgCFDhgTuwydOtHMcV+T/q1y4fSFjVozh0QsG8/R3ib6Huo4ehYED4b//hbZtAxerUqrE0rvTQmT48OGsXLmSlStX8tlnn7Fly5bAvHFmpp2I790bonzspOiUlZPFPT/eQ93ydalmBvof6vr7b1ixwu51opRSBVAy1/IqwtLT0wGIjY0NzBv+/LO996Rv33yLvr34bdbsW8M7l3/F29N20zuhtu+hrvbt7d4p+SQppZTKVTITShFavj7X448/zrBhw9i0aRMPPvgg1atXP+P3BOwX/9tvQ7dufovtOLyDofOGcnWTa5i+pC6VYjMY2rOl98IzZthdFzWZKKVOgQ55BYj4uLIq93jukNeePXuYM2cOixYtCswH16wJDz6Y75f/QzMewmEctC33COt3H/E91LVkiV2uZcSIwMSnlCo1SmYPpRCWr69SpQoHDx7McywlJYWGDRvmORYXF8ell17Kb7/9xoUXXnjKn5PHkiWwfj306+d3t8Rpf09j8obJPHzuEL75Ld33UJcx8Nhj9squ3J0YlVKqgLSHEiBxcXHUqlWLOXPmADaZzJgxg4svvjhPuezsbBYvXhyYZey//NL2Tvzcd5KZk8kDPz1A86otWPd3ZyrFRvke6po8GX791V7ZVd5jwQKllPJLE0oAff755wwbNoyEhAS6dOnCkCFDTiSOxx9/nISEBNq0aUPr1q257rrrzvwDR4yA5cv9DndFhUfxwdUfcHmt50ncc9z3UFdmpt3St0ULGDTozGNTSpU6JXPIq5C0aNGCuXPnehz/9NNPg/OBYWHQqJHP0w7jIEzCqFu2Iz8uXUjvhFq+r+p6/33YtMnu7hih/1sopU6dfnMUV4MH2y/+V1/1etoYw5VfXsml9bvw24qL/Q91paTYYa4rroDu3YMYtFKqJLiOEQMAACAASURBVNMhr+IoMxM+/tgut+JDenY68eXjWbXd4f+qLoAXX7T3srzxRpACVkqVBiUmodgFi0ser+0qwM2MMZExDD73LZata+v/BsatW+G99+y8SevWgQlaKVUqlYghr+joaA4cOECVKlV83g9SHBljOHDgANHR0XlPTJwIFSv6vJnxzUVv0rneZTw/KZWKZf0MdQHUrw9ffaXb+iqlzliJSCjx8fEkJSVREndzjI6OJj4+/uSBfNbu+n3H7wz+eTCX1LqDrbuvZ/Qt7X0PdRljLzkuwLItSimVnxKRUCIjIz1uICyx/Ax3ZTuyuffHe6kRW5vtW6+id0JtrmhZ0/v7OBy2h9O3L9xzT5CDVkqVBiVmDqXU8DPc9e7id/lr71/UMvdSuWxF/0NdR4/aJe8DtUilUqrUKxE9lFLDz3BX0pEknp/3PM0rXkLK7gQ+uqWV76EusMlk8mQ77KWUUgGgPZTixM9w18MzHiYrJ5vUvbfQJ6GO76EugEmT7H4nkO92wUopVVCaUIqTpk3h6ac9hru2HtrKpPWTiI/oR7Wy9f0Pde3ZY5fpf/rp4MaqlCp1dMirODnrLHjpJY/D3677FoDjhzvx/s35DHUNGQLp6fDKK8GKUilVSmkPpbj46y+YNQtycjxOTVo3hTKOs7i+TTv/Q11r1tg77P/v/6BJkyAGq5QqjTShFBfvvWfnTrwklLuaj6ZK5mPc3dn3QpGAXf+rfHl4/vkgBamUKs00oRQX77wDv/zi9WbGn9cepmnVZrSs7WcPk5kz7eO556By5SAGqpQqrTShFBcxMdCuncfhgd/ezpxtk+h1Th3fy87k5NjeSePGdrhLKaWCQCfli4MXXrBDVY88kudwenY6v29fSba0pWdCbd/1x4618yfffut3q2CllDoTmlCKusxMeOst6NXL41R0RDStIt+DGg4aVvVxx3tODrz8Mlx8MQRil0illPJBE0pRN3s2HDoEN97ocWrd7mRW7zzMs1c3910/PBwWLIDUVL2JUSkVVDqHUtRNmGCXSbn88jyHtx/eTsLH9UgL/41rz/Ex3JWebpdWqVsXmjULQbBKqdJME0pRlpkJ33/vde2uiWsnkuVI57w67ahRPtp7/X/9C3r21PW6lFIhoUNeRZmf4a7P/xpPpKMRN3c433f988/XoS6lVMhoQinKfAx37Ti8g1X7llDZcSs9WtXyXf/++4McoFJKnRTUIS8R6S4iiSKySUT+46PMpSKyUkTWisj8YMZTrOQz3AXQpX4vKpSN9Kw7YwaMGeP1rnqllAqWoPVQRCQcGAlcDiQBS0RkqjFmnUuZisD7QHdjzHYRqR6seIodP8Ndn6wcR6SjIbece4FnvcxMeOABm4Ruuy0EgSqllBXMIa/zgE3GmM0AIjIO6AWscykzEPjOGLMdwBizL4jxFC+1atlJdS/DXWuSl1CNW+nW3Ev+ff992LQJpk+HCB3RVEqFTjCHvOoAO1xeJzmPuTobqCQi80RkmYjc6u2NRORuEVkqIkuTk5ODFG4R07YtjB7tMdw1fq1dqr574z6UjXJLGCkp8N//2iTUvXuoIlVKKSC4CcXbpUXu169GAO2Bq4ErgedE5GyPSsaMNsZ0MMZ0qFatWuAjLWo2bIBVq7xe7vvpinFEOhpw+3kdPeu9+KLd0fHNN/XKLqVUyAVzTCQJqOvyOh7Y5aXMfmNMKpAqIguAc4C/gxhX0ffqq3bv+H37PHoo55YbSub+jXRq4pZYN26EkSPhzjuhdesQBquUUlYweyhLgCYi0lBEooD+wFS3Mt8DnUQkQkTKAucD64MYU/Hw+uvw3XceySQtM5s/Ngo3tLmMyHC3/3RPPmnLv/hiCANVSqmTgtZDMcZki8j9wEwgHBhrjFkrIvc4z48yxqwXkRnAKsABfGyMWROsmIqN6tWhSxePw7dMfIgDOdXodc4DeU9s3QqTJ9u9Tmr62bFRKaWCKKiXARljpgPT3Y6Ncns9HBgezDiKlTffhBo14Oab8xxOy0pj1pbJVCx7Jec2cNsga/Jk+/P220MTo1JKeaFreRUlmZkwbJi9B8X9VFYENY5/xF0JDxEW5jbh/uCD8Mcf0CifLYCVUiqINKEUJX5uZvxx9S6yc+D6tg0964WH23W7lFKqEGlCKUp8rN216+gu7prVgQqVVnvuGz9qFDz+ODgcIQxUKaU86a3URYWftbs+WT6OdMcBrm6e4LlvfGIirF4NYfq3gVKqcGlCKSr8DHd9tmIckY76/OvCTp71RozQ3olSqkjQP2uLCh/DXbuP7mbj4aU0iu3quW98Wpr9qb0TpVQRoN9ERYGf4a4Pl3wNGG5q0y9vHWPsel8PPRS6OJVSyo9TTigiEutcml4Fip/hri//Gk+kox7/6tg574mVK+Hvv6FlyxAFqZRS/uWbUEQkTEQGisiPIrIP2ADsdm6INVxEmgQ/zBIuLs72Ttyv7jqyi3+OLKVp+SuoWcFt3/hx4+zy9NddF8JAlVLKt4L0UOYCjYGngJrGmLrGmOpAJ+AP4FURudnfG6h8dO5s73Z3G+4audgOd92a4GW4a8IE6NYNqlYNXZxKKeVHQa7y6maMyXI/aIxJASYBk0TEyz60qkC2boXoaK9rcH29agJR3oa7/vzT1hsyJCQhKqVUQRQkoZTzuPfBhTEmxVvCUQX0wgswdSrs3Ztnh0WHwxCXfgddauVQsWzengvjxtneTO/eIQ5WKaV8K0hCWYbdGEuAesBB5/OKwHbAy1ogqsCeeAJ69vTYrvfPrSkcPVqPe69pm7e8w2GHu7p3h4oVQxioUkr5l29CMcY0BBCRUcBU5wrCiEgPoFtwwysFmje3DzdP//wSJjKebs2vzHvit99g1y7o3z9EASqlVMGcymXD5+YmEwBjzE/AJYEPqRT56COYOdPjcEraEebvGU3NGhs8942fOBFiYuDaa0MUpFJKFcypJJT9IvKsiDQQkfoi8gxwIFiBlXiZmXa465tvPE6t2Hac+ONf8Eznxz3rvfyyTUJxcSEIUimlCu5UEsoAoBow2fmo5jymToefmxmn/rWLSmVj6d6isWe9cuWgk5c1vZRSqpAVeHFI52XCus5HoEyc6HXtri0Hd/Lhhuu5vvGzREW45fvXXrMJ5b77QhioUkoVTEHulB8tIq19nIsVkTtF5KbAh1aCZWbClCle1+56ff7nZMgWerTwsgDBvHmwaFFoYlRKqVNUkB7K+8BzzqSyBkgGooEmQHlgLPBV0CIsifwMd32fOIlo6jEg4SLPej/9BFl6y49SqmgqyGXDK4G+IhIHdABqAceB9caYxCDHVzL5GO7amJzE7uMruLT23YSHu3Ues7IgMtI+lFKqCCrIkFc9AGPMMWPMPGPMN8aYKZpMTpOf4a5X538O4uCBjrfkrZOeDnXrwsiRIQxUKaVOTUGu8pqS+0REJgUxltLBz3DXtI3fUVbq0rvlBXlPzJhhl2Zpogs7K6WKroIkFNeFvBoFK5BSw+GAiy/2GO5as3s7+zJWcFGdawhz34Fx/Hi7qnCXLiEMVCmlTk1BEorx8VydjmuugV9/9Rjues053PXwhbfmLZ+aahePvOEGj/W+lFKqKCnIN9Q5InIE21OJcT7H+doYY8oHLbqSZs8eKF8eypb1ODXjnynEhtWlR7Pz85748Ue7d3y/fh51lFKqKCnIVV663W+gPPUU/PwzbN8OLsNam5OPEZbak1vbV8Njq4Bx46BWLb07XilV5OkYSigNGgSXXponmYBdaqWsac/z3brmLX/kCEyfDv/+N4RrXldKFW2aUELp4ovtw4Uxhg+Xfkzz+Lae+8ZPnQoZGTrcpZQqFk5lcUh1JsaNg2XLPA4v3prEhvQRRJZf6L1OvXpwwQWe55RSqojRHkooZGbCvffanRk/+yzPqV/WH6NB1mcM7+5ljuSDD2DLFo8hMqWUKoqC+k0lIt1FJFFENonIf/yUO1dEckTkhmDGU2hyb2bs2zfPYYfDMHXlLrqe3YSzq9X1rFe3LnTuHKIglVLqzAQtoYhIODAS6AG0AAaISAsf5V4DPLcuLCl8rN01a8NG/kp/nKb19nrWGTIEfvghRAEqpdSZC2YP5TxgkzFmszEmExgH9PJS7gFgErAviLEUnty1u3r18riZ8Z1FX5MevoKLGtfIWycjA778Ev74I4SBKqXUmQnmHEodYIfL6yQgz117IlIH6AN0Ac719UYicjdwN0C9evUCHmhQ+Rjuysx28OvOaVSIjKdj3Q5565QpAxs32kUhlVKqmAhmD0W8HHNfuuUt4EljTI6/NzLGjDbGdDDGdKhWrVrAAgwJH8NdP65N5JhZQY/GfTxvZnQ47ES8lzvqlVKqqApmQkkCXGea44FdbmU6AONEZCtwA/C+iPQOYkyh5We4a+Tv47yv3bVrF8TH2xsalVKqGAnmkNcSoImINAR2Av2Bga4FjDENc5+LyKfANGPMFEoKH8NdaZnZ/LH7RypGx3NefPu8dSZOhN27oZEu7KyUKl6C1kMxxmQD92Ov3loPTDDGrBWRe0TknmB9bpFy8CA0b+4x3DX5r0RSZSXXNrnOc7hr/Hg45xxo1iyEgSql1JkL6o2NxpjpwHS3Y6N8lL09mLEUiptugoEDwS1pfLh4HEiO586M27bB77/DK6+EMEillAoMvQU7WA4ftpPrbsnkUFomy5J/olJUPB1quw13TZhgf7oNkSmlVHGgCSVYHnoI2rQBk/fCtp/W7CEmuzOPXPAf78Nd556r8ydKqWJJ1/IKlj59oH17jx7K9yt30qZST5699JK85TdtsotHvvlmCINUSqnA0YQSLL08FwXYczidudumc99FV3rvnQDceGMIglNKqcDTIa9g+Ogj2LnT4/CEZRvYF/kKO7O+9awzbpzdK6Wul0UilVKqGNCEEmirVsHdd8O3nklj9rpjXFLxE5699FHPep9+Cq++Gvz4lFIqSHTIK9DGjLF3xd98c57DW/ansirpMM9efRH1KnhZj6x9e89jSilVjGgPJZDS0+0qwX36QJUqeU6NW7qe/VFv0rh2St46xsBTT8HSpSEMVCmlAk8TSiBNmQIpKTBoUJ7Dxhg+X/ktqeFziY125K2TlAQjR8Ly5SEMVCmlAk+HvALp44+hfn3o2jXP4bW7jrAtbQ5VY+M5t7bbKv1168JeLxtsKaVUMaM9lEDZsgXmzLG9E7c94Mcv28DxsJX0a3VD3suFc296jImxD6WUKsY0oQTK2LH2Jsbbb89z2OEwfLPqO5Bsbjmnf946S5ZAq1b2yjCllCrmNKEEQk4OfPIJdO/ucR/Jkq0p7MqcS7WYOpxX57y89caNszszFrddKJVSygtNKIFw6BB06gT3eK7KP375Bo6HrWBA6755h7scDrsYZPfuULFiCINVSqng0En5QKhSBb75xuNwZraDb9dOAclmYOt+eU8uWmTvpn/99RAFqZRSwaU9lDOVkgLr1nk99dumZPbnzKd6WR/DXTEx0LNnCIJUSqng04RypsaOhZYtYfNmj1Pfr9xFxfBzeOKiwXmHu7Kz7Va/V18NcXEhDFYppYJHh7zO1K23Qo0aHnuYpGVm8/O6vdyW8CCPXdg6b53582HfPujvdtWXUkoVY9pDOVPVq8Mtt3gcnr1+HynZq7mipZcJ9/Hjbc/kqqtCEKBSSoWGJpQzMXz4yW173Xz2+zr2lXmGH7a+lfdEVhZMmmTnTvRmRqVUCaJDXqfryBEYOhRuusljD/hFm/azdGsaj174Cf/u4DYZLwKffw41a4YuVqWUCgFNKKdr3DhIS/O6EOQbsxKpVT6WYT2uJjoyPG+9iAg7Ga+UUiWMDnmdrjFj7LIp5+XtgcxN3MfCpDmUq/UZmY7UvHXS02HIELvul1JKlTCaUE7HqlXw559w1112CMvJ4TC8MXMDqdGfsfnIQqIjovPWW7oUhg2Dv/8OccBKKRV8OuR1Onzsyjhj7R7+3PcDqVGbeanrN0SFR+Wtd/HFsHs3VKoUwmCVUio0NKGcKh+7MuY4DG/MWkNqmS9pV6MdfVv29V6/evUQBaqUUqGlQ16nyseujFNW7GRlykTSzV5e7fYqYeL2q/3uO+jWTTfTUkqVWNpDOVVjxnjsypiV4+CN2cs5VmYCXRt04/LGl3vW+/prWLsWqlYNYbBKKRU6mlBO1U032R0ZXXZlnLB0B+uOfk1W5GFe6/aqZ52jR+HHH+Ff/4LwcM/zSilVAmhCOVVuOzKmZ+Xw5uzFpEZOoX/L/rSv3d6zztSpdu6lXz/Pc0opVUIEdQ5FRLqLSKKIbBKR/3g5f5OIrHI+FonIOcGM54zk5MAHH8CBA3kOf/nHNran/U54GAzrMsx73XHj7E6OHTuGIFCllCocQUsoIhIOjAR6AC2AASLSwq3YFuASY0wb4EVgdLDiOWOLFsF998G8eScOpWZk88G8f7iyYT+2PbKVxpUbe9Y7eBBmzrTLs4TpNRBKqZIrmENe5wGbjDGbAURkHNALOLEblTFmkUv5P4D4IMZzZjp1gr/+gmbNThz6dNFW9qRt56MrrqNmnI97S6ZMsQtC6nCXUqqEC+afzHWAHS6vk5zHfBkE/OTthIjcLSJLRWRpcnJyAEM8RW3a2BsagcPHsxgxfzq7ov/F5mNzfNcZN87uldKhQ4iCVEqpwhHMhCJejhmvBUUuwyaUJ72dN8aMNsZ0MMZ0qFatWgBDLKD33rNXd2Vmnjj08a+byUyvyX3tnuTKxld6r5ecDHPm2N6JePt1KKVUyRHMIa8koK7L63hgl3shEWkDfAz0MMYccD9f6IyBkSOhcuUTvZMDxzIY+9sWrm1zFiOv9XFHPNj9Tj780A6XKaVUCRfMHsoSoImINBSRKKA/MNW1gIjUA74DbjHGFM0VExctgg0b8twZP3LuRrbxChc02+2/blycrXf22UEOUimlCl/QEooxJhu4H5gJrAcmGGPWisg9InKPs9jzQBXgfRFZKSJLgxXPaRszxiYG5yZaew6n8/6fn5EavoDIqKO+6+3ZY4fKDh4MUaBKKVW4gnpjozFmOjDd7dgol+d3AXcFM4YzcuSI3f994ECbVIC35qzlQPjntKqW4HsBSLCXCj/wgF2iRVcXVkqVAnpjhD/jx9tdGe+yOW9HShofr/iQbNnHiO7DPReAdHXbbXbfk+bNQxSsUkoVLk0o/nz8cZ5dGV+buZyD4eO5pF5XujXq5r3OsWOwcKF93qRJiAJVSqnCpwnFl9Wr7a6MgwaBCJv2HePLde/hkCP8r/vr3us4HHDLLXaYa5fHBW1KKVWi6eKQvrjtyjhsxkKOhE/humZ9aVernfc6Q4bYO+Pfegtq1w5hsEopVfg0ofjy6KNw0UVQtSprdx1m0sa3CIt0MPyKV7yXHz/e7hc/aBA8+GBoY1VKqSJAE4ov9erZB/D6jFVkhK9gUNu7aVSpkWfZZcvssvYXXWRvgtS74pVSpZDOoXjz3HMwaxYAy7cfZP7fR3jt4tm8fvlLnmV374Zevexe8d99B2XKhDhYpZQqGrSH4u7YMfjsM4iMhCuu4MWffqVybDh3d2pGbBm3X1d6OvTpY29eXLjQJhWllCqlNKG4i4uDLVsgI4OFm5L5aeez1KkUTtmoqzzL3ncfLF4MkyZBQkLoY1VKqSJEE4orh8M+IiIwMTG8MXM5DaJu4vmuDRFv8yL9+0OLFnDddaGPVSmlihidQ3E1c6adiF+7lnmJyazYcZjnLu/PwDZuS6ykpNifV1wBgweHPk6llCqCNKG4GjMGsrJwND6LR6e9T3a5z+mZ4Lb/yt9/Q+PG8MUXhROjUkoVUZpQcu3bB99/D7feytQNu1h99H3KxK4nNio6b7k6deyGWZdeWihhKqVUUaVzKLm++AKys8m5406emPYmOWHJvH/NVycXgMzOtld1xcXBqFH+30sppUoh7aGA3ZXx44/hwgv5OlX4J/1z2lbvzJVnXX6yzKOPQseO9rJipZRSHjShwIldGbPvuINnZr+MQ44yuuf/Tp7/6CN49124/PIT+6IopZTKSxMKnNiVcUyds0jK+pYu9frQoU57e27BAnu/yZVXwus+VhlWSimlCSV3V8bsvv14fumbIDmM7jXcntu6Fa6/3l7VNW4cROiUk1JK+aIJZdo0SEvjizYJ7MuZzvVNb6dx5cZ2rqRnT8jKgqlToWLFwo5UKaWKNE0oAwZwfNEfPHdoFRFh0Yy89qWTG2WtXQsTJsDZZxd2lEopVeRpQhFhbHoVIo73Ynq/5VSPrX5yo6w337R3wyullMpX6Z4UeP55Mvan8G61DnRt1pLLmza1lxDv3Al33gkPPVTYESqlVLFRuhPK0aMsXbeCxEs/4ImWk+0xEXvVV06ObpSllFKnoFQPeR148VXu7HQ/Harcxc21E6BrV9iwwSYSvaJLKaVOSen91ty0iVGJmWRll+ebfm8StSPR7oOSnl7YkSmlVLFUOhPK1q2Ys89mf/cGXNDvv5xVPQ6qt4fERLtTo1JKqVNWOoe8PvkEg2FS0y0MXj0Pnn3WXiqsyUQppU5b6UsoOTlkffQRPzcKp9vR5rQb8Ynd40Qn4JVS6oyUvoQyaxaRu3cz/awcPhy/Hdq0gU8+0YSilFJnqNTNoex/522IgUeXxRBZNtZuqhUbW9hhKaVUsVe6eij79lFh1ixSo6Du4SyYPNnuIa+UUuqMBTWhiEh3EUkUkU0i8h8v50VE3nGeXyUi7YIZz7o3XiHSYah/GMI+HA0XXhjMj1NKqVIlaAlFRMKBkUAPoAUwQERauBXrATRxPu4GPghWPBhD1VHvA3Donn/BHXcE7aOUUqo0CmYP5TxgkzFmszEmExgH9HIr0wv43Fh/ABVFpFYwglk0ew5VjmWytU5lKr77fjA+QimlSrVgJpQ6wA6X10nOY6daBhG5W0SWisjS5OTk0womuml7Hn75a2Ln/a7LqiilVBAE85vV23W45jTKYIwZDYwG6NChg8f5gmhXrxLt/jPgdKoqpZQqgGD2UJKAui6v44Fdp1FGKaVUMRDMhLIEaCIiDUUkCugPTHUrMxW41Xm11wXAYWPM7iDGpJRSKkiCNuRljMkWkfuBmUA4MNYYs1ZE7nGeHwVMB64CNgFpgF56pZRSxVRQZ6eNMdOxScP12CiX5wb4v2DGoJRSKjRK153ySimlgkYTilJKqYDQhKKUUiogNKEopZQKCLHz4sWHiCQD206zelVgfwDDKSpKYru0TcWDtql4qArEGmOqBfNDil1CORMistQY06Gw4wi0ktgubVPxoG0qHkLVJh3yUkopFRCaUJRSSgVEaUsoows7gCApie3SNhUP2qbiISRtKlVzKEoppYKntPVQlFJKBYkmFKWUUgFRahKKiHQXkUQR2SQi/ynseFyJSF0RmSsi60VkrYg85DxeWUR+FpGNzp+VXOo85WxLoohc6XK8vYisdp57R0TEebyMiIx3Hl8sIg1C1LZwEVkhItNKUJsqisi3IrLB+d+sY3Fvl4g84vx/b42IfCMi0cWtTSIyVkT2icgal2MhaYOI3Ob8jI0icluQ2zTc+f/eKhGZLCIVi0ybjDEl/oFdPv8foBEQBfwFtCjsuFziqwW0cz4vB/wNtABeB/7jPP4f4DXn8xbONpQBGjrbFu489yfQEbsb5k9AD+fx+4BRzuf9gfEhatujwNfANOfrktCmz4C7nM+jgIrFuV3Ybbe3ADHO1xOA24tbm4DOQDtgjcuxoLcBqAxsdv6s5HxeKYhtugKIcD5/rSi1Kej/+IrCw/mLnOny+ingqcKOy0+83wOXA4lALeexWkCit/ixe850dJbZ4HJ8APChaxnn8wjsncAS5HbEA3OALpxMKMW9TeWxX77idrzYtgubUHY4vzwigGnOL61i1yagAXm/fIPeBtcyznMfAgOC1Sa3c32Ar4pKm0rLkFfuP5hcSc5jRY6zy9kWWAzUMM4dLJ0/qzuL+WpPHedz9+N56hhjsoHDQJVgtMHFW8ATgMPlWHFvUyMgGfjEOZT3sYjEUozbZYzZCbwBbAd2Y3dOnUUxbpOLULShML9f7sT2OPLE5xZHyNpUWhKKeDlW5K6XFpE4YBLwsDHmiL+iXo4ZP8f91QkKEbkG2GeMWVbQKl6OFak2OUVghyA+MMa0BVKxQym+FPl2OecVemGHSWoDsSJys78qXo4VqTYVQCDbUChtE5FngGzgq9xDPuIIWZtKS0JJAuq6vI4HdhVSLF6JSCQ2mXxljPnOeXiviNRynq8F7HMe99WeJOdz9+N56ohIBFABSAl8S064COgpIluBcUAXEfmS4t2m3M9MMsYsdr7+FptginO7ugFbjDHJxpgs4DvgQop3m3KFog0h/35xTpJfA9xknGNSfuIIWZtKS0JZAjQRkYYiEoWdfJpayDGd4LziYgyw3hjzP5dTU4Hcqytuw86t5B7v77xCoyHQBPjT2aU/KiIXON/zVrc6ue91A/CLy/+IAWeMecoYE2+MaYD9ff9ijLm5OLfJ2a49wA4Raeo81BVYV8zbtR24QETKOmPpCqwv5m3KFYo2zASuEJFKzt7eFc5jQSEi3YEngZ7GmDSXU4XfpkBPihXVB3AV9uqpf4BnCjset9guxnYnVwErnY+rsGOZc4CNzp+VXeo842xLIs4rNpzHOwBrnOfe4+RqCNHARGAT9oqPRiFs36WcnJQv9m0CEoClzv9eU7BXwRTrdgEvABuc8XyBvVKoWLUJ+AY7B5SF/Qt7UKjagJ3L2OR83BHkNm3Czm/kfleMKipt0qVXlFJKBURpGfJSSikVZJpQlFJKBYQmFKWUUgGhCUUppVRAaEJRSikVEJpQlAowERkqIoMLOw6lQk0TilJKqYDQhKJUAIjIM849KGYDTfOtoFQJFFHYAShV3IlIe+zyMm2x/6aWAwVdFFOpEkMTilJnrhMw2TjXeVJ+VgAAAHxJREFUVRKRIrNOnFKhpENeSgWGrmGkSj1NKEqduQVAHxGJEZFywLWFHZBShUGHvJQ6Q8aY5SIyHrvy6zbg10IOSalCoasNK6WUCggd8lJKKRUQmlCUUkoFhCYUpZRSAaEJRSmlVEBoQlFKKRUQmlCUUkoFhCYUpZRSAfH/XVTYt746lUkAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1359,12 +1378,12 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1389,12 +1408,12 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 47, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1419,12 +1438,12 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1450,9 +1469,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:analysis]", + "display_name": "Analysis", "language": "python", - "name": "conda-env-analysis-py" + "name": "ana" }, "language_info": { "codemirror_mode": { @@ -1464,7 +1483,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.6" }, "widgets": { "state": {}, From 989efc7548d2aaa8dca03228f4bb23d937b0cc66 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 8 Jun 2020 16:18:48 +0100 Subject: [PATCH 26/67] move to using "simulations" instead of "replications" --- pointpats/ripley.py | 142 ++++++++++++++++++++++---------------------- 1 file changed, 71 insertions(+), 71 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index 0428f45..b6638d2 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -406,51 +406,51 @@ def simulate(hull, intensity=None, size=None): else: # default to 100 points n_observations = 100 - n_replications = 1 - size = (n_observations, n_replications) + n_simulations = 1 + size = (n_observations, n_simulations) elif isinstance(size, tuple): if len(size) == 2 and intensity is None: - n_observations, n_replications = size + n_observations, n_simulations = size intensity = n_observations / _area(hull) elif len(size) == 2 and intensity is not None: raise ValueError( - "Either intensity or size as (n observations, n replications)" + "Either intensity or size as (n observations, n simulations)" " can be provided. Providing both creates statistical conflicts." " between the requested intensity and implied intensity by" " the number of observations and the area of the hull. If" " you want to specify the intensity, use the intensity argument" - " and set size equal to the number of replications." + " and set size equal to the number of simulations." ) else: raise ValueError( f"Intensity and size not understood. Provide size as a tuple" - f" containing (number of observations, number of replications)" + f" containing (number of observations, number of simulations)" f" with no specified intensity, or an intensity and size equal" - f" to the number of replications." + f" to the number of simulations." f" Recieved: `intensity={intensity}, size={size}`" ) elif isinstance(size, int): - # assume int size with specified intensity means n_replications at x intensity + # assume int size with specified intensity means n_simulations at x intensity if intensity is not None: n_observations = int(intensity * _area(hull)) - n_replications = size + n_simulations = size else: # assume we have one replication at the specified number of points - n_replications = 1 + n_simulations = 1 n_observations = size intensity = n_observations / _area(hull) else: raise ValueError( f"Intensity and size not understood. Provide size as a tuple" - f" containing (number of observations, number of replications)" + f" containing (number of observations, number of simulations)" f" with no specified intensity, or an intensity and size equal" - f" to the number of replications." + f" to the number of simulations." f" Recieved: `intensity={intensity}, size={size}`" ) - result = numpy.empty((n_replications, n_observations, 2)) + result = numpy.empty((n_simulations, n_observations, 2)) bbox = _bbox(hull) - for i_replication in range(n_replications): + for i_replication in range(n_simulations): generating = True i_observation = 0 while i_observation < n_observations: @@ -473,20 +473,20 @@ def simulate_from(coordinates, hull=None, size=None): """ if isinstance(size, int): n_observations = coordinates.shape[0] - n_replications = size + n_simulations = size elif isinstance(size, tuple): assert len(size) == 2, ( f"`size` argument must be either an integer denoting the number" - f" of replications or a tuple containing " - f" (n_simulated_observations, n_replications). Instead, recieved" + f" of simulations or a tuple containing " + f" (n_simulated_observations, n_simulations). Instead, recieved" f" a tuple of length {len(size)}: {size}" ) - n_observations, n_replications = size + n_observations, n_simulations = size elif size is None: n_observations = coordinates.shape[0] - n_replications = 1 + n_simulations = 1 hull = _prepare_hull(coordinates, hull) - return simulate(hull, intensity=None, size=(n_observations, n_replications)) + return simulate(hull, intensity=None, size=(n_observations, n_simulations)) # ------------------------------------------------------------# @@ -824,19 +824,19 @@ def l_function( # ------------------------------------------------------------# FtestResult = namedtuple( - "FtestResult", ("support", "statistic", "pvalue", "replications") + "FtestResult", ("support", "statistic", "pvalue", "simulations") ) GtestResult = namedtuple( - "GtestResult", ("support", "statistic", "pvalue", "replications") + "GtestResult", ("support", "statistic", "pvalue", "simulations") ) JtestResult = namedtuple( - "JtestResult", ("support", "statistic", "pvalue", "replications") + "JtestResult", ("support", "statistic", "pvalue", "simulations") ) KtestResult = namedtuple( - "KtestResult", ("support", "statistic", "pvalue", "replications") + "KtestResult", ("support", "statistic", "pvalue", "simulations") ) LtestResult = namedtuple( - "LtestResult", ("support", "statistic", "pvalue", "replications") + "LtestResult", ("support", "statistic", "pvalue", "simulations") ) _ripley_dispatch = { @@ -856,8 +856,8 @@ def _ripley_test( metric="euclidean", hull=None, edge_correction=None, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, **kwargs, ): stat_function, result_container = _ripley_dispatch.get(calltype) @@ -884,10 +884,10 @@ def _ripley_test( ) core_kwargs["support"] = observed_support - if keep_replications: - replications = numpy.empty((len(observed_support), n_replications)).T + if keep_simulations: + simulations = numpy.empty((len(observed_support), n_simulations)).T pvalues = numpy.ones_like(observed_support) - for i_replication in range(n_replications): + for i_replication in range(n_simulations): random_i = simulate_from(tree.data) if calltype in ("F", "J"): random_tree = _build_best_tree(random_i, metric) @@ -900,17 +900,17 @@ def _ripley_test( n_distances.squeeze(), empty_distances.squeeze(), ) - rep_support, replications_i = stat_function(random_i, **core_kwargs) - pvalues += replications_i >= observed_statistic - if keep_replications: - replications[i_replication] = replications_i - pvalues /= n_replications + 1 + rep_support, simulations_i = stat_function(random_i, **core_kwargs) + pvalues += simulations_i >= observed_statistic + if keep_simulations: + simulations[i_replication] = simulations_i + pvalues /= n_simulations + 1 pvalues = numpy.minimum(pvalues, 1 - pvalues) return result_container( observed_support, observed_statistic, pvalues, - replications if keep_replications else None, + simulations if keep_simulations else None, ) @@ -921,8 +921,8 @@ def f_test( metric="euclidean", hull=None, edge_correction=None, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, ): """ coordinates : numpy.ndarray, (n,2) @@ -940,10 +940,10 @@ def f_test( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - keep_replications: bool + keep_simulations: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's replications attribute - n_replications: int + will be returned as the result's simulations attribute + n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. """ @@ -956,8 +956,8 @@ def f_test( metric=metric, hull=hull, edge_correction=edge_correction, - keep_replications=keep_replications, - n_replications=n_replications, + keep_simulations=keep_simulations, + n_simulations=n_simulations, ) @@ -968,8 +968,8 @@ def g_test( metric="euclidean", hull=None, edge_correction=None, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, ): """ coordinates : numpy.ndarray, (n,2) @@ -987,10 +987,10 @@ def g_test( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - keep_replications: bool + keep_simulations: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's replications attribute - n_replications: int + will be returned as the result's simulations attribute + n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. """ @@ -1002,8 +1002,8 @@ def g_test( metric=metric, hull=hull, edge_correction=edge_correction, - keep_replications=keep_replications, - n_replications=n_replications, + keep_simulations=keep_simulations, + n_simulations=n_simulations, ) @@ -1015,8 +1015,8 @@ def j_test( hull=None, edge_correction=None, truncate=True, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, ): """ coordinates : numpy.ndarray, (n,2) @@ -1034,10 +1034,10 @@ def j_test( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - keep_replications: bool + keep_simulations: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's replications attribute - n_replications: int + will be returned as the result's simulations attribute + n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. """ @@ -1049,8 +1049,8 @@ def j_test( metric=metric, hull=hull, edge_correction=edge_correction, - keep_replications=keep_replications, - n_replications=n_replications, + keep_simulations=keep_simulations, + n_simulations=n_simulations, truncate=truncate, ) @@ -1062,8 +1062,8 @@ def k_test( metric="euclidean", hull=None, edge_correction=None, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, ): """ coordinates : numpy.ndarray, (n,2) @@ -1081,10 +1081,10 @@ def k_test( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - keep_replications: bool + keep_simulations: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's replications attribute - n_replications: int + will be returned as the result's simulations attribute + n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. """ @@ -1096,8 +1096,8 @@ def k_test( metric=metric, hull=hull, edge_correction=edge_correction, - keep_replications=keep_replications, - n_replications=n_replications, + keep_simulations=keep_simulations, + n_simulations=n_simulations, ) @@ -1109,8 +1109,8 @@ def l_test( hull=None, edge_correction=None, linearized=False, - keep_replications=False, - n_replications=9999, + keep_simulations=False, + n_simulations=9999, ): """ coordinates : numpy.ndarray, (n,2) @@ -1128,10 +1128,10 @@ def l_test( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. - keep_replications: bool + keep_simulations: bool whether or not to keep the simulation envelopes. If so, - will be returned as the result's replications attribute - n_replications: int + will be returned as the result's simulations attribute + n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. """ @@ -1144,6 +1144,6 @@ def l_test( hull=hull, edge_correction=edge_correction, linearized=linearized, - keep_replications=keep_replications, - n_replications=n_replications, + keep_simulations=keep_simulations, + n_simulations=n_simulations, ) From 75e75a414fb61288bb87033dfc037634cf2fcedf Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 8 Jun 2020 16:54:41 +0100 Subject: [PATCH 27/67] rework types again for shapely --- pointpats/ripley.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/pointpats/ripley.py b/pointpats/ripley.py index b6638d2..e25ec1d 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -142,14 +142,16 @@ def _(shape: spatial.qhull.ConvexHull, x: float, y: float): try: from shapely.geometry.base import BaseGeometry as _BaseGeometry + from shapely.geometry import ( + Polygon as _ShapelyPolygon, + MultiPolygon as _ShapelyMultiPolygon, + ) from shapely.geometry import Point as _ShapelyPoint HAS_SHAPELY = True @_contains.register - def _( - shape: _BaseGeometry, x: float, y: float, - ): + def _(shape: _BaseGeometry, x: float, y: float): """ If we know we're working with a shapely polygon, then use the contains method & cast input coords to a shapely point @@ -262,7 +264,7 @@ def _prepare_hull(coordinates, hull): if (hull is None) or (hull == "bbox"): return _bbox(coordinates) if HAS_SHAPELY: # protect the isinstance check if import has failed - if isinstance(hull, _ShapelyPolygon): + if isinstance(hull, (_ShapelyPolygon, _ShapelyMultiPolygon)): return hull if HAS_PYGEOS: if isinstance(hull, pygeos.Geometry): From bfb00e8c2d465a35626e94d75a0e5527e4d17598 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Mon, 8 Jun 2020 17:12:12 +0100 Subject: [PATCH 28/67] [WIP] improve the notebook --- .../distance_statistics-numpy-oriented.ipynb | 331 +++++++++++++----- 1 file changed, 249 insertions(+), 82 deletions(-) diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb index fb69b0f..bde34e0 100644 --- a/notebooks/distance_statistics-numpy-oriented.ipynb +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -28,8 +28,6 @@ "from scipy import spatial\n", "import libpysal as ps\n", "import numpy as np\n", - "from pointpats import (PointPattern, PoissonPointProcess, as_window, \n", - " G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv)\n", "from pointpats import ripley\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt" @@ -47,11 +45,7 @@ "The distance between the nearest neighbor(s) $N(u)$ and the point $u$ is nearest neighbor distance for $u$. After searching for nearest neighbor(s) for all the points and calculating the corresponding distances, we are able to calculate mean nearest neighbor distance by averaging these distances.\n", "\n", "It was demonstrated by Clark and Evans(1954) that mean nearest neighbor distance statistics distribution is a normal distribution under null hypothesis (underlying spatial process is CSR). We can utilize the test statistics to determine whether the point pattern is the outcome of CSR. If not, is it the outcome of cluster or regular\n", - "spatial process?\n", - "\n", - "Mean nearest neighbor distance statistic\n", - "\n", - "$$\\bar{d}_{min}=\\frac{1}{n} \\sum_{i=1}^n d_{min}(s_i)$$" + "spatial process?" ] }, { @@ -63,9 +57,7 @@ "points = np.array([[66.22, 32.54], [22.52, 22.39], [31.01, 81.21],\n", " [9.47, 31.02], [30.78, 60.10], [75.21, 58.93],\n", " [79.26, 7.68], [8.23, 39.93], [98.73, 77.17],\n", - " [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]])\n", - "pp = PointPattern(points)\n", - "kdt = spatial.KDTree(points)" + " [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]])" ] }, { @@ -83,74 +75,138 @@ "source": [ "#### $G$ function - event-to-event\n", "\n", - "The $G$ function is defined as follows: for a given distance $d$, $G(d)$ is the proportion of nearest neighbor distances that are less than $d$.\n", - "$$G(d) = \\sum_{i=1}^n \\frac{ \\phi_i^d}{n}$$\n", + "The $G$ function is a kind of \"cumulative\" density describing the distribution of distances within a point pattern. For a given distance $d$, $G(d)$ is the proportion of nearest neighbor distances that are less than $d$. To express this, we first need to define the nearest neighbor distance, which is the smallest distance from each observation $i$ to some other observation $j$, where $j \\neq i$:\n", + "$$ min_{j\\neq i}\\{d_{ij}\\} = d^*_i $$\n", "\n", - "$$ \n", - "\\phi_i^d =\n", - " \\begin{cases}\n", - " 1 & \\quad \\text{if } d_{min}(s_i)" + "array([ 0. , 3.84791574, 7.69583148, 11.54374723, 15.39166297,\n", + " 19.23957871, 23.08749445, 26.93541019, 30.78332593, 34.63124168])" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "gp1 = G(pp, intervals=20)\n", - "gp1.plot()\n" + "g_test.support" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0. , 0. , 0.16666667, 0.16666667,\n", + " 0.25 , 0.58333333, 0.83333333, 0.91666667, 1. ])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "support, gfunction = ripley.g_function(points, support=20)" + "g_test.statistic" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "array([0. , 0. , 0. , 0.0247, 0.0011, 0.0003, 0.0059, 0.0581,\n", + " 0.0677, 0. ])" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "g_test.pvalue" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "g_test.simulations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make a plot of the statistic, the `statistic` is generally plotted on the vertical axis and the `support` on the horizontal axis. Here, we will show the median simulated value of $G(d)$ as well." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "g_test = ripley.g_test(points, support=10, keep_simulations=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -162,23 +218,96 @@ } ], "source": [ - "plt.plot(*ripley.g_function(points, support=20), marker='x')\n", - "plt.plot(gp1.d, gp1.ev)\n", - "plt.plot(gp1.d, gp1.G, marker='+')" + "plt.plot(g_test.support, np.median(g_test.simulations, axis=0), \n", + " color='k', label='simulated')\n", + "plt.plot(g_test.support, g_test.statistic, \n", + " marker='x', color='orangered', label='observed')\n", + "plt.legend()\n", + "plt.xlabel('Distance')\n", + "plt.ylabel('G Function')\n", + "plt.title('G Function Plot')\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "in the q-q plot the csr function is now a diagonal line which serves to make accessment of departures from csr visually easier." + "As you can see, the $G$ function increases very slowly at small distances and the line is below the typical simulated value (shown in black). We can verify the visual intuition here by looking at the p-value for each point and plotting the simulated $G(d)$ curves, too:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# grab the middle 95% of simulations using numpy:\n", + "middle_95pct = np.percentile(g_test.simulations, q=(2.5, 97.5), axis=0)\n", + "# use the fill_between function to color between the 2.5% and 97.5% envelope\n", + "plt.fill_between(g_test.support, *middle_95pct, \n", + " color='lightgrey', label='simulated')\n", + "\n", + "# plot the line for the observed value of G(d)\n", + "plt.plot(g_test.support, g_test.statistic, \n", + " color='orangered', label='observed')\n", + "# and plot the support points depending on whether their p-value is smaller than .05\n", + "plt.scatter(g_test.support, g_test.statistic, \n", + " cmap='viridis', c=g_test.pvalue < .05)\n", + "plt.legend()\n", + "plt.xlabel('Distance')\n", + "plt.ylabel('G Function')\n", + "plt.title('G Function Plot')\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "It is obvious that the above $G$ increases very slowly at small distances and the line is below the expected value for a CSR process (green line). We might think that the underlying spatial process is regular point process. However, this visual inspection is not enough for a final conclusion. In [Simulation Envelopes](#Simulation-Envelopes), we are going to demonstrate how to simulate data under CSR many times and construct the $95\\%$ simulation envelope for $G$." + "From this, we can see that there is statistically significant \"dispersion\" at small values of $d$, since there are *too few* nearest neighbor distances observed between $0 < d < 25$. Once we get to very large distances, the simulation envelope covers the observed statistic. As such, we can say that the point pattern recorded in `points` is unusally dispersed. \n", + "\n", + "To evaluate the $G(d)$ function without considering any statistical significance or simulations, you can use the `g_function` in the `ripley` module, which simply returns the distances & values of $G(d)$. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", + " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", + " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", + " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]),\n", + " array([0. , 0. , 0. , 0. , 0. ,\n", + " 0.16666667, 0.16666667, 0.16666667, 0.16666667, 0.25 ,\n", + " 0.25 , 0.25 , 0.41666667, 0.58333333, 0.75 ,\n", + " 0.83333333, 0.83333333, 0.91666667, 0.91666667, 1. ]))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ripley.g_function(points)" ] }, { @@ -187,36 +316,45 @@ "source": [ "#### $F$ function - \"point-event\" \n", "\n", - "When the number of events in a point pattern is small, $G$ function is rough (see the $G$ function plot for the 12 size point pattern above). One way to get around this is to turn to $F$ funtion where a given number of randomly distributed points are generated in the domain and the nearest event neighbor distance is calculated for each point. The cumulative distribution of all nearest event neighbor distances is called $F$ function." + "When the number of events in a point pattern is small, $G$ function is rough. For the pattern contained in `points`, there are only 12 observations! This means that there are only 12 nearest neighbor distances, and thus only 12 possible values for the $G(d)$ statistic, at any $d$. \n", + "\n", + "One way to get around this is to turn to an alternative, the $F(d)$ function. This is analogous to the $G(d)$ function, but measures the nearest neighbor distance *from* a set of known randomly-distributed points *to* a point in the observed pattern. Another way of thinking about $F(d)$ is that it reflects a *between-pattern* measure of dispersion, where one pattern is completely spatially random and the other pattern is our observed pattern. In contrast, $G(d)$ is a *within-pattern* measure of dispersion. \n", + "\n", + "For a randomly simulated point pattern of size $N_s$, this makes the $F(d)$ function:\n", + "\n", + "$$F(d) = \\frac{1}{N_s} \\sum_k^{N_s} \\mathcal{I}(d^*_k < d)$$\n", + "\n", + "This can have $N_s$ possible values for any $d$, and thus can give a much more fine-grained view of the point pattern. In this sense, the $F(d)$ function is often called the *empty space function*, as it measures the distance from random points in \"empty space\" to the \"filled\" points in our point pattern. The number of those random points governs how \"fine-grained\" our measure of the observed point pattern can be. \n", + "\n", + "Just like the `ripley.g_test`, this function is evaluated for every $d$ in a support. Further, we can provide *custom* values for `support`, just in case we have known distance values of interest. \n", + "\n", + "Below, we'll use the same ten `support` values from $G(d)$ function. And, let's constrain the \"simulated\" point patterns to fall within the convex hull of our original point pattern: " ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "fp1 = F(pp, intervals=20) # The default is to randomly generate 100 points." + "f_test = ripley.f_test(points, support = g_test.support, keep_simulations=True, hull='convex')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the $F(d)$ function is very smooth, we can see the $F(d)$ statistic and its simulations clearly by plotting their values directly as lines. For the simulated values, we will make them very transparent. As before we will visualize statistical significance using the `pvalue` attribute:" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deVzU1f7H8ddhWERUXMAlAUHcFxQlNdS0LLcys9WtrCy3aLnVzW7+utWtW5babVEws1Jzy0xyabHdJXMBQXAXFAEXEFQWkXXO749BRWUZdWCG4fN8PAi+8z3fmc9807eHM9/vOUprjRBCiOrPwdoFCCGEsAwJdCGEsBMS6EIIYSck0IUQwk5IoAshhJ1wtNYLe3h4aF9fX2u9vBBCVEuRkZFpWmvP0vZZLdB9fX2JiIiw1ssLIUS1pJQ6WtY+GXIRQgg7IYEuhBB2QgJdCCHshAS6EELYCQl0IYSwExUGulLqC6VUqlJqdxn7lVLqY6VUnFIqRinVzfJlCiGuR2h0aLn7526IZ0t82mWPbYlPY+6G+Os+9onv3jarttKO/9fvM5m7If6ajw2NDr1Yd1Ude+H8mHtsSRWd2+tlTg99ATC4nP1DgNbFXxOAsBsvSwhhrvJCOWxX+X8dA7zcCVkadfH4LfFphCyNIsDL/bqP3ZHxtVl1l3b8uqSFBHi5X/OxYbvCLtZdVceG7Qq77Hxdi4rO7fVS5kyfq5TyBdZprTuVsu9T4E+t9bLi7QNAf631ifKeMygoSMt16EKYJzQ6lCldp5S670KovHdfAK0au/Lrof18vHEbd3Zx5JfUUIZ6PUKR1hQZS3xpjbH459PnCjiYkkXjui6kZOXSyrMO9Vyd2JW9ki51Hii3rszzBcSdyqZJ3VoXjz1StLrC48o63tDwt+s6Ns3pe/wMw6nn6lRlxxoa/oY6ewdDOzXBq34t0MbLv4zGqx/TRtCaTxPWEDsu1qzXu5JSKlJrHVTqPgsE+jpgutZ6c/H2b8BUrfVVaa2UmoCpF4+Pj0/3o0fLvD5eCFFC54WdLwZATkEOSVlJ7Dwez47kQxxIT+BYdhIFDmkopzMoZSz1OUx/1VUFr6RRpTSp+NjrPa5yXrOiV6Sspy7zWH3pv2W8aMXvsvRjJ3eZXOY/1qUpL9AtcadoGaellAe1ngfMA1MP3QKvLUS1UVYve+6GeAK83An29wBAa836/XFsTTxI91ZGkrOSAbjvu1Ecy04mp+js5U9Q5IqbSxPqGFuSmu5GB08/7mzdkaa1b+KN6NF8fusGnAwKZ0cHXBwdcDI44OzogLPBASdHB3YePcMLX+9ibC8fFm9LZPboQIL9PS77R6QsF347GNvz0rETN99mdu/zyuMLfF4wHas15GdDzmnISTd9P1/i55x00k6d4HBCIn61c7m9ST5Rx87iWJgDxkKzXhsg38GV7i08iUjJx8XFFRxdwOAMjrWu+NkZDC7g6MKJc0Z+OXiWGb67eCahJ4MDvPDxqAcOjmBwMn13MBR/v2K7eH/nLS9cdw+9PJYI9GTAu8S2F3DcAs8rhF0J2xV2MdALjYWcOHeCpKwkzhj2M/mHKLr4FZFjTCUhM5G8ovMAfHvy0vGHMkzXJRjyWtOhzkC639Sa21u1o8tNN7H1SDohS6OYVByMgb1NofxGNPTwa1hmTVvi03hhxS5mjzG17+XfiJClUcweHVjh+7kQxhf+AbhwLD4VHFiYD5nJ7N63h/W//s13nR3xOZ/OE55H6AvkvdcGl/wzUJRfxhMoClzqk5XnSjvPptRr6AP5u1lZ0Js+HX3xauwBznXA2Q1c6lz62dkNnOuw40Q+z686xIzRvQhu1RgWduaWvNnMvj/w4j+qFb7nsYGw+TY6jZ3OvSXOgdm2mN/0Wlgi0NcAIUqp5UBPIKOi8XMhapqEjAQAJv4ykaSsJE5kn6BQX+pJOro7EXWiAbUdGpOd1Y2ivAYYCxpBQSPaefiSWO9Zpgf+TJBvA5rUq3XZc5cVrLNHBzK5y+Ry64pJzrgsjIL9PZg9OpCY5IzrPvbLXSPg5G7ISIKzSabvGUmQkWzazk4BNJ2ATgAxQJ2m1Hf3YlxRQw7X96V9S1+o3RBqNwLX4u8Xtmu58/mmBAK83PErfu3J0aH49HmIdckZTLrVv9y6I3fHM2NM8MW6J3eZTNc+pvdcUSiXfM+TsyZfdr6uJdArOrfXq8IxdKXUMqA/4AGkAK8DTgBa67lKKQXMxnQlTA7weGnj51eSD0VFTRAaHVrqFQ2BjQO5t9W9eNXx4kS6G99sy2TzodMAeDdw5f7uXgS1aEhXn/rUcXEsd/jjyiEbMIV8THIGk/qVH243pDAf0g5Cyh5I2V38fQ9kn7y8ncEZ3L3A3Rvqe5u+u3ubHqvvDfWam4Y3hFluaAxdaz2qgv0aePo6axPCbmmtcXNyw0E50Lp+aw6cOXAxlPMLjayLOc6/vz/M/pOnqO/qhKuTgUd6tWDlzmR6+DW8LKDL69GVFtrB/h7XNgRQ/huBrJNXB3fagUvj1QZn8GwH/rdD43ZQ3wfcfUyh7eYJDnIPY1Ww2vS5QtizvKI83tzyJmsPr+XOFnfydu+36bm0J5m5BSzblsiXfyVwMjOXNk3qMPHWlqyISOLzx4II9vegfzvPy4ZQgGu6CuKGZRyDIxvhxK5LAX7+9KX99bygSUdoM8j0vUknaORv+sBPWJUEuhAWlpqTyvN/PE9sWixPd32aiQETOZ6RS0fXBwh+93ey8wrp3aoR0+/vTL82nny68TBzxnQrdRzbYr3s8uSchoRNcHgDHNkA6XGmx53coHF7aD/MFNpNOkKTDuDaoPJrEtfFrOvQK4OMoQt7cmEcu269Ezz3x3NkF2QzrtW/OJXShrM5+ayNMV0nMCygGU/2bUmn5td2Z6FF5Z+DxL8vBfiJGECbrgZp0Rta9gO/ftC4gwyV2KDKvg5diBovwMudKd99hvL8hiZujbmn/rv8b3UehcYE6rg48kRvXx7r7Ufz+q5VX1xRARyLvBTgSdvBWGAa9/bqAbe9agrw5t1k2KSak0AX4gYVGYvYemYRRR5LIcef1KRxzM/KpUFtJyb182dUTx/q1arioMzNhL2rYd8aOLrFdJMOCpp1gVummALc5xZwrl21dYlKJYEuxA3IzM9k6sapbD62mVYug4jadytg4M4OTZgzuhvOjlU4ZGEsgsN/QPQy2L8OCnOhgR90GWkKcN8+pmu5hd2SQBfiOiVkJPDM78+QlJVEw5zRRO0LwMXRgfF9/Fi+I4mIo6er5kPNlL2waynEfGO6BrxWfeg6BrqMAq+g0uceEXZJAl2IaxQaHUqAZwAvb3iZIqMDeUkTSM9vSR0XxbxHuxPs70Gf1h5XXXpoUdmpELsSdi2DkzGmeUJaDzT1xtsMlht1aigJdCGugdaasF1hOCgHXPEi9eAoevm0oluLBvRu1ahyLz0syIWDP8Ku5XDoF9BF0KwrDHkfOt0PblXw24CwaRLoQpgp5VwKsyJmAeBwPoBTiffz0h2dmNTPH4PD1cMaFrtb81gk7PwK9qyC3Ayo2wyCQ0xDKo3b3/jzC7shgS5EBbLyswj5LYSdqTsvPlZYK5rabaJRDSZjcKikuziTtsOf0yH+N3B0Nd3g03WU6QNOB0PlvKao1iTQhShDQVEBKw6uYO6uuZzNO4t7UQ+OHelPnVbv89fDOyvvUsSkHfDnu6Ygr90I7ngTgp6AWvUq5/WE3ZBAF+IKWmvWJ6zno50fkZydTOu6gWQl9CP9XHPeG96Rt/a8XzlhnrQDNkyHuF8vBfnNT5rm9BbCDBLoQhSbuyEelzpH+PnE5+xO302r+q1pxwvs2O5Jx5vc+Xh8IP6edUhztPBc1hLkwkIk0IUADp05xMaM94lN2EoDZ0+e6fx/LPqlEcln8hjSqSkfjuyKi6Np3NpiMx9KkAsLk0AXNdKF9T1TzqUwJ3oOq+NX4+boxgjfCXz7hy/vxTpgNObx8uC2TOnfyrIvnhxhGiOP+9W0Gs8db8DNT0mQixsmgS5qpLBdYRQaC/lq71cU6kLGtB/DhM4T2HesiK9yt6KB8X18LRvmyRGmq1bifpEgF5VCAl3UKFpr1h5eC8BnsZ8xxG8IzwY+i1ddL46fPc/ErzaiFEzo25JvIpMZ0L7JjV9LnnMafvoXxCw3BfmA16HHU+BS1wLvSIhLJNBFjTFzx0wW7l142WM/HvkR33q+PNFxImPnbyMzt5CZDwbwQHdv+rW9euWga7Z3NXz/Ipw/A7f+E3o/J0EuKo0EuqgRfj36K2vi1+Dk4MSzgc8yK3LWxfU9tda8vDKGw2nneHFgGx7o7g3c4O372anww0umQG/WBR4Jh6adLf22hLiMBLqwaxl5Gby7/V2+P/w97Ru2550+79CqQStmRc662GbxtkS+iUzm2QGteeb21pcdf82372ttmjTrx5dNc5APeB2CnwWD/FUTlU/+lAm79dexv/j3X/8mPTedyV0m81TAUzg5mG4ImtzFdC35joTTvLlmDwPaNeb5Aa3Le7qKZR6HdS+YJtDyuhmGzwHPtjf6NoQwmwS6sDs5BTnMjJjJNwe/wd/dn48HfEzHRh0vazOl6xRSMnOZsmQn3g1r88HDXXEoZYIts2gNUYth/TQoyodB70DPSTLfiqhyEujCrkSmRDJt8zSOZx/nsY6PERIYgovh6rnB8wqLmLw4knN5hSx5sifurtd5K//ZRFjzrGmloBZ94J6PoZH/Db4LIa6PBLqwC3lFeXyy8xMW7V1E8zrN+XLwl3Rv0r3M9m+u3cvOxLOEjelGmybXcdWJ0QgRn8Ovb5i275oF3Z8Ahypcck6IK0igi2otNDqUfl79eHXzqxzOOMxDbR7ixaAXqe1U9uLHy7YnsnRbIpP7+zOkc7Nrf9H0eFjzDBz9C/xvh2EfQX2fG3gXQliGBLqotgqMBYTtCmNezDwauTZi7h1z6d28d7nHRCWe4fXVe+jb2oOXBl7jB5Zaw7a58OubYHA2fejZdYys2SlshgS6qJYKjAU89fNTAAzxG8IrPV7B3cW93GNSs3KZvHgnTdxd+GRUYKmrDJX9grmw9lmI+RpaD4JhH0K9m27kLQhhcTLgJ6qd0OhQun3VjciUSADWHV5Hn+V9CI0OLfOY/EIjTy/Zydnz+Xw6Noj6tZ3Nf8GsFFh4tynMb5sGo7+WMBc2SXrootq5s8WdfBb7GQN8BrA+Yf3FOz7L89/v97Ij4QwfjexKh5uuYeWfE7tg2SjTrfsPLYIOw2+gciEql/TQRbVSYCzg//76P+o51+PVnq+adczKyGQW/n2Up/r6Mbxrc/NfbO9q+GIwoOCJnyTMhc0zK9CVUoOVUgeUUnFKqVdK2e+ulFqrlNqllNqjlHrc8qUKAV/u/pK96XuZ1nMaDWs1vHjHZ1likzN4NTyWYP9GTB3czrwX0Ro2vA8rHoUmHeGp303zsQhh4yoMdKWUAZgDDAE6AKOUUh2uaPY0sFdr3QXoD8xSSl3DIKUQFTt05hBhu8IY5DuIgb4DgatXD5q7IZ4t8WkApGfnMfGrCOq5OBLUogGOBjP6LwXnYeUT8Md/IWAkjFsHdZtY/L0IURnM6aH3AOK01oe11vnAcuDK3z01UFcppYA6wGmg0KKVihrN3KGWAC93QpZGsenQKUKWRnEqK4/8IiO9/BtV/CKZx+HLIbAn3LQc3Ii54FTLgu9CiMplzoeizYGkEtvJQM8r2swG1gDHgbrAw1pr45VPpJSaAEwA8PGRGzGE+S4MtczqN4uGtRqW2e7ClLdPfLmD3EIjbs4G5j7SveIZE49FwrLRphkSRy6FdkMt/A6EqHzm9NBLu1hXX7E9CIgGbgK6ArOVUlddSqC1nqe1DtJaB3l6el5zsaJmKm2opTzHzpwnt9DUnxjfx6/iMI9dCV8OBUdnGP+zhLmotswJ9GTAu8S2F6aeeEmPA6u0SRxwBDDzEyghynatV7VsP3KaV1bF4OigePo2fxZvS7w4pn4VoxF+fxu+HQ83dYOn/jB9CCpENWVOoO8AWiul/Io/6ByJaXilpERgAIBSqgnQFjhsyUJFzXTlVS3lSUzP4YkF29EawsZ055+D2jF7dCAhS6OuDvX8c/DNo7BxBgQ+Ao+uBrcbXDtUCCurcAxda12olAoB1gMG4Aut9R6l1KTi/XOBt4AFSqlYTEM0U7XWZXSLhDDPtQy1ZOYW8MTCHRQWaWY+2IU7O5quTCl1GbnM47D0IUjZA4PehV6TZT4WYReU1lcOh1eNoKAgHRERYZXXFravwFjA2B/GcvLcScKHh5fbOy8sMvLEwgi2xKXx1fie3FLeFS2Zx2HBXZB9Ch78ElrfWQnVC1F5lFKRWuug0vbJrf/CJpl7VQvA29/vY+PBU0y/r3MFYX4CFtxtCvNHVoF3DwtXLYR1SaALm3MtQy1fbT3Kgi0JjO/jx8ge5VwKm3XSNMFWdgqMlTAX9knmchE25Vquatl8KI031uzh9naNeXVo+7IbZqWYeuaZJ2Dst+Bz5W0UQtgH6aELm2LuUEv8qWymLImklWcdPhrZtey5zbNTYeEw09j52JXg06uSKhfC+iTQhc0wd6jlzLl8xi/YgZPBgfnjgqhbq4wFnrNPmcI8IwnGrIQWwZVUuRC2QQJd2ARzh1ryC41MXhLJ8bO5LH2qJ94Ny1g79FyaKczPHIUx34Bv+UvTCWEPJNCFTTBnqEVrzetrdrP18Gn+93AXgnzLGJI5lwYL74EzCabVhfz6Vl7hQtgQCXRhdW/9/Rar4lZVONTy+eYjLNuexNO3+TMi0Kv0RufSYdFwOB1vCvOW/SqpaiFsj1zlIqyqwFjAioMrKhxq+X1/Cv/9YR+DOzblxTvblt4o57QpzNPjYNRyaNm/UmoWwlZJoAurmhczD6DcuVr2n8zkmaVRdLypHh883AWH0q5oyTkNi+6BtIOm6W/9b6vMsoWwSTLkIqwiNDqUsF1hF7df3PAibIDJXSZftgpRWnYe4xdE4ObiyPxHb6a2cyl/ZM+fMfXMTx2EUUuh1YCqeAtC2BzpoQurGNVuFI1dG9OiXgsAYsfFEjsuFoeMQRdnRswtKGLiV5GkZuUypHNTmrqXsnrQ+bOw6F44tR9GLoFWd1Tl2xDCpkigiyqntea1v17jTN4ZZtw647J9F5aQ2xKXxr9WxRJ59AwujgYGdWx69ROdPwtfjTDNmvjwYploS9R4MuQiqtySfUvYkLyBV3q8QvtG7ZncZfLFfRemu31yYQQ5+UW4OhmY92gpS8jl58CSB+BkLDz8FbQZVMXvQgjbI4EuqtTe9L3MipxFf6/+jG43GuCyMXMAPw83CotMS8g92beUJeSMRvhuEiRHwEOLoO2QKqldCFsnQy6iypwrOMfLG1+mYa2GvNX7LVQpi0porZmyeCf5RZpHb2nBktKWkPvjbdi7Gga+BR3uqaLqhbB9Euiiyvx3639Jykpiet/p1K9Vv9Q2s345SFTSWcb29OE/wztdvYRc1BLYNAu6jYNbQqqweiFsnwS6qBJr4tew9vBaJgVM4uamN5fa5vS5fD7fdAR/TzfeHN4JuHwJORI2w9rnwK8f3DVLlo0T4goyhi4qXUJGAm9vfZvuTbozIWBCme3+s3YPhUYjoWO6XzYdbrC/B8H1M2D+WGjoZxo3N5Qxw6IQNZj00EWlyi/K558b/4mzwZnpfadjcDCU2u73/Sl8F32cKf1b0bZp3ct35pyGJQ+CcoDRK8C19OEaIWo66aGLSvVB5AfsP72fT27/hKZupVxLDmTlFjAtfDdtmtRhym3+l+8szIevHzHNaT5uramHLoQolfTQRaX5I/EPluxbwtj2Y+nv3b/Mdu/9tJ+Tmbm8d38ALo4levBaw7rn4ehmGB4qqw0JUQEJdFEpTp47yWtbXqN9w/b8o/s/ymy37XA6i7cm8kRvPwJ9Gly+c/P/IHoJ9HsFAh6s5IqFqP4k0IXFFRmLeGXTK+QX5fP+re/jbHAutV1uQRGvrIrFu6ErLw5sc/nOPd/Bb29Cpweg/ytVULUQ1Z+MoQuLmxczj8iUSN7p8w6+7r5ltvvw10McSTvHkid7Xj6LYnIkhE8E754wfI5cniiEmaSHLixqx8kdzI2Zy7CWwxjmP6zMdrHJGXy26TAPB3nTu1WJW/vPJsGykVCniWlec6dSZlgUQpRKeujCYj6I+IDvj3yPd11vpvWaVma7giIjL38bQyM3Z169q/2lHbmZsPRhKMwzXdHi5lHmcwghriaBLixCa82Xe77EycGJT4Z+gpuTW5lt5208zL4TmXz6SHfcXYtvECoqhG/Hm+Y1H/stNG5XRZULYT8k0IVFLN2/FIAXg16kQ6MOZbaLS83mo18PcVfnZpfPcf7zNDj0M9z9oSwfJ8R1kjF0cUNCo0PpvLAz07dPB2D69ul0XtiZ0OjQq9oajZqp38bg6mzgjXs6XtqxbR5sm2uabCvo8aoqXQi7Y1YPXSk1GPgIMADztdbTS2nTH/gQcALStNb9LFinsFGTu0xmd9puIlMiySnMIXZcbJltv9p6lMijZ5j1YBc867qYHoz/HX6aCm2Hwp3/qaKqhbBPFfbQlVIGYA4wBOgAjFJKdbiiTX0gFLhHa90RkLtAaojfE39n07FNPN316XLbJZ/J4b2f9nNrG0/u69bc9GDGMfj2SfBsB/d9BmXM8yKEMI85PfQeQJzW+jCAUmo5MBzYW6LNaGCV1joRQGudaulChe3JKchh+o7ptGnQhtHtR5NdkF1qO601r4bvBuCdEZ1MC1sUFcDKx01XtDy0CFzqVGXpQtglc8bQmwNJJbaTix8rqQ3QQCn1p1IqUin1aGlPpJSaoJSKUEpFnDp16voqFjZj7q65plv8e72Go4PjVUvJXbBq5zE2HjzF1MHt8GpQ2/Tgr29A0ja452PwaF11RQthx8wJ9NJu09NXbDsC3YG7gEHAa0qpNlcdpPU8rXWQ1jrI09PzmosVtuPQmUN8tfcr7mt9H10bd71s39wN8RdXGDqVlcd/1u2lTZM65OQXmhrs/x7+ng03PwWd7q/q0oWwW+YEejLgXWLbCzheSpuftNbntNZpwEagi2VKFLZGa83bW9/GzdmN57s9f9X+AC/3i8vGvbFmD+fyCknJzKOLd304fQTCJ8NNgTDov1aoXgj7ZU6g7wBaK6X8lFLOwEhgzRVtVgN9lVKOSqnaQE9gn2VLFbZiTfwadqbu5IXuL9CgVoOr9l9YNm7Coki+jz2Bk8GBsLHdCPapA9+MM/3O9+ACcHSp8tqFsGcVfiiqtS5USoUA6zFdtviF1nqPUmpS8f65Wut9SqmfgBjAiOnSxt2VWbiwjoy8DGZFzKKLZxfubXVvme1u9m2Iobi78EQfX4L9PWDdP+DELhi1HBr4Vk3BQtQgZl2HrrX+AfjhisfmXrE9A5hhudKELfpo50dk5mfyWq/XcFBl/4L3zvf7yDhfyLAuzVi2PYnhhi20ifgCej8HbYdUYcVC1Bxyp6gwW8ypGFYeXMno9qNp27Btme1+35/Cgi0JtGtal49HBvL5XXXx2vwvMhsHwe2vVWHFQtQsEujCLIXGQt7e+jaerp4V3kT0xeYENPDOfZ1RBTkE/v0cTi61Wd3qbTA4VU3BQtRAMjmXMMvXB75m3+l9zOw3s9yZFNOy84hKPMOQTk3p5l0fwifBqQM4PRLOI/63VGHFQtQ80kMXFTqVc4rZUbMJvimYgS0Gltv2k98OkVto5KVBbWHnIohZblpCTmZQFKLSSaCLCs2ImEF+UT7Tek4z3bZfhqPp51iyLZGHb/bGv/Aw/PBPaHkb3PrPKqxWiJpLhlxEuf4+/jc/HvmRyV0m41PPp9y2M38+iJPBgX/0aQJLB0LtRnD/fJl0S4gqIj10Uab8onze2fYO3nW9Gd95fLltY5MzWLvrOON7++L5+4twNhEe+EKWkROiCkkPXZTpy91fkpCZQNgdYbgYyr6rU2vN9J/20aC2EyFuv8LWNXDnW9BCPgQVoipJoItSJWUl8VnsZ9zZ4k76NO9TbttNh9L4Ky6dT/oWUuuP16HtXRD8TBVVKoS4QIZcxFW01ry77V0MysDUm6eW29Zo1Ez/cT8d6hdw94F/Qb3mcO8cKOfDUyFE5ZAeurjKhVWIXgp6iSZuTcptuzbmOPtOnOXvFp+j0k7B+J/B9eoJu4QQlU8CXVzmo8iPWHdkHW0atGFM+zHlts0rLGLG+gNMbbCRpikbYehM07S4QgirkEAXl5m/ez4A79/6Po4O5f/xWLotEbezB5jgugDaDIabn6yCCoUQZZFAFxfFn40HYESrEQQ2Lr+nnZVbwLzf9rDCLQzlUh/umS3j5kJYmXwoKgiNDqXzws7cu9o0v3l4XDidF3YmNDq0zGPmbTzMhPxFeBceRY0IgzqypKAQ1iY9dMGUrlN4vNPj3L7idrILsokdF1tu+9TMXA5uWsWnjuuh1xRodUcVVSqEKI/00AUAvx79leyCbLPazv9pG/91CCW/UQcY8HolVyaEMJf00AUAqw6twruuN3f53VVuu8OpWQTv/jfuhlycHv4CnGpVUYVCiIpID12QmJlIREoEI1qN4OnA8hev2LFiOv0dosm7/U1o3L6KKhRCmEMCXfBd3Hc4KAfu8b+n3HZ7o//m3lOfcrhBH+r0mVxF1QkhzCWBXsMVGgtZHbea3jf1LveuUJ2fQ511k8hSbjR5ZL5coiiEDZJAr+G2HN9C6vlU7mt9X7ntkldOxacwgehu7+DWsFkVVSeEuBYS6DVc+KFwGtZqSD+vfmW2KTrwM94HF7HS8W763TWqCqsTQlwLCfQaLP18On8m/cmwlsNwMjhdtm/uhni2xKdBdioF305in9GbYzdP5fPNR6xUrRCiIhLoNdi6w+so1IWMaD3iqn0BXu6ELNlJ+tInUfmZzHD7Jwu3pRDg5W6FSoUQ5pBAr6G01qw6tIoAzwD86/tftT/Y34OV3XfT6PgG3ikYzY7zTZk9JpBgf1lSTghbJYFeQ8WkxXA44zD3tSrjw9CUvfjtnM6fxq4sLBrI48G+EuZC2DgJ9Boq/FA4ro6uDPYbfPXOglz4dp4TEkkAABYwSURBVDyZ2pUX8ycypmcLFm9LNI2pCyFslgR6DZRTkMOPR35kkO8g3Jzcrm7w6xuQupfncicQ1LEN/x3RmdmjAwlZGiWhLoQNk0CvgdYnrCenMKf0a88P/QrbwlhpuIsIp+68f38XwDSmPnt0IDHJGVVcrRDCXDI5Vw0UHheObz1funp2vXxH9in4bjKZ9VozLfVBXru3Pe61L13OGOzvIePoQtgws3roSqnBSqkDSqk4pdQr5bS7WSlVpJR6wHIlCks6knGEqNQoRrQegSp5+77WsCYEnZvB07lP49e0EaN6+FivUCHENasw0JVSBmAOMAToAIxSSnUoo917wHpLFyksJzwuHIMyXD0RV8QXcPAnNvqEsCmzMW/c0xGDg8zXIkR1Yk4PvQcQp7U+rLXOB5YDw0tp9wzwLZBqwfqEBRUYC1gTt4ZbvW7Fw7XE0Mmpg7B+Grk+/ZkU1527OjejV8tG1itUCHFdzAn05kBSie3k4scuUko1B0YAc8t7IqXUBKVUhFIq4tSpU9daq7hBm5I3kZ6bzohWJe4MLcyHVU+CkytvOYVg1A78a2g76xUphLhu5gR6ab936yu2PwSmaq2LynsirfU8rXWQ1jrI01MWFa5q4XHheLh60Ner76UH/3wHTuziUM93WLInn4n9/PFqUNt6RQohrps5V7kkA94ltr2A41e0CQKWF3/I5gEMVUoVaq2/s0iV4oadyjnFpuRNjOs4DkeH4v/tCZth84cYAx/h+RgvmrnnM7nf1dMACCGqB3N66DuA1kopP6WUMzASWFOygdbaT2vtq7X2BVYCUyTMbcua+DUU6aJLwy3nz8KqidDQj289Q9hzPJN/DW2Pq7PBuoUKIa5bhT10rXWhUioE09UrBuALrfUepdSk4v3ljpsL69Na813cd3Rr3A1fd1/Tg9+/CFknyB77A9OXJnGzbwOGBcjCFUJUZ2bdWKS1/gH44YrHSg1yrfVjN16WsKSdqTtJyExgfOfxpgdiVsDulXDbNP63rx6nc9JZOKzH5delCyGqHbn1vwYIPxSOm5MbA1sMhDNHTb1z757EtZ3Awi0JjLzZm07NZZ5zIao7CXQ7l52fzc9Hf2aw72BqG1wgfBJojR7xKW/9cBBXZwMvDmxr7TKFEBYggW7nfkr4ifOF500Tcf31ISRugaEz+CO1NhsOnuK5Aa3xqONi7TKFEBYggW7nwg+F06p+KzrnFcAf70DHEeR3fIi31u2jpacbj97ia+0ShRAWIoFux+LOxBGTFsO9fkNR4ROgThO4+38s+DuBI2nn+PfdHXB2lD8CQtgLmT7XjoXHhePo4MiwI1GQHg/j1pBa6MrHv8UxoF1j+rdtbO0ShRAWJN0zO1VQVMDa+LXc5t6OhlFLIDgE/G5l5voD5BUW8X93XzVhphCimpMeup36M/lPzuSdYcTJE9C0M9z+GjHJZ/kmMpkJfVvi51HK0nNCiGpNAt1OhR8KpzGOBGdnwui1aIMzb6yJoJGbCyG3t7J2eUKISiBDLnYo5VwKm45tYvjZdAx3vgWN27E6+jg7E8/y8uC21K3lVPGTCCGqHQl0O7R613wAejq0Y0ujEZzLK+TdH/cR4OVOc3dX5m6It3KFQojKIIFuZ9Iyj7H8wNcAONz2ESHLopkWHktKZh73dfPimeVRBHjJbf5C2COl9ZVrVVSNoKAgHRERYZXXtlef7PyEebHzrno879QA/AwjOJWdz+zRgQT7e5RytBCiOlBKRWqtg0rbJz10O6G1Jv1EJAAz3LsDsGN0NDednoMhYxAHUrIZ29NHwlwIOyaBbie+jprDt2mRPFlUm8HDPgPgnR/2cSAlC0eDA8/e3orF2xLZEp9m5UqFEJVFAt0O7Dj2F+/FfEq/3AKeuXc5GJwYeNMjLPr7KLUcHfj0ke68MLAts0cHErI0SkJdCDslgV7NHcs+xgu/PYN3QQHvBr+NQ0M/Tmbk8vvfXWlS14VPH+1+cZgl2N+D2aMDiUnOsHLVQojKIDcWVWM5BTk8+8NjFBXm8UnTO6jb+QGMRs0LK6LJLTCycnIw/p51Ljsm2N9DxtGFsFMS6NWUURv5vz/+QVzOCUKL6tFiyCwAPt14mC3x6bx3f+erwlwIYd8k0KupedFh/HJiCy9l5tJ77BpwdCE66Syzfj7A0M5NeSjI29olCiGqmAR6NfRb4m/MiZnLsKxzPHr7TGjYkuy8Qp5bHkWTerV4d0SALPgsRA0kgV7NHDpziFc3TKVTXh7/bjEM1ek+AP69ejdJp3NYPuEW3GvLXC1C1ERylUs1cjb3LM/8OgW3gvN8aPSg1uD3AFgdfYxVO48Rcntrevg1tHKVQghrkR56NVFoLOSlDS+Seu4kX6Zn0eTx1eBUi8T0HKaF7yaoRQOelWlxhajRJNCriZkRM9l2cjtvpaXTZdBH4NGKgiIjz30dhVLw4ciuOBrkFy4hajIJ9Gog/FA4S/YtYWxGJve2uR8CHgTgo18PEZV4ltmjA/FqUNvKVQohrE26dDYsNDqU6NRo3tr6Fr3yinjRsRkUj5v/HZ/OnD/jeLC7F3cH3GTlSoUQtkB66DYsbFcYKw6soGmRZmbaWRyfCgfn2pzNyecfX0fj18iNN+7paO0yhRA2QgLdRuUW5gJwPi+D+ceScL/rY/Bsi9aaqd/GkH4uj88e7Y2bi/wvFEKYSBrYmNDoUMJ2hV3cztGFjPBqxmTOMgVYuj2R9XtSeHVoOzrLykNCiBLMGkNXSg1WSh1QSsUppV4pZf8YpVRM8dcWpVQXy5daM0zpOoWZ/WZe3I7NciV21FamdJ3CoZQs3lq3l76tPXiyT0srVimEsEUVBrpSygDMAYYAHYBRSqkOVzQ7AvTTWgcAbwFXr4MmzHIs+xhvbnmDAKPpl6foXv8DZzdyC4p4ZlkUzgYHunjXx8FBbu0XQlzOnB56DyBOa31Ya50PLAeGl2ygtd6itT5TvLkV8LJsmTVDgbGAlze8jC7I4b1jiTxYrw9P/JjDlvg0pv+4n/0nszBqCPZvZO1ShRA2yJwx9OZAUontZKBnOe3HAz+WtkMpNQGYAODj42NmiTXHnKg5xKTFMCM1Da/bXuffvZ/ljoA0nloUybm8QlwcHZhXYsEKIYQoyZweemm/2+tSGyp1G6ZAn1rafq31PK11kNY6yNPT0/wqa4Atx7fw+e7PuT8zm8FtH4TgZwDILSgiJ68QgPF9/CTMhRBlMifQk4GSk2t7AcevbKSUCgDmA8O11umWKa9mSDufxqt//hP//AKm1usId80Cpfg7Pp2JiyJxcFBMvLUly3ckyXqgQogymRPoO4DWSik/pZQzMBJYU7KBUsoHWAU8orU+aPky7ZdRG5n2+z/Izs9gRoEbrg8tBoMT0UlnefzL7Ri1JnRMN/41tL0s8iyEKFeFga61LgRCgPXAPmCF1nqPUmqSUmpScbN/A42AUKVUtFIqotIqtjMLokLZkhbNy1n5tB65Elzrc+BkFo99uR0XJwc+HhXIoI5NAVnkWQhRPqV1qcPhlS4oKEhHRNTs3I85Gcm4nx7jtvO5zBr6FapFL46mn+OBuX/joOCbicH4NJJJt4QQlyilIrXWQaXtk8m5rCQzL4OXf55I48JC3uj1OqpFL05knGfM/G0UFhlZPL6nhLkQ4prIrf9WoLXmP2vHctKYywLvu6gXOJb07DzGzt/G2ZwClj3Vi9ZN6lq7TCFENSM9dCtYteH/WH8ugRCXFnQdOIPM3AIe/WI7yWfO8/m4IJmjRQhxXSTQq1j8/tVMP7KaXtqFJx5YyfkCI+MX7OBgShZzH+lOz5ZyF6gQ4vpIoFeh3LSDvPTXq9RG8e6wpRQoZyYujiTy6Bk+fDiQ29o2tnaJQohqTMbQq0puBjO+e5g4Jwfm3vx/1K/fimeWRbHx4Cnevz+AuwKaWbtCIUQ1Jz30qlBUyC8rHmCFUyGPew3glnYP8cqqWH7cfZLX7u7AQzd7V/wcQghRAemhVzatmf7NPawpPE7nOjcR0u99/rNuLysjk3n+jtaM7+Nn7QqFEHZCeuiVbNPiN1iSl4R2dOa9IV8w+48EFmxJIKhFA54b0Nra5Qkh7IgEemXRGr1xFtvOLABgZOtXWB9dwMe/HcLF0YEX7myDUrJIhRDCcmTIpTIYjXz87f18lhMH7vUAmH/wbQBcG9/BZ8OmEdxKpsEVQliW9NAtraiA1FXj2Xp6DwBTukwGIGvfdLL2TeeJDhPp01rCXAhheRLolpSfQ+yy+xiZsZU4Vzdm3voBhw/1BsDF0YGQ2/xZJnOaCyEqiQS6pZw/w9rFg3is4AjOrg2ZP3gpy/5055vIZIyn7+TLx27mpUHtZE5zIUSlkUC3gKKMZD5YPIBXDWfp4t6SOYNW8dqKdDYePMXgTk357J5XL46Zy5zmQojKIh+K3qDMk7uYum4sm53h4WZ9GRX4LuO/2MnJzFzmPRLEHR2aXHVMsL+HrA0qhLA4CfQbkBD3E89seJFkR8W/2z1Ou+ZP8vCn2ykyapY82YvuLRpYu0QhRA0igX6dNkfO5eWYT3B0UHx2y9ucU715eN7fNKjtzKLxPfD3rGPtEoUQNYwE+jXSWrPoj6l8kPgDrbSBT4Yu5O9jnkz9dgdtmtRlweM307heLWuXKYSogeRDUTOFRoeSV5THtDUjmZn0IwN0LRY98CPf7a/Li9/somfLhnw9sZeEuRDCaqSHbqawXWFs3v8NsXlpTFGNeHLkGt7+OZGFfx9leNebmPFAF5wd5d9HIYT1SKCbYceJ7QDEnU/lw9pt6T18Cc+u3MuPu08y4daWvDK4HQ4OMi+LEMK6JNDL8fHOj/ks9rOL2+cdHHg+9xAeS/7DkUN9GNCuMa8ObW/FCoUQ4hIZIyhD7NEN/LJnMQAPnSsE4N2uP9Hs9GyS4vtSx8WR8X1lLnMhhO2QQL9CQd45PlnzKI/88TTn87OZ16g3U0ZuBuCZZdEkpJ3D1dnAvEe7y81BQgibIoFewsGohYxecgvzzkRxl0N95vVbwHrjM/T+33by0wbg37gO+UWax4N9JcyFEDZHxtCBorSDLPhxEnOKUqmrFG/6jGX76SEM+jIZrdO4N7A5vVq+yDs/7OfZ21uxeFsivfwbSagLIWxKzQ703EyO/v4605J+YFctZ/rW8kUV/YOXfs7F0XCMUT18mHBrSxJP5xCyNIrZowMJ9vegl3+jy7aFEMIW1MxANxox7lrG8r/e4n9uBhxrudLZOJIfojvh5lzAU31bMr6vH43rmm4SWhdz4rLwLjljogS6EMJWKK21VV44KChIR0REVNnrzd0QT4CXO9HHPmTEgU28VnScba61qJ/rQ3LSGOo5efB4b18eC/alfm3nKqtLCCGuhVIqUmsdVNo++++h55yG41EMObOFhD9+J8wvjUWOmjxHN3JPDONsbh9eubMVY3q1oI6L/Z8OIYT9MivBlFKDgY8AAzBfaz39iv2qeP9QIAd4TGu905KFXuhhB/t7EBodypSuU9gSn0ZMcgaT+vmbGhWHtz4eRdqxHRxN3c3J/NMkOTmS7OjIvuZugCI7twXnTzzMI0HdeWVIO2o5GSxZqhBCWEWFga6UMgBzgDuBZGCHUmqN1npviWZDgNbFXz2BsOLvFhPg5X7xg8iwXWF0MQzgs9VL6N/iJPPmHyY97wSpKpckR0eSnRw55+AA9R2Aq8e4Ve1EavvPoLHPZGo5dbRkmUIIYTXm9NB7AHFa68MASqnlwHCgZKAPBxZp04D8VqVUfaVUM631CUsVeuGDyI+/eQOaQUjk/RR6KyKNgBMYHB2oW9iIWnjS2LEljev60dK9BR08/Qi8qSXe9d3ZeiSdiZtv4/FmK1m8LZGufQItVZ4QQlidOYHeHEgqsZ3M1b3v0to0By4LdKXUBGACgI+PzzUVGhodStiuMGhm2i5UpsmwejXsz1Ndn6dTE29qO5f9YeaW+DRClkaBD7wwsK1ceiiEsDvmBHpp0wheeWmMOW3QWs8D5oHpKhczXvuiKV2n0LXuQ4QsjaLA5wWcEj+4pjCOSc5g9uhAorMmA3LpoRDC/phz638y4F1i2ws4fh1tbsiFHvbs0aZhktmjAwlZGsWW+DSzjp/Uz59gfw+mdJ1y8bFgf49LH6gKIUQ1Z06g7wBaK6X8lFLOwEhgzRVt1gCPKpNeQIYlx8/hUg872N+DyV0mX9bDFkIIYeaNRUqpocCHmC5b/EJr/V+l1CQArfXc4ssWZwODMV22+LjWuty7hqr6xiIhhLAHN3xjkdb6B+CHKx6bW+JnDTx9I0UKIYS4MTJ9rhBC2AkJdCGEsBMS6EIIYSck0IUQwk5YbfpcpdQp4Oh1Hu4BmHcBunVJnZYldVqW1Gk5VVljC621Z2k7rBboN0IpFVHWZTu2ROq0LKnTsqROy7GVGmXIRQgh7IQEuhBC2InqGujzrF2AmaROy5I6LUvqtBybqLFajqELIYS4WnXtoQshhLiCBLoQQtiJahfoSqnBSqkDSqk4pdQr1q6nLEqpBKVUrFIqWillM9NKKqW+UEqlKqV2l3isoVLqF6XUoeLvDaxZY3FNpdX5hlLqWPE5jS6eBdSaNXorpf5QSu1TSu1RSj1X/LhNnc9y6rS181lLKbVdKbWruM43ix+3tfNZVp1WP5/Vagy9eMHqg5RYsBoYdcWC1TZBKZUABGmtbeqGCKXUrUA2pjVgOxU/9j5wWms9vfgfyQZa66k2WOcbQLbWeqY1a7tAKdUMaKa13qmUqgtEAvcCj2FD57OcOh/Cts6nAty01tlKKSdgM/AccB+2dT7LqnMwVj6f1a2HfnHBaq11PnBhwWphJq31RuD0FQ8PBxYW/7wQ0192qyqjTpuitT6htd5Z/HMWsA/TWro2dT7LqdOmaJPs4k2n4i+N7Z3Psuq0uuoW6GUtRm2LNPCzUiqyeHFsW9bkwgpTxd8bW7me8oQopWKKh2SsPjR0gVLKFwgEtmHD5/OKOsHGzqdSyqCUigZSgV+01jZ5PsuoE6x8PqtboJu1GLWN6K217gYMAZ4uHkIQNyYM8Ae6AieAWdYtx0QpVQf4Fnhea51p7XrKUkqdNnc+tdZFWuuumNYl7qGU6mTtmkpTRp1WP5/VLdArfTFqS9FaHy/+ngqEYxouslUpxeOsF8ZbU61cT6m01inFf5GMwGfYwDktHkP9FliitV5V/LDNnc/S6rTF83mB1vos8CemcWmbO58XlKzTFs5ndQt0cxastjqllFvxh08opdyAgcDu8o+yqjXAuOKfxwGrrVhLmS78pS42Aiuf0+IPxz4H9mmtPyixy6bOZ1l12uD59FRK1S/+2RW4A9iP7Z3PUuu0hfNZra5ygdIXrLZySVdRSrXE1CsH07qtS22lTqXUMqA/puk+U4DXge+AFYAPkAg8qLW26geSZdTZH9OvsxpIACZeGFu1BqVUH2ATEAsYix9+FdP4tM2cz3LqHIVtnc8ATB96GjB1Nldorf+jlGqEbZ3Psur8Ciufz2oX6EIIIUpX3YZchBBClEECXQgh7IQEuhBC2AkJdCGEsBMS6EIIYSck0IUQwk5IoAshhJ34f5SvxVvkTOclAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -228,9 +366,27 @@ } ], "source": [ - "plt.plot(*ripley.f_function(points, support=20), marker='x')\n", - "plt.plot(fp1.d, fp1.ev)\n", - "plt.plot(fp1.d, fp1.F, marker='+')" + "plt.plot(f_test.support, f_test.simulations.T, alpha=.01, color='k')\n", + "plt.plot(f_test.support, f_test.statistic, color='red')\n", + "\n", + "plt.scatter(f_test.support, f_test.statistic, \n", + " cmap='viridis', c=f_test.pvalue < .05,\n", + " zorder=4 # make sure they plot on top\n", + " )\n", + "\n", + "plt.xlabel('Distance')\n", + "plt.ylabel('F Function')\n", + "plt.title('F Function Plot')\n", + "plt.show()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From this we see that the values of the $F$ function are *too high* for distances from about 15 to 25, and (in contrast) for values between $5 < d < 10$, the $F(d)$ function has too few short distances. When the observed $F(d)$ values are too large, then the pattern is too dispersed, or regular. If the empirical $F(d)$ tends to fall below the simulated values, then it reflects clustering. This is the *opposite* of the interpretation of the $G(d)$ function above, so be careful!" ] }, { @@ -239,48 +395,58 @@ "source": [ "#### $J$ function - a combination of \"event-event\" and \"point-event\"\n", "\n", - "$J$ function is defined as follows:\n", + "The $J$ function combines the $G$ and $F$ function, in an attempt to provide an immediate graphical indication of the clustering both internally and with respect to the empty space distribution. Practically, the $J(d)$ function is computed as a kind of \"relative clustering ratio\":\n", "\n", "$$J(d) = \\frac{1-G(d)}{1-F(d)}$$\n", "\n", - "If $J(d)<1$, the underlying point process is a cluster point process; if $J(d)=1$, the underlying point process is a random point process; otherwise, it is a regular point process." + "where the numerator captures the clustering due to within-pattern distances and the denominator captures that for the pattern-to-empty distances. This means that when $J(d)<1$, the underlying point process is a cluster point process, and when $J(d)=1$, the underlying point process is a random point process; otherwise, it is a dispersed point process.\n", + "\n", + "This function can suffer from numerical stability issues; as $G(d)$ and $F(d)$ both approach $1$, the $J$ ratio can become chaotic. Further, when $G$ or $F$ reaches one, the $J$ function changes abruptly. As such, the $J$ function is often *truncated* to the first $1$ (either in $F(d)$ or $G(d)$), and any $d$ where both $F$ and $G$ are $1$ is assigned a $J$ value of $1$. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:885: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", + " tree, distances=distances, **core_kwargs\n" + ] + } + ], + "source": [ + "jp1 = ripley.j_test(points, support=20)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "jp1 = J(pp, intervals=20)" + "As you can see from the warning above, the $J$ function did encounter numerical stability issues at about $d=25$. To address this, `pointpats` truncated the $J$ function to only have 14 values in its support, rather than the $20$ requested. " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/ipykernel_launcher.py:1: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", - " \"\"\"Entry point for launching an IPython kernel.\n" - ] - }, { "data": { "text/plain": [ - "[]" + "Text(0, 0.5, 'J Function')" ] }, - "execution_count": 9, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAb1ElEQVR4nO3de5Bc5Xnn8e/T0z03XWYkz0gIjZBkWVQAcRHIBEw22JAsxE4CSYWyTJnVbnkLg8F2sk5twJWqZFNLxamNs9nYCJY4DqoiQMmxEyhXdmNWMWBbifDowkXIQhIY0aORZgb1jEaanpm+PPtHnx5amot6ZvpyuvX7lMfd/fbpt98en/n18avnPcfcHRERqS+Rag9ARERKT+EuIlKHFO4iInVI4S4iUocU7iIidSha7QEAdHR0+Jo1a6o9DBGRmrJ79+4Bd++c6rlQhPuaNWvo7u6u9jBERGqKmb073XOalhERqUMKdxGROqRwFxGpQwp3EZE6pHAXEalDCncRkQp7/KUj7DwycFbbziMDPP7SkZK9h8JdRKTCrupq48Gn904E/M4jAzz49F6u6mor2XuEos5dRORC8rF1HXzz7o38523d3HxpJ7veOck3797Ix9Z1lOw9dOQuIlIFH1vXQcTg/7xxnM/+4iUlDXZQuIuIVMXLb/VzeizD9WuW8tSuo5Pm4OdL4S4iUmE7jwzwxWf2AvA7m7r45t0bz5qDLwWFu4hIhb0WH+LBT6wDoGtJy8Qc/GvxoZK9h8JdRKTC7rt5HW2tjQB0tbcCuTn4+25eV7L3KDrczazBzPaa2feDx0vN7AUzOxTcLinY9mEzO2xmB83stpKNVkSkTsQTSSIGF7U1l6X/2Ry5fxk4UPD4IWCHu68HdgSPMbPLgc3AFcDtwFYzayjNcEVE6kM8McJFi5tpjJZnAqWoXs2sC/gU8K2C5juAbcH9bcCdBe3PuvuYu78DHAauL81wRUTqQzyRpGtJa9n6L/Yr4y+B/wpkC9qWu3svQHC7LGhfCbxXsF08aDuLmd1rZt1m1t3f3z/rgYuI1LKeRJKuJS1l6/+84W5mvw70ufvuIvu0Kdp8UoP7E+6+yd03dXZOeZUoEZG6lM5kOX5qlJVlDPdiTj9wE/CbZvZJoBlYbGZPASfMbIW795rZCqAv2D4OrCp4fRdwrJSDFhGpZb1Do2SyXt0jd3d/2N273H0NuX8o/Rd3/yzwPLAl2GwL8Fxw/3lgs5k1mdlaYD3wSslHLiJSo+KJJEBZ59znc+KwrwHbzexzwFHgLgB3329m24E3gTTwgLtn5j1SEZE6EU+MAJT1yH1W4e7uLwIvBvffB26dZrtHgEfmOTYRkbrUM5jEDFa0VXFaRkRESiueSLJ8Uflq3EHhLiJScfHESFmnZEDhLiJScfEy17iDwl1EpKLSmSy9Q6NlrZQBhbuISEWdGB4jk/WyLmAChbuISEXFT5a/DBIU7iIiFVWJBUygcBcRqah8uF/cXp7zuOcp3EVEKqhncIRli5poipb3MhcKdxGRCqpEGSQo3EVEKqrcF+nIU7iLiFRIJuscG9SRu4hIXTlxapR01nXkLiJST3oGc5Uy5V7ABAp3EZGKqcR53PMU7iIiFRI/GRy5tyvcRUTqRjyRpHNRE82x8ta4g8JdRKRieipUKQMKdxGRioknRioyJQMKdxGRishmPThyL38ZJCjcRUQqom94jFTGNS0jIlJPKlkGCQp3EZGKyC9gUriLiNSR/HncV7Zrzl1EpG7EEyN0LGykpbH8Ne6gcBcRqYh4IsnKClXKgMJdRKQieip0kY48hbuISJlls058MElXhRYwgcJdRKTsBk6PMZ7O6shdRKSevJfIl0Fqzl1EpG5UegETKNxFRMqukldgylO4i4iUWTyRZOmCRloboxV7T4W7iEiZxStcBgkKdxGRsosnRhTuIiL1xN2DBUyVq5QBhbuISFkNnB5nLJ2t2BWY8hTuIiJlVI0ySFC4i4iUVbwKC5igiHA3s2Yze8XMXjWz/Wb234L2pWb2gpkdCm6XFLzmYTM7bGYHzey2cn4AEZEwmziPewiP3MeAW9z9auAa4HYzuwF4CNjh7uuBHcFjzOxyYDNwBXA7sNXMKnMCYxGRkOkZHKG9NcbCpsrVuEMR4e45p4OHseDHgTuAbUH7NuDO4P4dwLPuPubu7wCHgetLOmoRkRpRjRp3KHLO3cwazGwf0Ae84O67gOXu3gsQ3C4LNl8JvFfw8njQdm6f95pZt5l19/f3z+cziIiEVjyRpKtCl9YrVFS4u3vG3a8BuoDrzWzDDJvbVF1M0ecT7r7J3Td1dnYWN1oRkRri7lVZwASzrJZx90HgRXJz6SfMbAVAcNsXbBYHVhW8rAs4Nu+RiojUmPfPjDOaqux53POKqZbpNLP24H4L8CvAz4DngS3BZluA54L7zwObzazJzNYC64FXSj1wEZGw65molKn8tEwx/3y7AtgWVLxEgO3u/n0z+1dgu5l9DjgK3AXg7vvNbDvwJpAGHnD3THmGLyISXh/UuFf+yP284e7urwEbp2h/H7h1mtc8Ajwy79GJiNSw/OrUSte4g1aoioiUTTyRpK0lxuLmWMXfW+EuIlImPYPVqXEHhbuISNnEEyMVPxtknsJdRKQMcjXulT+Pe57CXUSkDBIjKUbGM5qWERGpJ9U6j3uewl1EpAx6qnSq3zyFu4hIGVTrIh15CncRkTKIJ0ZY1BylraXyNe6gcBcRKYtqVsqAwl1EpCyquYAJFO4iIiWXr3Gv1gImULiLiJTcUDLF6bG0jtxFROpJtStlQOEuIlJy1V7ABAp3EZGSq+ZFOvIU7iIiJRZPJFnYVL0ad1C4i4iUXK7GvQUzq9oYFO4iIiUWT4xUdUoGFO4iIiWXW8BUvUoZULiLiJTUUDLF8Gi6qguYQOEuIlJSYSiDBIW7iEhJhWEBEyjcRURKKgw17qBwFxEpqZ5EktbGBtpbq1fjDgp3EZGSypdBVrPGHRTuIiIlVe2LdOQp3EVESigMC5hA4S4iUjKnRlOcGq3uedzzFO4iIiXSE1TKrGzXtIyISN0ISxkkKNxFREomLKtTQeEuIlIy8USSllgDSxc0VnsoCncRkVLpSSRZGYIad1C4i4iUTHwwHGWQoHAXESmZ/BWYwkDhLiJSAqfH0gyOpEKxOhUU7iIiJdETojJIKCLczWyVmf3QzA6Y2X4z+3LQvtTMXjCzQ8HtkoLXPGxmh83soJndVs4PICISBvkyyGpfgSmvmCP3NPAVd78MuAF4wMwuBx4Cdrj7emBH8Jjguc3AFcDtwFYzayjH4EVEwiIsF+nIO2+4u3uvu+8J7g8DB4CVwB3AtmCzbcCdwf07gGfdfczd3wEOA9eXeuAiImEST4zQFI3QsbD6Ne4wyzl3M1sDbAR2AcvdvRdyXwDAsmCzlcB7BS+LB23n9nWvmXWbWXd/f//sRy4iEiL5Spkw1LjDLMLdzBYC3wV+191PzbTpFG0+qcH9CXff5O6bOjs7ix2GiEgo9QyG4zzueUWFu5nFyAX737n794LmE2a2Inh+BdAXtMeBVQUv7wKOlWa4IiLhFA9Wp4ZFMdUyBvwNcMDd/6LgqeeBLcH9LcBzBe2bzazJzNYC64FXSjdkEZFwOTOW5uSZ8dCUQQJEi9jmJuAe4HUz2xe0fRX4GrDdzD4HHAXuAnD3/Wa2HXiTXKXNA+6eKfnIRURComcwXJUyUES4u/uPmXoeHeDWaV7zCPDIPMYlIlIzwraACbRCVURk3ibO4x6SBUygcBcRmbd4IkljNELHwqZqD2WCwl1EZJ7iiSRd7S1EIuGocQeFu4jIvMUTI6EqgwSFu4jIvIVtARMo3EVE5iU5nmHgdLhq3EHhLiIyLz2DQaWMwl1EpH68F8Iad1C4i4jMS0/IzuOep3AXEZmHeCJJY0OEzhDVuIPCXURkXuKJES5ubw5VjTso3EVE5iV3kY5wTcmAwl1EZF7yV2AKG4W7iMgcjaYyDJweU7iLiNST/Hncw3bqAVC4i4jMWTykZZCgcBcRmbOJ87jryF1EpH70JJLEGoxli5qrPZRJFO4iInMUTyRZ0dZCQ8hq3EHhLiIyZ/HESCinZEDhLiIyZ2GtcQeFu4jInIymMvQNj4WyUgYU7iIic9I7NAqEs1IGFO4iInOSL4Nc2a5wFxGpGxMLmJZqWkZEpG7EEyNEI8byReE6j3uewl1EZA56EklWtDcTbQhnjIZzVCIiIRdPJOlqD+eUDCjcRUTmJJ5IhvJskHkKdxGRWRpLZzgxPBraMkhQuIuIzFrv4Cju4TzVb57CXURklvIX6dCRu4hIHQn7AiZQuIuIzFo8kaQhYqxoC9953PMU7iIisxRPJLlocXhr3EHhLiIyaz0hPtVvnsJdRGSWchfpCG+lDCjcRURmZTyd5fip0VAvYAKFu4jIrBwfGiXr4S6DhCLC3cy+bWZ9ZvZGQdtSM3vBzA4Ft0sKnnvYzA6b2UEzu61cAxcRqYZ8GWTNhzvwJHD7OW0PATvcfT2wI3iMmV0ObAauCF6z1cwaSjZaEZEqiwcLmFbV+py7u78MnDyn+Q5gW3B/G3BnQfuz7j7m7u8Ah4HrSzRWEZGqiyeSRAwuCnGNO8x9zn25u/cCBLfLgvaVwHsF28WDtknM7F4z6zaz7v7+/jkOQ0SksuKJES5a3EwsxDXuUPp/ULUp2nyqDd39CXff5O6bOjs7SzwMEZHyiCeSoS+DhLmH+wkzWwEQ3PYF7XFgVcF2XcCxuQ9PRCRcamEBE8w93J8HtgT3twDPFbRvNrMmM1sLrAdemd8QRUTCIZ3J1bjXQrhHz7eBmT0DfBzoMLM48EfA14DtZvY54ChwF4C77zez7cCbQBp4wN0zZRq7iEhF9Q6Nksl66BcwQRHh7u6fmeapW6fZ/hHgkfkMSkQkjOKJ/Hnc63fOXUTkglMrC5hA4S4iUrSewSRmsKJN4S4iUjfiiSTLFzXTGA1/dIZ/hCIiIZE71W/4j9pB4S4iUrR4jdS4g8JdRKQo6UyW40OjNVEpAwp3EZGinBgeI511HbmLiNST+MlcGWQtLGAChbuISFFqaQETKNxFRIqSD/eL28N9Hvc8hbuISBF6BkdYvriJpmhtXFxO4S4iUoR4IsnK9tqYbweFu4hIUWrlIh15CncRkfPIZJ1jg7WzgAkU7iIi59U3PBrUuOvIXUSkbnxQBqkjdxGRupE/j3utLGAChbuIyHnFT+aO3FUtIyJSR+KJJJ2LmmiO1UaNOyjcRUTOq6fGKmVA4S4icl65i3TUTqUMKNxFRGaUzTo9g7W1OhUU7iIiM+obHiOVqZ3zuOcp3EVEZtAzmCuDVLiLiNSRWjuPe57CXURkBvlw15y7iEgdiSdG6FjYSEtj7dS4g8JdRGRG8USSlTU2JQMKdxGRGfUkam8BEyjcRUQmefylI+w8MkA268SD1ak7jwzw+EtHqj20oincRUTOcVVXGw8+vZf/+0Yv4+ks46ksDz69l6u62qo9tKIp3EUkVLbu21rVfkfG0wDc+gvL+NKz+wD4zu4437x7Ix9b11GWsZVDtNoDEBEp9Nirj/GFa75QsX77To3S/W6C7p8n2P3uSfYfO0U66wAsXRDj5JkU99xwSU0FOyjcRSQkjp85zu4Tu4FcEJfDdw5+h/GxRRxPxDjSG+G1o2niJ8cBaIpGuHpVO5+/+cNsWr2UdMb5g++9xpdu+QhP7TrKv7u0c9qA37pva1m+kObD3L3aY2DTpk3e3d1d7WGISIVkPcvbg2+zp28Pe/r28NJ7L3E6dboKIzFaG9roaOlk1eLlLF+wjI6WDobPtLD934b4/Vs/yi3rP8KhXvi9Z/dPOzVz5bYreX3L65Ufvdlud9801XM6cheRsktlUux/fz97+vaw98Re9vbvZWhsCIAPNX+IGy++keuWX8fGZRv59Pc/zav/4dXz9rnzyABffGYv3/hMLnB3Hhnggaf38J9uXMPwaJruown29wxNTLEsuuyr3NL6V3z4oizLl4xDdIiB5AADyQH6k/30j/TzVuIg74++T9az0Al/9tqT/Nlrufdb8OHFPLyrnUuPXExnSyedrZ10tnTS0RrO6RoduYtIyZ0eP82r/a/y1z/dwbC/xbtnfsZYZgyA5S2rWNpwKXdf/XGuXXYtqxatwswmXjvVUbC7c3oszeBIiqFk7mdwJMWeoyd5etd7rP5QK2+dGCbIcRqjEa7uauO61Uv56JolXHvJEn75768r6ug6k82QGEvQP9I/Efr9yf7cl8BI/8SXwfEzx3Em5+f9V99fsSkaHbmLhNxMc7aPv3SEq7razpoO2HlkgNfiQ9x387qq9V3Yb/9If26K5cQe9vbt5WDiIFnPEiGCj63klrW/wa9fehOjw6v4w++9y32fvIxVsQUc6knRnexhcCTFYDLFqWSKtQ138h//9pVciAftQ8kUmez0B6I/Oz7M2o4FbP7oKjatWcqGlYtpip59uoD7r77/vL8rgIZIAx0tHXS0dHAZl027nbszNDZEf7Kf337+t6syLTOTsh25m9ntwP8CGoBvufvXptt2LkfuhTtlfiebzQ5fTN/7hrdP7Lyl7PvdzD/wp7f8/kRbqfreum8rkaHb5hUEle67MCDmG2LT9VvKvqcKylL0PdOc7c4jAzz49N6J+d5zH5ey758c7ufBZ3bz9buu4LKVCzg1OsrwWO7n9NgYZ8bHOD2eu/3Wka9w2cJb6Em+yanMcQAiNLLI1tGa/QjR1DpsdDWJ08bxU6M0mJGaIaDNYFFTlPbWRtpbY7S15H7y99tbGmmbuB+jvbWRw33D/OE/vsE9N6zmqV1Hq1auGMY597KEu5k1AG8BvwrEgZ8Cn3H3N6fafi7hXrhTfv7Hn+B//9IPZ7XDF9N36pL/wutbXp/1H9P5+s6Pdy5/qDO5ctuVk34Ppep/rn27O45/cIuT+09uv7vuqevY89k9APzb2+/zpWf3BXOoncGc6j4evfvaWY+98I/N3fnxoX6+9Owevv7pK9m0egn/+nY/f/Ddffz337qCq1ctJpN10tk06WyWjGdJZ9Nks04qmyadzZD13PNffPke/vymvyWbzQTbZTh4/BRP7XqHzR/t4pKOVo70DfPdPUf5jatXsHJJE5lsbruMZ8kUvC7rWdLZLNlslu/3/hW/uvy+3PPZNGnPkPEMmWyWrKdJjIxxqP8UHQujDJwZZdWSJpobjYxnyAY/Gc9O3M+S69/JMMR+FvhHyHqaLGmcNFkyeOF9T2ORDFhmVr/nbLqVTHINNrqWxvQ6Wn01rY2NLGiK0hJroLWxgdbGKG8PnOZA7zA3rF3Kp65aweIgnNsLAnxRc4yGiJ3/TQPz/dIrpWpVy1Qj3G8E/tjdbwsePwzg7n861fZznXP/xo9e5u8P/B4nm8ZZMW4YBsXvGzNyoDeW5aLxoEOb+K8ptz378cy/076Y05GyD15bMGw/53a695nq+cGo05a2c7bz3CHRlH1NPdJJYzBIRqApO/n5/PgntQFeov8tJoZRMFjj7P81LHjzfPt4BBpy3yNkSzyOamhwiHhu1WHEc/93OOKWuy1oa3AjApxqyDI0xUkMV6SM1akoUSCGEfXcrWccMk5LxFgQbSCG0WhGI0YsuG0040fRUf4lOjap3/t9MV/w9inHPjSa4tCJYZYvbubEqVHWL19EW3Ns3r+TY0NJFjRFz+praDTFmbE0F7dV+FwwF10Jvzbt5ETZVGPOfSXwXsHjOPCL5wzqXuBegEsuuWTWb7B131aeePsxaMo97m3MxUpXKsKq9PSn5jzf3/nRaIZ4LDvx+HhjLlFWpSKsPqdfK/oRvBtN825BvwOxoN/xCOvS0bODyid3YBO3BU84HImleSf2wdHWUDTX75rxCJckI8QajFgkMuXntkm3dtZzB2Mp3iroeyxYz7x+LMLaZAONDUZTQ2RiewtSvjB4I+e8jwGvxlK83pieNJ4rx6NcmYrllntnssQaIjRGI2d9YUx8dJv8Zbc/luJA7IN+M8Ebb0hFuSbVSAQYS2VIpbO0RBtYEGvIBSMW3EJDwf38cz+OjfKj2Pik8f5KqonbUi251xucHkkxPJpmSXOMpa2NNFgQwFbQt33wHg0E4WzGpxqP8/9SK2jAiFouqGMWyQU2xvBomkN9swzIYHe7MnKU17PB31hD8FNgaDTFofeDvgdn7vt3aJu632nkgz3f5+KW2FmP52OqAG9rjpXki6MuuHvJf4C7yM2z5x/fA3xjuu2vu+46n4ufHO73jX/yA9/w5Abf+Cc/8J8c7p9TP9P1veHJDf71f/5ZyfvOj7fUfW94coO7f/B7KWX/5eo7329eqfo/t99S9T1Vv6Xoe7p+C/vO93nu42r1PVO/eY+9eHhSXz853O+PvXj4vK+V8wO6fbocnu6J+fwANwL/XPD4YeDh6bafS7gX7oQbntww6x2+mL7PDbRS9Z0fb6n7nur3UKr+y9V3YUCUsv/pvjTm2/dMXxrz6fvRvY9O+9x8A7Jcfc/Ur1RGNcI9CrwNrAUagVeBK6bbfi7hXrhT5neyUh0R5Psu3HlL2fdDO/7HWW2l6vvRvY+W7UipXH0X/o5L2f+5wVOqvqcKNB2dSrXMFO7lLIX8JPCX5Gb4vu3uj0y3rRYxiYjMXlUWMbn7PwH/VK7+RURkejqfu4hIHVK4i4jUIYW7iEgdUriLiNShUJzy18z6gXfn0UUHMFCi4dQifX59fn3+C9Nqd++c6olQhPt8mVn3dOVAFwJ9fn1+ff4L9/NPR9MyIiJ1SOEuIlKH6iXcn6j2AKpMn//Cps8vk9TFnLuIiJytXo7cRUSkgMJdRKQO1XS4m9ntZnbQzA6b2UPVHk+lmdnPzex1M9tnZhfEaTXN7Ntm1mdmbxS0LTWzF8zsUHC7pJpjLKdpPv8fm1lPsB/sC87IWpfMbJWZ/dDMDpjZfjP7ctB+wewDxarZcA8uwv0o8GvA5cBnzOzy6o6qKj7h7tdcQHW+TwK3n9P2ELDD3dcDO4LH9epJJn9+gP8Z7AfXBGdkrVdp4CvufhlwA/BA8Hd/Ie0DRanZcAeuBw67+9vuPg48C9xR5TFJmbn7y8DJc5rvALYF97cBd1Z0UBU0zee/YLh7r7vvCe4PAwfIXbP5gtkHilXL4T7VRbhXVmks1eLAD8xsd3DB8QvVcnfvhdwfP7CsyuOphgfN7LVg2uaCmJIwszXARmAX2gcmqeVwtynaLrS6zpvc/VpyU1MPmNkvV3tAUhWPAeuAa4Be4OvVHU75mdlC4LvA77r7qWqPJ4xqOdzjwKqCx13AsSqNpSrc/Vhw2wf8A7mpqgvRCTNbARDc9lV5PBXl7ifcPePuWeCvqfP9wMxi5IL979z9e0HzBb0PTKWWw/2nwHozW2tmjcBm4Pkqj6lizGyBmS3K3wf+PfDGzK+qW88DW4L7W4DnqjiWisuHWuC3qOP9wMwM+BvggLv/RcFTF/Q+MJWaXqE6m4tw1xsz+zC5o3XIXQv36Qvh85vZM8DHyZ3m9QTwR8A/AtuBS4CjwF3uXpf/6DjN5/84uSkZB34OfD4//1xvzOyXgB8BrwPZoPmr5ObdL4h9oFg1He4iIjK1Wp6WERGRaSjcRUTqkMJdRKQOKdxFROqQwl1EpA4p3EVE6pDCXUSkDv1/DTOA2GJBqZMAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -292,16 +458,17 @@ } ], "source": [ - "plt.plot(*ripley.j_function(points, support=20), marker='x')\n", - "plt.plot(jp1.d, jp1.ev)\n", - "plt.plot(jp1.d, jp1.j, marker='+')" + "plt.plot(jp1.support, jp1.statistic, color='orangered')\n", + "plt.axhline(1, linestyle=':', color='k')\n", + "plt.xlabel('Distance')\n", + "plt.ylabel('J Function')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "From the above figure, we can observe that $J$ function is obviously above the $J(d)=1$ horizontal line. It is approaching infinity with nearest neighbor distance increasing. We might tend to conclude that the underlying point process is a regular one." + "From the above figure, we see that the $J$ function is above the $J(d)=1$ horizontal line, especially as $d$ gets large. This suggests that the process is over-dispersed. " ] }, { From b3427fbff456c1ca70f79f2686c09a97ea76cd3a Mon Sep 17 00:00:00 2001 From: ljwolf Date: Wed, 10 Jun 2020 16:50:42 +0100 Subject: [PATCH 29/67] fixup simulate_from vs simulate options --- pointpats/ripley.py | 9 + pointpats/tests/test_ripley.py | 321 +++++++++++++++++++++++++++++++++ 2 files changed, 330 insertions(+) create mode 100644 pointpats/tests/test_ripley.py diff --git a/pointpats/ripley.py b/pointpats/ripley.py index e25ec1d..d89ef5a 100644 --- a/pointpats/ripley.py +++ b/pointpats/ripley.py @@ -473,6 +473,15 @@ def simulate_from(coordinates, hull=None, size=None): Note: will always assume the implicit intensity of the process. """ + try: + coordinates = numpy.asarray(coordinates) + assert coordinates.ndim == 2 + except: + raise ValueError("This function requires a numpy array for input." + " If `coordinates` is a shape, use simulate()." + " Otherwise, use the `hull` argument to specify" + " which hull you intend to compute for the input" + " coordinates.") if isinstance(size, int): n_observations = coordinates.shape[0] n_simulations = size diff --git a/pointpats/tests/test_ripley.py b/pointpats/tests/test_ripley.py new file mode 100644 index 0000000..4526291 --- /dev/null +++ b/pointpats/tests/test_ripley.py @@ -0,0 +1,321 @@ +import numpy +from scipy import spatial +from pointpats import ripley +from libpysal.cg import alpha_shape_auto +from shapely import geometry +import pygeos +import warnings +import pytest + +points = numpy.asarray( + [ + [66.22, 32.54], + [22.52, 22.39], + [31.01, 81.21], + [9.47, 31.02], + [30.78, 60.10], + [75.21, 58.93], + [79.26, 7.68], + [8.23, 39.93], + [98.73, 77.17], + [89.78, 42.53], + [65.19, 92.08], + [54.46, 8.48], + ] +) + +tree = spatial.cKDTree(points) + +chull = spatial.ConvexHull(points) +ashape = alpha_shape_auto(points) +pygeos_ashape = pygeos.from_shapely(ashape) + +bbox = numpy.asarray((*points.min(axis=0), *points.max(axis=0))) + +support = numpy.linspace(0, 100, num=15) + +d_self = spatial.distance.pdist(points) +D_self = spatial.distance.squareform(d_self) +try: + numpy.random.seed(2478879) + random = ripley.simulate(bbox, size=500) + D_other = spatial.distance.cdist(points, random) +except: + # will cause failures in all ripley tests later from NameErrors about D_other + # If D_other is missing, then test_simulate should also fail. + pass + + +def test_primitives(): + area_bbox = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) + assert area_bbox == ripley._area(bbox) + area_chull = chull.volume + assert area_chull == ripley._area(chull) + area_pgon = ripley._area(ashape) + assert area_pgon == ashape.area + assert area_pgon == ripley._area(pygeos_ashape) + point_in = list(ashape.centroid.coords)[0] + point_out = (100, 100) + + assert ripley._contains(chull, *point_in) + assert ripley._contains(ashape, *point_in) + assert ripley._contains(pygeos_ashape, *point_in) + assert ripley._contains(bbox, *point_in) + + assert not (ripley._contains(chull, *point_out)) + assert not (ripley._contains(ashape, *point_out)) + assert not (ripley._contains(pygeos_ashape, *point_out)) + assert not (ripley._contains(bbox, *point_out)) + + numpy.testing.assert_array_equal(bbox, ripley._bbox(bbox)) + numpy.testing.assert_array_equal(bbox, ripley._bbox(ashape)) + numpy.testing.assert_array_equal(bbox, ripley._bbox(pygeos_ashape)) + numpy.testing.assert_array_equal(bbox, ripley._bbox(chull)) + numpy.testing.assert_array_equal(bbox, ripley._bbox(points)) + + +def test_tree_functions(): + kdtree = ripley._build_best_tree(points, "euclidean") + balltree = ripley._build_best_tree(points, "haversine") + try: + failtree = ripley._build_best_tree(points, "notametric") + except KeyError: + pass + except: + raise AssertionError("Failed to raise an error for _build_best_tree") + + with pytest.warns(UserWarning): + mytree = ripley._build_best_tree(points, lambda u, v: numpy.var(u - v)) + + # check that neighbors are not returned as a self-neighbor + # for self-neighbor queries + distances, indices = ripley._k_neighbors(kdtree, points, k=1) + assert (indices.squeeze() != numpy.arange(points.shape[0])).all() + distances, indices = ripley._k_neighbors(balltree, points, k=1) + assert (indices.squeeze() != numpy.arange(points.shape[0])).all() + distances, indices = ripley._k_neighbors(mytree, points, k=1) + assert (indices.squeeze() != numpy.arange(points.shape[0])).all() + + +def test_prepare(): + tmp_bbox = ripley._prepare_hull(points, "bbox") + numpy.testing.assert_array_equal(bbox, tmp_bbox) + + tmp_bbox = ripley._prepare_hull(points, None) + numpy.testing.assert_array_equal(bbox, tmp_bbox) + + tmp_bbox = ripley._prepare_hull(points, bbox) + assert tmp_bbox is bbox # pass-through with no modification + + tmp_ashape = ripley._prepare_hull(points, "alpha") + assert tmp_ashape.equals(ashape) + + tmp_ashape = ripley._prepare_hull(points, "α") + assert tmp_ashape.equals(ashape) + + tmp_ashape = ripley._prepare_hull(points, ashape) + assert tmp_ashape is ashape # pass-through with no modification + + tmp_ashape = ripley._prepare_hull(points, pygeos_ashape) + assert pygeos.equals(tmp_ashape, pygeos_ashape) + + tmp_chull = ripley._prepare_hull(points, chull) + assert tmp_chull is chull # pass-through with no modification + + tmp_chull = ripley._prepare_hull(points, "convex") + numpy.testing.assert_allclose(tmp_chull.equations, chull.equations) + + # -------------------------------------------------------------------------- + # Now, check the prepare generally + # check edge correction raise + + try: + ripley._prepare(points, None, None, "euclidean", ashape, "ripley") + raise AssertionError() + except NotImplementedError: + pass + except AssertionError: + raise AssertionError("Did not raise an error when edge correction is set") + + # check tree gets converted into data with no tree + out = ripley._prepare(tree, None, None, "euclidean", ashape, None) + numpy.testing.assert_array_equal(points, out[0]) + + # check three distance metrics + out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[3] + assert out == "euclidean" + out = ripley._prepare(tree, None, None, "haversine", ashape, None)[3] + assert out == "haversine" + test_func = lambda u, v: numpy.var(u - v) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + out = ripley._prepare(tree, None, None, test_func, ashape, None)[3] + assert out is test_func + + # check precomputed failure + try: + out = ripley._prepare(tree, None, None, "precomputed", ashape, None) + raise AssertionError() + except ValueError: + pass + except AssertionError: + raise AssertionError( + 'Did not raise when metric="precomputed" but' " no distances provided" + ) + + # check support setting will: + # give 20 breaks from 0 to max dist if none + out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[1] + assert len(out) == 20 + assert out.min() == 0 + numpy.testing.assert_allclose(out.max(), 34.631242) + numpy.testing.assert_allclose(out.min(), 0) + out = ripley._prepare(tree, 30, None, "euclidean", ashape, None)[1] + assert len(out) == 30 + numpy.testing.assert_allclose(out.max(), 34.631242) + numpy.testing.assert_allclose(out.min(), 0) + # give tuple correctly for 1, 2, and 3-length tuples + out = ripley._prepare(tree, (4,), None, "euclidean", ashape, None)[1] + assert out.max() == 4 + out = ripley._prepare(tree, (2, 10), None, "euclidean", ashape, None)[1] + assert out.max() == 10 + assert out.min() == 2 + out = ripley._prepare(tree, (2, 10, 5), None, "euclidean", ashape, None)[1] + assert out.max() == 10 + assert out.min() == 2 + assert len(out) == 5 + # passthrough support + out = ripley._prepare(tree, numpy.arange(40), None, "euclidean", ashape, None)[1] + assert len(out) == 40 + assert (out == numpy.arange(40)).all() + + +def test_simulate(): + + assert ripley.simulate(ashape).shape == (100, 2) + assert ripley.simulate(chull).shape == (100, 2) + assert ripley.simulate(bbox).shape == (100, 2) + + assert ripley.simulate(ashape, intensity=1e-2).shape == (50, 2) + assert ripley.simulate(chull, intensity=1e-2).shape == (52, 2) + assert ripley.simulate(bbox, intensity=1e-2).shape == (76, 2) + + assert ripley.simulate(ashape, size=90).shape == (90, 2) + assert ripley.simulate(chull, intensity=1e-2).shape == (52, 2) + assert ripley.simulate(bbox, intensity=1e-2, size=3).shape == (3, 76, 2) + assert ripley.simulate(bbox, intensity=None, size=(10, 4)).shape == (4, 10, 2) + + assert ripley.simulate_from(points, hull=None).shape == (12, 2) + assert ripley.simulate_from(points, hull=bbox).shape == (12, 2) + assert ripley.simulate_from(points, hull=ashape).shape == (12, 2) + assert ripley.simulate_from(points, hull=chull).shape == (12, 2) + + assert ripley.simulate_from(points, hull=chull, size=3).shape == (3, 12, 2) + + +def test_f(): + + # -------------------------------------------------------------------------# + # Check f function has consistent performance + + nn_other = D_other.min(axis=0) + n_obs_at_dist, histogram_support = numpy.histogram(nn_other, bins=support) + manual_f = numpy.asarray([0, *numpy.cumsum(n_obs_at_dist) / n_obs_at_dist.sum()]) + numpy.random.seed(2478879) + f_test = ripley.f_test( + points, support=support, distances=D_other, n_replications=99 + ) + + numpy.testing.assert_allclose(support, f_test.support) + numpy.testing.assert_allclose(manual_f, f_test.statistic) + numpy.testing.assert_allclose( + f_test.pvalue < 0.05, [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] + ) + assert f_test.replications is None + + f_test = ripley.f_test( + points, + support=support, + distances=D_other, + n_replications=99, + keep_replications=True, + ) + assert f_test.replications.shape == (99, 15) + + +def test_g(): + # -------------------------------------------------------------------------# + # Check f function works, has statistical results that are consistent + + nn_self = (D_self + numpy.eye(points.shape[0]) * 10000).min(axis=0) + n_obs_at_dist, histogram_support = numpy.histogram(nn_self, bins=support) + numpy.random.seed(2478879) + manual_g = numpy.asarray([0, *numpy.cumsum(n_obs_at_dist) / n_obs_at_dist.sum()]) + g_test = ripley.g_test(points, support=support, n_replications=99) + + numpy.testing.assert_allclose(support, g_test.support) + numpy.testing.assert_allclose(manual_g, g_test.statistic) + numpy.testing.assert_allclose( + g_test.pvalue < 0.05, [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] + ) + assert g_test.replications is None + + g_test = ripley.g_test( + points, support=support, n_replications=99, keep_replications=True + ) + assert g_test.replications.shape == (99, 15) + + +def test_j(): + # -------------------------------------------------------------------------# + # Check j function works, matches manual, is truncated correctly + + numpy.random.seed(2478879) + j_test = ripley.j_test(points, support=support, n_replications=99) + numpy.random.seed(2478879) + j_test_fullno = ripley.j_test( + points, support=support, n_replications=0, truncate=False + ) + numpy.testing.assert_array_equal(j_test.support[:4], support[:4]) + numpy.testing.assert_array_equal(j_test_fullno.support, support) + numpy.random.seed(2478879) + _, f_tmp = ripley.f_function(points, support=support) + _, g_tmp = ripley.g_function(points, support=support) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + manual_j = (1 - g_tmp) / (1 - f_tmp) + assert numpy.isnan(manual_j[-1]) + assert len(manual_j) > len(j_test.support) + assert len(manual_j) == len(j_test_fullno.support) + + numpy.testing.assert_allclose(j_test.statistic, manual_j[:4], atol=0.1, rtol=0.05) + + +def test_k(): + # -------------------------------------------------------------------------# + # Check K function works, matches a manual, slower explicit computation + + k_test = ripley.k_test(points, support=support) + n = points.shape[0] + intensity = n / ripley._area(bbox) + manual_unscaled_k = numpy.asarray( + [(d_self < d).sum() for d in support], dtype=float + ) + numpy.testing.assert_allclose( + k_test.statistic, manual_unscaled_k * 2 / n / intensity + ) + + +def test_l(): + # -------------------------------------------------------------------------# + # Check L Function works, can be linearized, and has the right value + _, k = ripley.k_function(points, support=support) + l_test = ripley.l_test(points, support=support, n_replications=0) + l_test_lin = ripley.l_test( + points, support=support, n_replications=0, linearized=True + ) + + numpy.testing.assert_allclose(l_test.statistic, numpy.sqrt(k / numpy.pi)) + numpy.testing.assert_allclose( + l_test_lin.statistic, support - numpy.sqrt(k / numpy.pi) + ) From 2656033ec869d726a618795a380b242c448244f4 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Wed, 10 Jun 2020 16:50:57 +0100 Subject: [PATCH 30/67] finalize the notebook --- .../distance_statistics-numpy-oriented.ipynb | 1079 ++--------------- 1 file changed, 122 insertions(+), 957 deletions(-) diff --git a/notebooks/distance_statistics-numpy-oriented.ipynb b/notebooks/distance_statistics-numpy-oriented.ipynb index bde34e0..f71b85c 100644 --- a/notebooks/distance_statistics-numpy-oriented.ipynb +++ b/notebooks/distance_statistics-numpy-oriented.ipynb @@ -161,8 +161,8 @@ { "data": { "text/plain": [ - "array([0. , 0. , 0. , 0.0247, 0.0011, 0.0003, 0.0059, 0.0581,\n", - " 0.0677, 0. ])" + "array([0.00e+00, 0.00e+00, 0.00e+00, 2.89e-02, 1.10e-03, 1.00e-04,\n", + " 4.30e-03, 6.10e-02, 7.33e-02, 0.00e+00])" ] }, "execution_count": 6, @@ -206,7 +206,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -243,7 +243,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -266,7 +266,7 @@ " color='orangered', label='observed')\n", "# and plot the support points depending on whether their p-value is smaller than .05\n", "plt.scatter(g_test.support, g_test.statistic, \n", - " cmap='viridis', c=g_test.pvalue < .05)\n", + " cmap='viridis', c=g_test.pvalue < .01)\n", "plt.legend()\n", "plt.xlabel('Distance')\n", "plt.ylabel('G Function')\n", @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -301,7 +301,7 @@ " 0.83333333, 0.83333333, 0.91666667, 0.91666667, 1. ]))" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -333,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -349,12 +349,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -406,14 +406,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:885: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", + "/home/lw17329/Dropbox/dev/pointpats/pointpats/ripley.py:894: UserWarning: requested 20 bins to evaluate the J function, but it reaches infinity at d=25.5178, meaning only 14 bins will be used to characterize the J function.\n", " tree, distances=distances, **core_kwargs\n" ] } @@ -431,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -440,13 +440,13 @@ "Text(0, 0.5, 'J Function')" ] }, - "execution_count": 26, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -477,68 +477,38 @@ "source": [ "## Interevent Distance Functions\n", "\n", - "Nearest neighbor distance functions consider only the nearest neighbor distances, \"event-event\", \"point-event\" or the combination. Thus, distances to higer order neighbors are ignored, which might reveal important information regarding the point process. Interevent distance functions, including $K$ and $L$ functions, are proposed to consider distances between all pairs of event points. Similar to $G$, $F$ and $J$ functions, $K$ and $L$ functions are also cumulative distribution function.\n", + "While both the $F(d)$ and $G(d)$ functions are useful, they only consider the distance between each point $i$ and its nearest point. Earlier we spelled this distance $d_i^*$, and the distance between $i$ and $j$ was $d_{ij}$. So, note that $d_{i}^*$ is the *only* term that matters for $F$ and $G$, if $d_{ij}$ changes (but $j$ isn't closest to $i$), then the $F$ and $G$ functions generally remain the same. \n", "\n", - "#### $K$ function - \"interevent\"\n", + "So, further statistical summary functions have been developed to consider the *whole* distance distribution, not only the nearest neighbor distances. These functions (still considered part of the \"Ripley\" alphabet, are the $K$, and $L$ functions. \n", "\n", - "Given distance $d$, $K(d)$ is defined as:\n", - "$$K(d) = \\frac{\\sum_{i=1}^n \\sum_{j=1}^n \\psi_{ij}(d)}{n \\hat{\\lambda}}$$\n", + "#### $K$ function\n", "\n", - "where\n", - "$$ \n", - "\\psi_{ij}(d) =\n", - " \\begin{cases}\n", - " 1 & \\quad \\text{if } d_{ij}\\pi d^2$ indicates that the underlying point process is a cluster point process. " + "In the same manner as before, we can construct a set of $K(d)$ function evaluations for random point patterns, and compare them to the observed $K(d)$ function we saw in our original data." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "kp1 = K(pp, intervals=20)\n", - "kp1.plot()" + "k_test = ripley.k_test(points, keep_simulations=True)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9ebSleVUluM8dvzu+KSIyIiMzSUBAASWVEFEsRK1a0LY2WBaI1SVgUYXSjpTlEtTVUmVRbXUjtorFEguFtFBMW1tRoSykBaWKYWViypRaJkQOkfGmO8/zr/+4d58494vvvXdfxLsvpt9e662477vfdF+899vfOfucfcQ5Bw8PDw8Pj/0Qu9Y34OHh4eFx/cOThYeHh4fHgfBk4eHh4eFxIDxZeHh4eHgcCE8WHh4eHh4HwpOFh4eHh8eB8GTh4XENICItEXnKMV/zIyLyL47zmh43DzxZeNzwEJFHROQfmu9fKSJVEfmmiH1fJCKT2WLNrz9e8v1dtkg75/LOuS8t4VqPiEh39rm2ReQ3RSR/yHPcLSJORBJHfX8eNy48WXjcVBCRVwP4VQD/s3Puo3vsdnG2WPPrO47xFo8D3+GcywP4GgBfC+BnrvH9eNwE8GThcdNARF4H4BcAvNg599+v4Ph3i8i/M9+/SEQumO8fEZF/LSKfEZG6iPyuiATm/ZeKyIMi0hCRL4rIS0TkLQD+AYC3z5723z7b14nIl81er4jIvSKyKyKPisjPiEhs9t5rRORjIvLWWbR0XkT+p0U+j3PuCQAfBPDsiM8am13nURHZmV1/Zfb2X87+rc3u+esP83P0uDnhycLjZsHrAfwcgG91zt2/xOu8AsBLADwZwFcBeA0AiMjzANwL4CcArAJ4IYBHnHM/DeCvAPzQLIr5oYhz/gqAFQBPAfBNAF4F4PvM+18H4O8AnADwfwJ4l4jIQTcqIncC+DYAfx3x9mtmX988u24ewNtn771w9u/q7J4/ftC1PG5+eLLwuFnwjwB8AsBnF9j3dhGpma9XHOI6v+ycu+icqwD4YwD3zLa/FsBvOOc+5JybOOeecM797UEnE5E4gO8G8CbnXNM59wim0dH3mt0edc79unNuDOA9AM4AuG2f0/6hiNQAfAzARwH8+4h9/lcAb3POfck51wLwJgCv9DqFx17wZOFxs+AHADwdwH9a4Kn7onNu1Xzdd4jrbJnXHUyfyAHgTgBfPMR5iBMAUgAeNdseBXA26prOuc7s5X6i9ctmn+tJzrn/zTnXjdjn9ohrJrA/CXncwvBk4XGzYAfAt2KqD/zHKzxHG0DWfH/6EMc+DuCpe7y3n7VzCcAQwJPMtrsAPHGIa18JLkZccwRgG/vfr8ctCk8WHjcNnHMXAXwLgJeIyC9ewSkeBPBtIrIuIqcB/Nghjn0XgO8TkW+dicdnReTLZ+9tY6oLRN3zGMB9AN4iIgUReRKAfwXgP1/B/R8GvwPgDSLy5Flp7b8H8LvOuRGAXQCTve7Z49aEJwuPmwrOuccxJYx/IiL/xyEP/y0AfwPgEQD/FcDvHuK6n8JUlP5FAHVMtQI+uf/S7H6qIvLLEYf/MKZRzZcw1Rl+G8BvHPLeD4vfwPTz/iWA8wB6s/tgqustAP7bTNN5/pLvxeMGgPjhRx4eHh4eB8FHFh4eHh4eB8KThYeHh4fHgfBk4eHh4eFxIDxZeHh4eHgciJu2W/PEiRPu7rvvvta34eHh4XFD4YEHHig5506Gt9+0ZHH33Xfj/vuXaRHk4eHhcfNBRB6N2u7TUB4eHh4eB8KThYeHh4fHgfBk4eHh4eFxIDxZeHh4eHgcCE8WHh4eHh4HwpOFh4eHh8eB8GTh4eHh4XEgPFl4eHh43OAYj8dLv4YnCw8PD48bFM45DIfDYyGLm7aD28PDw+Nmxng8xng8hoggmUwu/XqeLDw8PDxuIEwmE4xGIwBAPB5HPB4/lut6svDw8PC4QTAajTCZTCAiSCQSEJFju7YnCw8PD4/rHNcqmrDwZOHh4eFxHYPRRCwWQzweP9ZowsKThYeHh8d1CBtNJBIJxGLXtnjVk4WHh4fHdQTnHMbjsUYTicT1sUxfH3fh4eHh4aHlsMD1EU1YeLLw8PDwuMZwzmE0GsE5d6howjmnX8sWvT1ZeHh4eFwDcJGfTCaYTCYAFosmLEEQxyF6e7Lw8PDwOCaEF3qSxEHlsHsRBEliPB4vPWXlycLDw8NjiYha6Lk9FoshFotFRgb7EYSIzAnhPrLw8PDwuAGx30LP7SSKRY+z+zB1tdd5lgFPFh4eHh5HgEUiAaadwtEEF/7wcTwvj+N7zjm1/IiKWpaBpdGRiAQi8ikR+RsR+byI/JvZ9nUR+ZCI/P3s3zVzzJtE5GER+TsRebHZ/lwR+ezsvV+Wa9XC6OHh4RGCTQdxEWe3NUmBkYCIXNaFHT6OUYKNHux7/D4ej+u1b2iyANAH8C3OuecAuAfAS0Tk+QDeCODDzrmnAfjw7HuIyDMBvBLAswC8BMB/FBEqPu8A8DoAT5t9vWSJ9+3h4eGxEMLRgiUIvs/FfL+0ExFFEDwn3ydRsMOb3y8bSyMLN0Vr9m1y9uUAvBTAe2bb3wPgZbPXLwXwPudc3zl3HsDDAJ4nImcAFJ1zH3fTn+q95hgPDw+PawJLFFGeTftFE3Yfe76oqCR8rlgshtFohPF4fKymgktVRUQkLiIPAtgB8CHn3CcB3Oac2wSA2b+nZrufBfC4OfzCbNvZ2evw9qjrvU5E7heR+3d3d4/2w3h4eHjMQKKIeqo/KJogSBQkhDBB2P14LhHBcDicMxYMaxrLwlLJwjk3ds7dA+AOTKOEZ++ze5QO4fbZHnW9dzrnzjnnzp08efLwN+zh4eFxACxRhIlgkWiC+zGSIBFEXceSDru8gSmxJBKJOSJZNo7FeMQ5VwPwEUy1hu1Zagmzf3dmu10AcKc57A4AF2fb74jY7uHh4XGs2IsoFo0muC+JggiTSlgLsV3eTD2FI45lY5nVUCdFZHX2OgPgHwL4WwDvB/Dq2W6vBvBHs9fvB/BKEUmLyJMxFbI/NUtVNUXk+bMqqFeZYzw8PDyOBXsRRVhPOGjhtvuGSSN8PlZSUQRnquq4iQJYbp/FGQDvmVU0xQDc55z7ExH5OID7ROS1AB4D8HIAcM59XkTuA/AFACMAP+icG8/O9XoA7waQAfDB2ZeHh4fHsSCKKPbrm9gL4WiBr+37JIaovgtLFFFNfsuEHEd97rXAuXPn3P3333+tb8PDw+MGR7iUNbwt3GF90HlILOPxeC7CiBKpbQOe3c8SB79SqdSRfF4RecA5dy683Xdwe3h4eOyBMFFcSTQBzOsUTC3xHHbBB+a7vkkofE2ioEYCQK3Nj4os9oInCw8PD48IhIniSqIJey4Acyks4NJ8batd8F9LFJZMbCOfcw7D4dB7Q3l4eHhcC4RLUvkUfyWCsiUKRiY8nxXFw9ELZ1swirDX5fbBYIB4PI5kMnkUH3tfeLLw8PDwMLBEEU4fHZYorMZA0rAlsIxY2I3NSIPEMRwOtQkv7DXV7/cxHo8RBMGxNOV5svDw8PCYwaaErIZw2DSPjSDCRBPuxSBRhMXsyWSC4XAIAEin03P6BrdnMhmMx2OMRiMEQXBUP4ZIeLLw8PDwwOVlq4eNJsIW5SSKRCKhREB9gdbiNAKkgE0isdEG9+X7dgTreDxGv99feGb31cCThYeHxy0NLsBc5K1+sMixUTMsnHP7WpTbRV9ElDT2cpcNi9r2nOl02pOFh4eHxyK4UjO9qAqng0TsvQgiqknOdmCHyYDg/Gweu1f3ti2Z5fupVAqDwQDj8RjpdPrQn/8w8GTh4eFxw8MuqIvuH7YXPyjlFDXNzp6PX7YXwkYP4WOpNZBA+K/VNizpOOfQ7/cBQE0Eh8OhpquWDU8WHh4eNzRsxdIiqaNwNdIi544io6jIglECdQfaiFODsAv/aDSam0cRJYjz/obDIQaDgUYTnGfBL99n4eHh4XEAuGgftGDayGC/VFMUQUSlj8LRCHsnuJ/tm7Ak4JxDr9dTXYPH2vJY3gen4VlrkOFwqOccj8dIJpM+svDw8PDYD1F231H7HFQGG6VDRBkGRpXBhu067H52sY/FYqov0J7DpprYhBc+r529DcyPXk2lUnqNZcOThYeHxw2Lg6KKRaKJsIhst3ObTR/xvXCpre2fsKkmVjox8kgkEkgkEpqeYkQRdX6ms3gOpqoGg4FqFgeR5VHBk4WHh8cNif2iiiuJJqJE6HAEEZWeYqTA/UgKXMyt/mBFbHucTWHZlNNgMFDC4fWtTkGh23dwe3h4eOyBvaKKRQz/oiqV7DF2nyiCCJv7AfNVVdxOJ1geY9NJ4aiE1+M+vV5vjlDsdVOplDbrsddi2fBk4eHhccMhKqqwBLCfgB12ebUkcRBBWDHbNs7xmvY9gseyGS98be5v007cZstqGVGkUqnLhHMvcHt4eHhEwD5t2yfz/cpn9+p7sAvvXgRhiSTKCNA2zLHKyTrVhocm2bJXWzll74HnsLqFtQdhmooGhMuGJwsPD48bDtbyYpFy2L2iCS7QdsHer+KJxzHlREKwRETPpslkgmQyOSd20xuKTrJRWoa9no1ker2eekUBwGAw0GPYrLdMeLLw8PC4oRDVSX3YaMISBZ/eSQD22HBXtu2DCDvU8pyMAmzUMZlMMBgMLiMVS0r2vDadNhqN0G63kUwm1WW23+8rcbTbbR9ZeHh4eIQRNTgoClG+SsClRZllp7aLOnysPcZeyy76NgKwVUv2XDYlZZvxCHu8jXT6/T76/b6SWbfbxXg81uiiVCqh1Wp5gdvDw8ODYCrHOTfXwBa1n40muM1WI3EeRPg8+9mUW1KithD2caIeYdNZNjIJV0RZQduW3YoIBoMBer0ehsMhUqkUut2uprZGoxFKpRLa7TZSqdTS528DwNIMRUTkThH5CxF5SEQ+LyI/Otv+ZhF5QkQenH19mznmTSLysIj8nYi82Gx/roh8dvbeL8txdKB4eHhcN4gSlqOwV0ksI4PxeKy9D8lkcq5j2orLPD4qemH0YI/jNjvDIlz9ZEemApjTS2w6rNfroVaroVqtotlsqlkgdQ4AqNVqaLfbyGazOHHiBFZXV4/4J345lhlZjAD8uHPu0yJSAPCAiHxo9t4vOufeancWkWcCeCWAZwG4HcCfi8jTnXNjAO8A8DoAnwDwAQAvAfDBJd67h4fHdQC7uALQdEwU9hOxGZWwHDU8/8GmkvYTzG2ayUYRJB3qCJaoeD5WMoWNA3m+yWSCRqOBTqej6SjqFExdZbNZNJtNdDodFItFJYkbWrNwzm0C2Jy9borIQwDO7nPISwG8zznXB3BeRB4G8DwReQRA0Tn3cQAQkXsBvAyeLDw8blpElcPyqT0KlijCIratZNpPnyD2EsxtJzWvwyiHr8PnIkmF3WgBzBHFaDRCs9lEr9dDLBZDMplELpdDLpebi1YYYaysrGBlZQWTyUTTU8vGsWgWInI3gK8G8EkALwDwQyLyKgD3Yxp9VDElkk+Ywy7Mtg1nr8Pbo67zOkwjENx1111H+hk8PDyOB1HlsDZ1E4VwV7RtkLPbLFHwad46woajCRIWF3w7f4J6R5gomH7i/sPhcK7UNpwqa7fbaDQamEwmCIIAIlMb8iAI9Pq09eh2uxARpNNp9Ho9dLtdtFqtOYJaFpZugi4ieQC/D+DHnHMNTFNKTwVwD6aRxy9w14jD3T7bL9/o3Dudc+ecc+dOnjx51ffu4eFxfLC6ge1l4Ht7RRXhKCRqbCmJwhKE7WWgxmAFaeoIw+FwrkciFoshlUpdpnkA0PQWyYVCOl/bqqhEIoFarYZSqYTxeIx8Pq9pJ1Y+9ft9FbubzSbq9TpGoxH6/T46nQ4qlQrK5TKq1ery/mNmWGpkISJJTInivc65PwAA59y2ef/XAfzJ7NsLAO40h98B4OJs+x0R2z08PG4ShIVfSwwHRRW2a9o2ynHht41thO1tsC6x4S9LGolEQmdH2K5v3r+ttGLKio1zrFbiPQ4GA5TLZS17XV1dhXOXLMftedmQ1+v11LF2NBqhVqthe3sbvV4PxWLxaP4j9sHSyGJWsfQuAA85595mtp+Z6RkA8J0APjd7/X4Avy0ib8NU4H4agE8558Yi0hSR52OaxnoVgF9Z1n17eHgcP2ylUxiLRBV835aoWnIAoocV8ftwXwXPxe+TyaR2Y3N/9mkwmrBRCKuaaPJnyaTf76NWq6Hf76NQKCAIAhXeORGP98aZF9Q8Op0OJpMJWq0WNjc34ZzTcywby4wsXgDgewF8VkQenG37KQDfIyL3YJpKegTA9wOAc+7zInIfgC9gWkn1g7NKKAB4PYB3A8hgKmx7cdvD4ybBfpHDQVEFq4BsFEGNwaaywmRjz8vFOIpIuA8dXgHM9WlwMWeaimTV6XTQ7/fniCKRSKjOMB6PEQQBcrmcWnWQhOLxuEYwk8kEtVoNnU4Hg8EAw+EQ3W4X5XIZk8kE6+vrGqksG8ushvoYovWGD+xzzFsAvCVi+/0Ann10d+fh4XE9gE/ve3Vi7xdV2GPDvRVRVU/2nDwOwJyOYFNLvAa3WzsOW9lELYKE0e/30ev1kMvlkE6nkU6nEY/HNZU0GAyQTCaRSCSUKGzVl41AKpUKOp2OnpdfAJDP5+GcQ7lc9q6zHh4eNy9sCimKEPaLKpxz+jTNxdVWNO0Vidjz8kk+bA1OWM+o8KxskgrJotvtzk2zW1lZQSaT0cii0+mg3W6j0+nMEVwmk0G3253TSegkW6lUUKvVkE6n1R+KnysIAk111et1bGxsXOH/wuLwZOHh4XHsoHi8V08D94kqY7VVUywptWWvixBFOIpgWolpK6aD2GBHc0BLFkw/9ft9OOeQzWZVCE+lUkin0xgOh+h0Omi1WnPOsNRAWPpKnYOfqVwuo9FoIBaLaVVUMpnEYDBAt9tFNptFu93GE088AeAGb8rz8PDw2AsHaRHhp/9woxujAaadwkZ/eyFcHWX7MEgMJASW2rIRL+wG2+v1MBqNEI/HkclkNLLgcKJut6vaRafTUSLLZDJa0dTtdlUIZ8XU1tYWWq2W6hzUN5iWSqVSaDQaaDQaGI1GWFlZ2ZcgjwqeLDw8PI4VizTYhSuZLPgeRef9TAX3uu5wOJyLJigmMxVlvaRoXsg0F1NFbI6jTTijC87NHgwGShQknkwmg1QqhX6/j2aziXa7rQQ1HA7VC6pQKGgZba/XU3IgGo0GxuMxTp48iW63O/fesuDJwsPD49iwn6DNiIFfYf8mRhlsorPzIg6C1UdY3sq+Bs6MsOePxWLo9/tz1UkUnW3j4GQyQafTwXg81q5qCt4UpuPxuKalSCw0CWSqKpFIaCkuxe9ut4utrS3UarW5xkKSTzwex8WLFzVFtWx4svDw8DgW7Cdo22iCKSZgvjfC2nZYoliELMLmf5xlzZGkdm52PB7HYDBALBZDEARatdTpdPSerDDOEl1WLLGUlWTE/ozRaIROp4NarYbRaKR2HiKCer2OdruN8XisEQkFcVY9Mcph6qrT6Sg55fP5I/t/2gueLDw8PI4F+wnaVqBlrj4sbodnVIRf7wXrNssFl30Mg8FAU0pW92C5Kw3+ut2udm4zfcVmOi7cJCQOKyLBMRoZj8dotVpzXeGdTgfdbhftdltTYSTARCKBM2fOaJQTj8exvb2Nfr+vPR3JZHLh6Opq4cnCw8Nj6bC9DBYUkKk97BV5WFfZRaMKW97K67IslQuwLY+10QwAtNtt1R/YfMcFmgOIWq0Wms2m7sNBRYw+bP8F01LAlMAqlYqW3U4mE7X84Fcul1N9hN5Q9n5pKsjty4YnCw8Pj6ViL0Hb9jVYfSJqP+DyKCKqrNa+DpfacnFlRGHPQR2C0QfLXBOJBIIg0IolagXtdlvTROPxWCucgiCYE6t5bZIOAHQ6HVSrVd2eSqWQy+UQi8V0P5YEk2QoYNN8sF6vI5lMotlsYnt7+zJ9ZxnwZOHh4bE02G5p6yBry2GtHhGlZdiyWStCA5fPogh7PNnUEKuV7HvhyIKLO9NQ/X4fjUZD9QcSCTuxWQrL+2FPBPUNAOj1ehpBkWSYZqJzLVNS7D5ntdRwOFSioOVHrVbTnyHTUidOnDi6/7Q94MnCw8NjKbCNd9bVlZGCfS9s8keE+y32Oi68bzweV38nPqnTbM/2VqTTaU1rUZSmVsHRpRxExMY8fjHlBExJgsI074Pfp9NpdLtdvXYymdTy2Varpc1/7Kno9XrY3d3VCGUwGKDVaqkQzkopRi4AkM1ml/OfaODJwsPDYymwgrbtfLb2HGEhO3w897OlrYwELElYW3Iu/tZkkDoC00/USFiyysWYWkCv10O/31ezP6aE+EWRnFYeFK5ZrTQejxGPxxEEgZbPsvGOfRHdblejCxJbs9lErVbT6qparYbxeIxCoYBGo6FmhNQ66Drrm/I8PDxuSNj0kNUHmFs/yDzQpohIOmxss8exqsiem1oA90mn0xo58D5YcTUajVCv1+GcQxAEag8+mUxQKBSQzWaVKKLsPmKxGBqNBqrVqi7kjBwYyXBUqrUmZ29FLBbTdBPHqlKnqFarqoWUSiVUq1VNpzWbTf2Z1Go1Fc6XCU8WHh4eRwZbgURwUWNEEVXJZMVoYN7Ej/uHu6htpRP3Ay75PFmR2FqCANDFm+NMY7EYWq2Wpn4YdXQ6HdUKSFKsXhIR9Ho9XLx4EcPhEJlMBrlcDkEQaGVUs9nUc5fLZbX9YCTUaDQwHA41kmm1WmoTQrKpVCqqc8RiMVQqFf38w+EQ9Xp97ue9LHiy8PDwuGpY0ZoLIQnCpkjCRn5RAjZ1A0sAliwYddgog4s3iYKpHZvKonOsTR3R24mOrmzUYyMeiYTVSrTZ4IK/tbWFbreLXC6HU6dOIZPJAJiSXbPZ1MorWo2z4slajnBcKvs14vE4crmc6hrOzU/fI7Hw89qU3DLhycLDw+OqYNMyYU3BLmJcvO2TtXWLBS6fNWEJgtcKW4aQSPgexW17jXQ6reWz/X4f3W5XIwj2SDASYborlUqpGywA1Ot1jT5EBNVqFZ1OB+vr6wiCACKiBEStYTgc4uLFi2g2mypC93o9JRM2/bVaLaRSKWxsbKieUq/X9RrUQug5RR2I92EJd1nwZOHh4XFFsAu0XaysaG1JJGwlvpc3FN+zqZUwyTBKsNe20+2sSSC1BKZ8eE+ZTEY1Ebv48jOwGQ4AWq2WlrAmk0k9/8mTJwFcqoZilRIjABoAMqXVbDZVCOd99Ho9iAhyuZymofr9Pur1ukYQ7DgnWdhS3F6vh81NTqpeHjxZeHh4HAphXcKWsLILO8pW/KDpdeHmPR7PhdW+H9WxTBLiNDneDxdUEUE2m8VwOJwrl+W1WD0VBAGazSYGgwESiYQ++cdiMe2LYLqI+sJwOEQ6ndYoh2mndrs9J2QDU7LJZrMaFdCOpNFoKOEMh0MEQaDW5yQGNgsyZVWpVABAS3iXCU8WHh4eB8JGCDZVRO0BwNyTP7/n4snU1F7njiIKRiN2Ih7PYUtkeU+0xKA4TEdXkkYqldJmOkYYfGpnGSun0gFQh9der6f6y3g8VhsQjknt9/tKCOyuZvns6uqqltgmEgl1sO12u+h2u9jc3ES73UYQBEgmk9oMyJQT+zAoxpPoqtUq2u323M9w2fBk4eHhEYmwAG0jCZapRgnQ4UY5q0GEEfZ84jbaa7C/grbdlkyYNqJgzcqmtbU1pNNp3Y8lr+yf4AxsWobTBoTiNlNJ4/FYU0isqqLFBifcUT+g9lCr1TAYDLC+vj7nH8XmPEYQvV4Pjz/+OBqNBpLJJDKZDJxzc6aC9LHi1Lx6vQ4RQbvdvmwyXrFYPMr/+kgsjSxE5E4A9wI4DWAC4J3OuV8SkXUAvwvgbgCPAHiFc646O+ZNAF4LYAzgR5xzfzbb/lwA7waQAfABAD/qjoNKPTxuMYQJwuoKdmyp1Rd4XLhvgufZT5+w57UeSqxS4iyIMDnxvOySbjabWrpKzURE1LuJcyfi8biSiR2AlMvlUCwWNX3E+8nlcnrvqVRKCYKLeiaT0Sf/wWCAIAhw+vRpTCYT1Go1lMtlANPUE9NV3W4X1WoV5XIZsVgM2WxW+zQYRdHufHNzU681mUy0EzwMXmeZOJAsROQFAN4M4Emz/QWAc8495YBDRwB+3Dn3aREpAHhARD4E4DUAPuyc+3kReSOANwL4SRF5JoBXAngWgNsB/LmIPN05NwbwDgCvA/AJTMniJQA+eNgP6+HhEQ27eFsR2hKH3RZFFPYcAObEaJueinKQ5eLIyIHNcGyes8cx4uCQoV6vh0wmM6cZ0A+q3++r2ByPx1EoFJBMJrX5zXZiP/bYY+h0Ovo9IyjagZdKJWxtbanwXCwWdaGnluCcQ7lc1i5t6iS8J4rc29vb6kFVr9cBXLIH4VzvcrmMWq025zPFn9e1wCKRxbsAvAHAA5g+8S8E59wmgM3Z66aIPATgLICXAnjRbLf3APgIgJ+cbX+fc64P4LyIPAzgeSLyCICic+7jACAi9wJ4GTxZeHgcCeziHS5FDaeI9iMK7stzRpXF2miC5+QTPjWDcG+E7atg1MFz2Eoh+3lYNcSGNxFBoVBAOp2ey/0z9VMulzEcDrGysqIlr7FYDOVyWe9nc3NTCYoEcPHiRZRKJRXw2QXO8txCoYDBYIB6vY5Go6FOtSQI6iL8eTHq6PV6c53ZnFtxHFbke2ERsqg7565qYRaRuwF8NYBPArhtRiRwzm2KyKnZbmcxjRyIC7Ntw9nr8Pao67wO0wgEd91119XcsofHTY+oVNAi20kmwLzBn408uNBH9U/Y/VgJRI+ksG0Fn+ptdRV7Gnq9HrrdrgrfHC3KSIK5/Vgshnw+j1QqhUqlMtcUZ6OCfD6vT/YUzAEgk8lgc3NTS2n5pF+pVOYEaBoG0tIjkUigUqnoOalpMKpJpVIolUraUzEajdBoNFCr1S6LHo7DzuMgLEIWfyEi/xeAPwDQ50bn3KcXuYCI5AH8PoAfc8419uk0jHrD7bP98o3OvRPAOwHg3LlzXtPw8IiA1SVs1OkfYM4AACAASURBVABEC848xuoFdrtNJ9nGu73Oye8pPHNfO/Oa20k4JBg20TH/LyJaScTrh23AORq1VCqh2+2qmR/N/7jYs4tbRDQySaVSePTRR7G7u4vhcIh2u418Pq8iN11hqZVsbm7Opbx4r4wWKN6vrq7q/W1ubqJUKgHAXIXT9YZFyOLrZv+eM9scgG856EARSWJKFO91zv3BbPO2iJyZRRVnAOzMtl8AcKc5/A4AF2fb74jY7uHhcUjYJ/SwIG2n2UUt9lEIE4WNIBgR2HPyfevXxLQSUzksM7VutYwcWLIKXGq44zFc4PmUz9RUIpGYc3m1EclkMlGtJAgCjQwajYZ6Ou3s7GiajFVKFy9enJuux4iFRoKnTp3CaDRCuVzG1taWVjZxpjYjjc3NTVSr1aP8L14aDiQL59w3X8mJZfrb9i4ADznn3mbeej+AVwP4+dm/f2S2/7aIvA1TgftpAD7lnBuLSFNEno9pGutVAH7lSu7Jw+NWRZSAbbEoUVhdwvoyhU39eIxdUHk+mgQCmJtIF+7KZtlsEASIxWJa+mp7N6hXsA+BkQO1CKZ4WALLaCAej2s6iI2Ejz322JyW0Gq1NE1F/yi6vFriGwwGaDQaiMfjSKfTWFtbQ7/fx/nz57G7u6vRDUVt9oNsb29fF+mlRbFINdQKgJ8F8MLZpo8C+LfOufoBh74AwPcC+KyIPDjb9lOYksR9IvJaAI8BeDkAOOc+LyL3AfgCppVUPzirhAKA1+NS6ewH4cVtD4+FsV80ARyeKMI9EYwSGA3YlFOYKEgorPgBphoEhWwbcdD5FQBqtZrqDyS+bDariz59m9ivwI7rdrut5aa893Q6PXftRqOBra0txGIxFAoFFcjZ4EdC4P3ncjkAUPGclh4rKytIJpOoVCrY2tpCtVqFiGgHONNT3P9GgxzUriAivw/gc5hWLgFTAniOc+4fL/nergrnzp1z999//7W+DQ+Pa4aDogngYKKwT9BhomDVEHPvVvgOn48VT2ymY3SRSqW0eY0LMhvweBzz+CxpHQwGyGaz2pFNwz1qExSdGQ1MJhMtq2W0Uq1WdWGn5feJEye0cmlzc1Ob/GgVTpLjUKLJZKIkEIvFUCwW0e12USqVsLu7q81/dJRlFLYsS/Gjaj0TkQecc+fC2xfRLJ7qnPsu8/2/MZGCh4fHdYi9hGqLRYjCdmCHq5jYOGcHGoWvx7QLSQWALuQ81o4PpbjN71mRlEwm0e/3tTcBgD6hVyqVueqmdDqNdDqt2zkjm812nE9RKpVUCA+CAKVSSbulu90u0um0ei5xbgRTTqzgsjrN7u6u2nCQZDikaGVlRX2krlWfxNViEbLoisg3Ouc+BmiTXnQboYeHxzXFXmWvYSxCFOG5FHyfugMXext5WEdVLvpcWMO248BUs7D+Sqx2CpMRoxp2c9OSo1wua6TBLu5kMond3V0lCpoJcpYE00LtdhvOTSfkPfzww+ocOx6PNTXGbu1SqaRur+PxGKlUCu12G6VSSX/eNPtj7wdLbHk/vV7vMpuOGwmLkMXrAbxnpl0IgAqmXdgeHh7XERaJJoBootiv+9rqBHZmhHV/tZVLBKubksnkZb0ZXLh7vR6cm86OYMRAXSOZTOqIUqaPqEewFJX2HXRppTBdLBaRz+dVt+Dn3N7e1rJbej49/PDDc46wTFexgY5fqVRKPx/HnLKXgz97nrPX66m/lO3AvpGxSDXUgwCeIyLF2fc3njLj4XED4Upyz+Eu7L3OYRd3XiusT7BPgk/0liSirmcn2rHfgU/QrHKyPRpcQEk6dITlosuUF/UM9l9QUG61WgCgUQPnP2QyGYzHY+TzebUiL5VKaruxs7Oj8yRIOhyJGgSB3hsANf/jsCOOSWX0US6XVb+gfQhJhtbhN3IUEYU9yUJE/plz7j+LyL8KbQcAhMphPTw8rhLhp/tFEXZ23esclihspBDexkokfs+8PO+R+9vowqZiOAqULq5c6AGoUSA7ttl0xwY9AJpusuWy1DCswSAtwpnq4mzsbreLSqWCRqMxN4iIXdKTyUS7r8fjMQqFglp9OOc0IqBewpJeXq9Wq2mPRiqVUqsQ3i81nZsN+0UWudm/hYj3fHe0h8cRIqw1LApGAQfNYWb1UXiwUDjNxIU43GFtexvsMaxscjPjPuoTjCioWwDQaifqDkxTTSYT1QpIIs45LXulBsKcP+dBUPAmGTjntOqp3W6rQyww7Ywej8fo9/solUoYjUYIggDr6+tqUR6Px7Gzs6NCNj8rR5oOh0ONGHivlUpFoxW6zrJp8GbDnmThnPu12cs/d879N/veTOT28PA4AtjUz2GJAsBCRMFzU4y2x9muaz7l2wFAvBaJxKarLFEwXcMFm+koG/lwhgRTWEzbUGgmEdGWm1VUtMqYTCbq3ErNg3oCyYDiN5/2G40GSqWSVkEFQYBCoYBMJqN9Es45nD9/XqMe3j8rm9rttkYj/Pmw4Y/6C+/zZsUiAvevAPiaBbZ5eHgcEldDFHaB3ws2tRPVc2EjGtuJbSudbOUTjyFJ8MmezW5MH1HkZSMdU0skCOBSyoqlq8A0+mi1Wuh0OnqPjAoYfdh00mAwQD6f18ii1WppRMGUEt1bY7EYcrkcCoWCzqbY3d1Fs9nUkaWrq6vI5XJoNps68pTzt+v1upod2h4TNv0dVZ/D9Yr9NIuvB/ANAE6GdIsigOj5iB4eHgvjuIiC1wLmK6Cs5TXJxC7qtuPazpQgOdg0lZ2vPRwOtbqIT+lsaLMRBYmE+gNJgee3Cz/TW6xMyuVyKkxz+BHLYvl5h8MhyuUyxuOx6iOMgqrVKiqViqaXut0u1tbWAACPP/64XgeAGgEOh0M0Gg0Ui0Ukk0klk1sF+0UWKQD52T5Wt2gA+CfLvCkPj5sdV0oUe/VHRO1nS1VtGspWN4Wrmbi42wiDJGBTStQqSCK8L6aBSDLW54nX59AhXp9d2nxS7/f7aszHSXl8oo/H48hms6pnMPXEiic23fX7fXQ6HdUbOEyJGkS9XteyV1ZXURCn9sIBRtQkRATr6+t6zVuJKID9NYuPAvioiLzbOffoMd6Th8dNjUX7IcJYhCi4MIeJyEYRVqPgEz+f3O39kShsespegwI201R8QmeXNRvxeD52cvPcjDBYjsqhRBScc7mc9j2wca/T6aiekUql5qIgRiCtVkuvIyLq90SDwVarpZ3VrLaiTkIrDuoi9HAKgkCjGZbV3mpYRLP4TyLycudcDQBEZA3TiXYvXu6teXjcfLgSojhMV7btVbBCNHD5PO0wUYTFblsWS6JhxMLFnn0G1BKAS8OJWNFkIxmmnZhm4lwI5v3tjGye01YysUw2n8/DOYdarYZKpaLpJgrdHC5ER1oASjS7u7saAfH++PlZWcVoI5vNQkSQyWTU8uNWxSJkcYJEAQDOuapcmm7n4eGxIBbVGizsYm9Hh9r3mRayXcQkIqZmwg13JAoK0zYCYfqKUQN1Cdv0RyJhJVClUgEwnTbHaIBzIrgvK53Yq8DFG4DaeFNXaLfbaDQaOh+CpoH82VGUrlar+qSfTqeRz+c10mi1WqjVatpVTXsQ6hR0pi0UCqjVapENiizVbTQaWoZ7q2IRspiIyF3OuccAQESeBN9n4eFxKBwlUZAgwtU3XMR5DX7Zc1misLYdvEc7iCjc98GUEhd/poWoJbBz2moefMpnNNLpdJQoEokEVldX9Tq1Wk3vo9/vYzAYaITBSXVMR43HY01XWRGeLrCVSgW9Xk97OlqtFur1OjqdjhJgNpsFAI1w2FwXxq1OEsQiZPHTAD4mIh+dff9CzOZce3h4HIyjIIowQYT1iHCTXdS5ooiCC7uNIMJRhH3aBqDpoV6vhyAIVICmQysrm7jw8jwUjweDAYrFoqaIRqORVhsVCgUdcQpAK5eohQCYq8KiYM4RqOyxoBlgOp3WyXfssbDR0GQywdbWlkY4HntjEW+o/yIiXwPg+ZgaCb7BOVda+p15eNwEuFqi4GLO11Hmf5ZUDiIKW5oaLq215EBtglVMdIOdTCba57C6uqoLLx1aWXIqM28p26HNa3IbxeVyuYx+v48gCLC7u6u6gIjoACF+z/4JdnRXKhW02+25Ulb2VHBeBS04ODej1+thZ2dHr+2xGBaJLAAgjanbbALAM2eM/pfLuy0Pjxsfi5a5Wlgx2U6dsyklYJ4orA2HRdhrigIxF3+mrKzmYdMwk8lEZ1mzL4J9DOvr6wCgY0w5NIhicTKZVCLhsdQgbOc0G+a4gDM9RfLh/XY6HU0r0c7jiSee0P2ZCut2u8hkMhqt1Ov1OXPA8XiMWq2G7e3tw/533vJYZKzqfwDw3QA+D4C/eQ6AJwsPjwgsWr0UdRyf+pkiijrWnp9kwrJXgvoD3ycZ0OE1TBLhKioAatsxHA517gT7HOLxOJrNpi7s9XodIoJisagRDO01+JrEMplMsLu7q6NSmWoajUa47bbbkEqlNKKgzgEAKysrGI/HOkeCgnc+n9eIxjmnxELiG41GqNVq6Pf7qn14HB6LRBYvA/AM59ytV1js4XFIHAVRJJPJhc7PvL0lirD+wGiDaZlwLwWjCVvaalNWFLFpy8EZ141GQ5vyuNAHQYB2u60Dg/i0zzGkzjl0u120Wi0dZcqGvGQyidXVVSSTSd2XvRmMgjiwiEI1xeter4fd3V39bNQ7UqkUarUaarUams2mRkUeV4ZFyOJLAJIAPFl4eByA/cpc9wKf8AFcFiGE97M+TtyfhGRtvun8ahvoWEJqy21ZWcTzA9ARpXYMaDqdVrLhdjapjUYjpFIpNJtN7ZomidlKpnQ6rT0MFO0pXNO2g415JBI7XpX3GovFtHeCMycYPXW7XU1LlUolXLx48bJqJlZ1eRwOi5BFB8CDIvJhGMJwzv3I0u7Kw+MGRLjUdNFjwq6vB52f+4eJws564IJo/ZcYcVAXsbbgwCWBnCknkkAul9P77PV66Ha7asbX7XYRi8XUa4nVRuy63t7e1lkR7IxmOW2pVMJwOEQmk1GS4OckgdE9lumw8XiMnZ0dVCoVHbREIZzkAwD1el27r/f6OXocDouQxftnX4eCiPwGgG8HsOOce/Zs25sB/EsAu7Pdfso594HZe28C8FoAYwA/4pz7s9n25wJ4N4AMgA8A+FF3s9s7etxwuJKqJ1vyamdNRME+/VN74P58uo8iCl7H2o7zPABUv7D23tQ6GI1Qe+B5MpkMgOlo0XK5rGJ1EAQ6NY5fzjkUi0UMh0NsbW2pxTfTWJxlTc2EE+nYLc3IiESytbWlaSvqGbu7u7qNP6u9iMLjyrFI6ex7rvDc7wbwdgD3hrb/onPurXaDiDwTwCsBPAvA7QD+XESe7pwbA3gHpn0dn8CULF4C4INXeE8eHkcOPunvJUhHIdwpvN+xYaIIE4IdGkQNwpaYWhKzT/22BJUiti15ZUMcz2/dWyuVCnZ3dzVllcvlVM9Ip9Pq7ppMJtFqtbQ8lpVP7MtIJBJot9sIgkA1CdunYaf27e7uqqhNkZwW48C0ezyTyaDT6agFiY8ijg6LVEOdR0THtnPuKfsd55z7SxG5e8H7eCmmflN9AOdF5GEAzxORRwAUnXMfn93LvZgK7p4sPK4LhPsYFoGNQmxkwfNF7cucPPcjSUwmE13AWVnE9BJJxQ4wsjoFr2UjkFwud9mUO35GRiAUizOZjOoBXOypGzCtNJlMNIpgjwMHB/FeKJKzaW4wGCCZTGrZLnUJjmtlJLO9vY1Op4MTJ06oqSDFc4+jxyJpqHPmdQDg5QDWr+KaPyQirwJwP4Afd85VAZzFNHIgLsy2DWevw9sjISKvw6y7/K677rqKW/TwWAyH1SksUQCXSl9tz0R4XxrcUaewPlAkHDurOjzf2noeMWXFKIaRChdtpqv6/f7cmFQu0kzxiLEC5xxqVkKxg5r9EPy31Wrp57Mka43/mJri9Tk7e2dnB9vb20gmk5p6yufzWFlZQbFYRKfTwSOPPHKE/7MeYSyShgq3OP7fIvIxAP/7FVzvHQB+DtNI5ecA/AKAf45pZ/hll95n+173+k4A7wSAc+fOeV3DY6m4WqKwvQ02FWU9mCjssqTWdjPzX3ZOs+LIVkLZNMxoNNJIwBIUu6v5L1NZLH3l+FJGDZZMAGh5LZ1a2UsRVVprPwvvs9FoYDQaoVKp6Hl5r+12G9vb25pqarVa+pkowH/pS1+6qv9Hj8WwSBrKjk+NYRppFPbYfV8457RtUkR+HcCfzL69AOBOs+sdAC7Ott8Rsd3D45risIJ2OJ3ExZRP/7YJj0/cwKVeCju3waaNJpNLc6IzmYymkKyXE601mH7iom3JyoK6BfUIahWc+QBgrmucYjbJg4t5vV7XstYgCDAajZDNZlEoFFQjKZVKqNfraDabui+7vmk6SINB5xxSqZQ26Q2HQ59yOkYskob6BfN6BOA8gFdcycVE5IxzbnP27XcC+Nzs9fsB/LaIvA1TgftpAD7lnBuLSFNEng/gkwBehen8bw+Pa4b9BG1r9kdQJCa46LN6yXo9sf8h3HUdnithxWkAOiiIUQk1AkYI1A/sxDhegxoHSYsCOUmCCzhnY1Ob4LWoYbCMNhaLqUCdTCaxsbGhVuFc7FlWW6vVNEVFLcM5h52dHT0nz8NmO/tz9Tg+LJKG+uYrObGI/A6AFwE4ISIXAPwsgBeJyD2YppIeAfD9s2t8XkTuA/AFTAnpB2eVUADwelwqnf0gvLjtcQ2xn6AdTvswncMyVOvFFOXlFG6Ys9Po7HlJVEwTZTIZJJNJ7XgmMfDaAJDJZFQ8ttezDq4iolPmmCqijUatVtP3JpMJgiDAZDJRK3D2Q7Bng58vFothe3tbo4per4dqtYoLFy7o3GyK3iyFJSmRtJgq87i2kL1aFmQ6TvU1s9evvooS2muCc+fOufvvv/9a34bHTQY+ze5l2mfLVZlmsj0RUWTDbVa4tvvYc1KwphBNjWIymaDX681ZgTAqsNEOBxIB04Y3CufpdFqJAbhkldFqtdBqtXSxttfqdDoaFVCMzmaz+tmpWfAzDQYD7O7uolqt6rVZ7luv17WbmykypsBIGB7746jaz0TkAefcufD2/SKL55jXPwrghiILD4+jxl5WHnaxBy7Nb2DDW9gtFrjkKGvJwVZEWTJhuofvMRogUXBh5iLN3gSmu3hN9i3QVoNP89lsFoPBALVaTRfm8XisJMEu8MlkosTAVBMtPiiO20U+lUqhXq9raqtcLmsKKpFIIJvNol6vo16vo1QqKSFZE0SP6wf7kYX/n/LwmCFcyWRhjfssOUQRhRW5+X14YbST7sJERHGbo1ApUrOKSOTSmFQeQ4GbRMBqIwrinU4HW1tbqFariMfj+rTPczK11Ww2ISLI5XI6+5riOjUQnttqIf1+XwcQ0bmWVVBbW1sol8v6c+C1PVFcf9iPLO4QkV/GtHyVrxXOe0N53CIId0FbMIcftuuIMhIkQVjxmukm7m9TTTadRZBEbMUTK4u4CFvLDNqDs4+B98aIpFqtolwu6xS7QqGgTW80DOx2u9qwl0wm1V680+lo4xwjlsFgoA63PA8jCrrWjsdjbG1tzQ06sj8jn3K6PrEfWfyEee2T/x63JKx+EI4SKCAfRBTM19tRoDZVxf1ZekrYiIMNcxSeSSIsWaU1h3NOn/b5VA9Ay1V7vd5cpMD3aY/R7XbVRpwLfKFQQCaTgYhge3tbBxgxzcZ5FBxEJCLY2dlRsgGgViDspfjiF78Y+fO+EYkijQxO4DQmmGAXFzHC4eZlFLGOItbQQwdlbMEdIqkjEJzAGaSRwf944It4+nOfetjbX/xaN2u45wVuj6OATS8RXIijog0bIbCiyUYQLG8laVC7oDbAqIHHUH8g2VgHWUYU6XRaG+XsU76NKCw5WJE7nU6jUqmg2Wxq4x0n3mUyGaTTae3LoNU4o5V4PD433xq4RDrUMnh9+j5FRRM3Mu7C0/BUPBuAg4ODQPBZfBIlbB54rCCGe/ACrGADMjvDCEPcj4+gh86Bx2eQwzm8CHEkIBBkcznc883Pwpv/4CeQSC46BDXivq5A4PbwuKUR7tC2QjS3205qCrx2rgSPZerHppWoK5AowvYcPHe73VZBm0RBcuDsBuoR1A3Yt5BOp7XklYRTLBY1qtna2sLW1pYSBXsZNjY2UCgUdJQqq5WcczrjolKpqOU4q55YHdXtdtUShMOKGo3GTeUGm8cKnopnIS7zkeRXuq/DX+FPD4wwnoSnYRUbiMulZTjm4ng2nof78ZEDr/+VeD6SSCMm09+xfqePB//ic/ijt38Q3/WG7zj8BzoAniw8PCIQ9l4Kl68StiyVi7jtyOZ2EgOPZwTC6iGSCiuBSD5c4GkLzmiCKSo7vpRT4+jdlEqltGmP97CysqJWGhcvXsT58+d1YW82mwiCALfffjsSiQRqtRp2d3d18h2jJM6ioKDOdBwNA5n+ovNtr9dDqVS6IVNM++E07oLg8oKHIO7wc2fP4Blrj+17/G899GQ0h/NLcExiWJc1vPcrUsgk9u4taQ0DvPdvixi7+ev3OwP86a9/+HjJQkTucM5d2OO973DO/fGR342Hx3UAK2hHdWRzGxc/lqgC0Kd/ko0dLsQUEqMHLqzcRgLgtSn2Upi2ojUJhSmgZDKJer2uJat2oBEX+WQyqTpCrVbD+fPnVX9oNBpIpVI4e/asDhiq1WqqYZDgGDkwUqETrNU4SBTsxbhZO60FMUQ7vQg2EjE8JbP/8YwILtsO4M60oJja+9hKLIaYOIwjVITRcHT5xiPAfpHFh0Xkxc65R+xGEfnnAH4agCcLj5sKNnoAMEcGXNxtWactlbXd2VzIrfjNL9t8ZyMEew7uJyLIZrNzY0TtfXDuAzWFeDyOVCqFZDKpYjarmdLpNLrdrvZGUGjOZrNa1bS6uqqNeLTZGAwGGgU1m03UajXt2GYKjOknprB4/M2O9ewFpPtPxmAyv+j3xoIf+tIWBgf4G34ZHsed+LK5NJZzDjXXxgs/fdAU6w6+AT1kJT+3NRUk8S3/9B8c5mMsjP3I4g0APiQi3+ac+3tAp9n9UwDftJS78fA4RoTJAcBlKSY+8XOR52Juy1d5HInE+i4BlxrwuLDy6ZtP5bQTJ0mECcdaX7BTmrbithyWvkvcj/OwaQDYaDTQbrf1dS6XQ7vdRiwWQxAE2NnZ0ZRYp9NRq/EgCFS3qNVqc6653W5X9QxaftwK+L7bgV99RhlvfehRfHT7SYCLzyTuCf4en8UAvQPPcR4P4STOIO0ySEgSYzfCBA6fx6cWuofP4ZP4GvdCCARxSSCTD3D6yafwin/9v1ztx4vEvtVQIvKtAH4N04FD/wLA1wL4djedQXFdw1dDeURhL4Kwjq9WW7AWHtyH6aRwFEK3VuCS/TgFadu5PRwONWUTBIGeiwRBHYO9ENQMmA5ixZFzTktah8MhqtWq9kTwfExdNZtNFeepH3AbPaBY0URB2o495aQ7fk47JpW6yK2ApAC/9Azg9XcCHyoD3/MZYDTawCncjjHG2MbjaKO58PkEglM4ixVsoIs2tvAYhljcByuJFM7gSQiQxTvvewde8LKvvapKKGDvaqgDS2dF5BsB/CGA/w7gFc65G+I3w5OFB3EQQRDW/ju83QrTXNytAywJhKZ3fEK36SUSAec+ZLNZjTK4P0XhZDKp4jYji2w2q7Miut2u2pFTcN7d3dWqKaageG+j0Qjtdlt1iF6vp93etPngMCNGLiSRZrOJRqOhpbmj0QiPPvroLWfudyYN/N5XAS9YBf7DeeCnv4hIzeC4kUqlsLKygp2dnSM536FLZ0WkiUsDiNIAvhXAjkz/ipxzrngkd+bhccQgKSxCENzP2oiHZ1wDl8RpRgrsv7D7UydgVGB1DEYsjUYDk8kE6XRaJ8vx/Pb6dGLlgB9qF8PhUD2b8vk8hsMhNjc3UalU9J6YhmIUMhqNlBCGwyHq9bpOpaNGwSiDfR3dbldLYxnVcADRrThD4htWgP/nOUAxAbziM8DvbR98zHEgnU6jUCjg1KlTS7/WnmThnLuiAUceHleLo/QG2o8gbFWTjRxsZRIjA3Yms0zU9lcwVcRKpSAIVEvg+dmvwCY1pqno48R7scZ9FKvtbG1OiltZWVHbjAsXLmifA3sgmA7r9/vaIFepVFCpVBCPx1GpVPRc1Bk4cKjdbmsEJCIol8tzjra3Gn7gjmnq6bEe8I8eAD7fPviYZYHRZLFYxMmTJ9UBIAiC5V976Vfw8DgEwvrAlWKvY23JK7+3YrVNL4X1CUsUYULjdv7xkgwYHXBgECMO7mvP1ev10O12dQY1dQPrI8WIotVqYXNzE5ubm8hmsypas9R2MploE9xgMECpVJoToCmwZzIZ1TTq9frc/AjnnI5EvRWRjgG/+uXAa88Cf7oL/LPPAbVr9KPY2NjA6uoqYrEYNjY2kE6ntZgiFoshn88ffJKrhCcLj+sKVgg+ynPalJR1dOW1bGrJRg18z6ajbMMez8NoAMDcyFL75J7JZLS5zgrpbGLj90z7MFoAoNoEXWJrtRqq1SpyuRxERDuweb+sehoMBtje3tYSWHZVj8djtQinZQctPOgIeysJ12HckQZ+/znA81aAf/sl4M1fvDY23KlUCk9+8pORTqfnKt9IFLR6P3ny5NLvxZOFx3UD25B2VOcKaxa2U9o2v7FPIcoskLl8RgGseuJC3+v1VETmXAfuy6+wGywjERIN74FDgeyxIoJ2u60LBDUGEgutPagrcOJcu92eixZIYhxXytkSrVYL8Xhcz3krQSB4Ep6BO/FlSCCBKnaxUvwM7vvqJoIY8LIHgT/aPf77isfjuOOOO3DmzBn9PR0MBlrkkE6nUSwWsbGxgbW1NRSLy5eQPVl4XDewT/5XinB6aK+qJ1slZCuXmDqyhEVNB9SvSwAAIABJREFUgU/uAJQYmCLiQmz1DeDSwCHr4cS8M3Bp8l673UapVEK1WtVqKF6bZMHmPDbAMXpwzs11VpNEWA7rnFOjwHq9PjeXmz+rVqt1yxEFADwT53AKZ9Wf6QROI9fZwJda/xWveaiHvzvYz+/Isb6+jrvvvhv5fF4j0NFohNOnTyMIAqyvryOXy2FtbQ3JZBLpdPqq/mYWhScLj+sCVxNV7JVmivoDsmRCUTqRSKgFuG2G41e4Z8JWTtnBRDwPRW9rOMgUUy6X0/fYP1EqlbQqaTweY3V1dc5QsN1ua0qI7q8klUQioVYbjHI4HpVjSnluPp3ynlgRVa1e921TS0EaGZzCHSEjQEF3HMdrP/00/J377LHcB3+vAOD222/HmTNnNFLgjPVCoYDbbrsNQRAgm82iUCjMlWTz4WKZ8GThcV0gambEfohKM0UNJ7Kw3ktcsNk9zegg6hz2j5FeTslkUi04UqnUXHks9QemsJje4ihSVjx1Oh1Uq1XtbeD9UZTma55nMBigXC6rj1MymUSj0UCr1VLdgeW7tN6wusNwONTqKlZO3Qq2HHshhyImGCOOedfYCeLIuPVjuQcWOqysrKBYLOL06dPI5XL6+8RIgjNFisXiHEFQx7ihq6FE5DcAfDuAHefcs2fb1gH8LoC7ATyCaZNfdfbemwC8FsAYwI845/5stv25AN4NIAPgAwB+1N2K8fJNjMOknxZJM4XPzejAfm/Hh3IhpqAcnkxnt7M6iikgVj5xPw77oe8Tj+XiTJAoBoPBnDtrr9fTmdjUL0gitVoN9XoduVwOo9EIjz/+uBIN51hbkZuVMjT1ExHU63VtBLzV0UULSbl8ouHETdDC8mZucHBUoVBAKpXCbbfdhmw2q9ttFLq2toZ0Oo1sNqv70KySkaUdoLVMLDOyeDeAtwO412x7I4APO+d+XkTeOPv+J0XkmQBeCeBZAG4H8Oci8nTn3BjAOwC8DsAnMCWLlwD44BLv2+OYcVBUcZg0E/e35bE8P0VlitPUGPivNQrkQkvLDQD6miZ8fKpjOSzLUdkXQUM/Cti8br1eVw2BndWtVkuPoY7CiIXiMzu/KXAzgmg0GqhUKuj1eqp3FAoFVCoVLX215oS3ar9EGD98dxux1g4erJzEyF1aCieY4DH8/ZFfL51OY21tDblcDqurq3P/ktQZ3RaLRayurs4RBft3SA78si7Dy8TSruCc+0sRuTu0+aUAXjR7/R4AHwHwk7Pt73PO9QGcF5GHATxPRB4BUHTOfRwAROReTH2qPFncJLDOrhZRBHFQmonns30aYW8nppw4bIhPcdbmg6kpAHOVSVycOV+CDXV0kGWVUa/X0zGnVrvggs90ET2iGGHYudr1el3LYcvlskYHjDRY/bS7u6tEwYUlHo+jVCrpNuBSV7gPyoFcHPjNZwEvvw1478VP4E/Lz8EJ9yTEEEMLdTyET6OLo+u8C4IAQRDgxIkTKBaLqjnkcjlkMhl9CBkOhxARrKys6PApdmgHQaCzzfmQkk6ntVLvZuyzuM05twkAzrlNEWGP+llMIwfiwmzbcPY6vD0SIvI6TKMQ3HXXXUd42x7Lgl3Y9yp3XVTLsEQR1R9hBWqmh/jUTyJilGBLWln5xPLatbU1vR4w1QIajYaSBUtuSUQkGpLDcDhEu91Gp9PRCiY+JXY6Hezs7GglE0Vr3oudFVEqldTmo1AoYDKZoFaraZopFovpsbeKG+xB+LIs8P8+B/iKHPAT/wN466NjAJ8G8GkIYnA4uqiLkSnF6VOnTiGVSs2ll/gwEYvFsLq6io2NDSUUCtskiUwmoyaSMjOhzOVyWk67bFwvAnfUSuD22R4J59w7AbwTmBoJHs2teSwL4eFB4adeEkSYQPY6l62msjOt7ZxrnpeL8Hg8RjKZ1HQPxWSez86f4Dxq55ya/znnUC6X1c6bwrJ1hh0MBmqh0e/3tdOa56Am0ev1UC6XNaXA62YyGT0/iadcLmN3d9oAkEqlMBgM0Gg0VEex+onHFN92Anjvs4GRA178aeDDIYuroyQKAFhZWcHp06dx+vRprK2taeSYyWT09w+A6heZTAZra2sQEeTzeU07BUGg1Xp8L5fL6T783V02jpsstkXkzCyqOAOANokXANxp9rsDwMXZ9jsitnvc4LC2GvvtswhsRBEVLTBXb80B7SwJwlYk2cWe98mRpiQdPslzrjSjipWVFU0rRQ05WllZUd2DJGRtxJPJJHq9ns6nYA8GS23L5TLa7bYuIDwXYUt7PaZPnD/zFODNTwEebAL/+G+AR4+wOZ1P/kxPrq6uolgs4vbbb8fq6qoK0SyDLRaLczYdhUJBI+tsNotkMqmpKuoRw+EQq6urWFtbQzabnZu+SNuYZeO4yeL9AF4N4Odn//6R2f7bIvI2TAXupwH4lHNuLCJNEXk+gE8CeBWAXznme/Y4Itg0E5/ew09Eh0k7AZea2kgMDNGZq+c54/H4XBNdeEY274t/1ExDkUCsBQi9m7rd7twc6iAIMBqNUC6X9XjOl0ilUuh2u6jVakoKttGO6ajxeKwVS61WC6VSSa3GR6MRqtUqSqXSLV3yehgUE8C9zwJeegq49yLw/Q8BvSMKIJgqCoJAHxBSqRTW19dRLBZRLBb1/dXVVeTzeSQSCSSTSU0rBUGg1Xij0QjJZBKrq6tKFPxdXVtbQ6FQ0HQldTVGruPxGBsbG0fzwfbAMktnfwdTMfuEiFwA8LOYksR9IvJaAI8BeDkAOOc+LyL3AfgCgBGAH5xVQgHA63GpdPaD8OL2DYdwdZJtwLPkcNgeCy7ydhQpn97tdubwmTayYjb3ISHY+RE8P/8wqXkwpUQL70QigXQ6jd3dXZRKJa1WYUQRi8Wwu7ur1hvUEBg5lctlda5l8xyNANk3QWGcFVEeB+PLc8AfPgd4Sgb44b8F3v740ZyXugKjV6YnRQSnT59GPp/XBb9QKGBlZQXpdBqDwUDTpEyNcqQtyWNjY0P9vvjQs76+rhYf/Bvhgwwfjo6jGurA4Uc3Kvzwo2uLKLGaIHFYW4zDno9/JHaWBEVcW81kxWXbFc0nPJIC/2X5q/1j5TXZHU1Bm8OAOp0OSqWSLvSFQkGF8VQqpdEEm/XG47E6wNqogfOxWSrLiKNWq3n94QBs4DTyKKKNJkrYxHeeAt7zLKAzBl7+GeCvald3/kwmoyRAkgiCQCuWqC3k83msr6/P9U2Q8FOpFIrFovo6JRIJFan5O5vJZDTqXV1dRRAESCaT+iBj3QD4AMOijELhaKZKyGGHH3l4XCnC5aoW9mn+IKLYq7/CGvsB0KiBNee8B+t/RBGbXcycM02/Jl6HQjKbnagr0AmWRNFoNDRCYRc2cInE+FWv17WHgk+DNPwTEa2yomjdbreRSqV0Oh31EI9oJJHCOXwz0ggQQxwTjFFI9fCbX/EX+EJ7gO/6G+CJK+w/TCQSKiKzKimXy+kCHwQBNjY25oZTZTIZTTvagonbbrsNJ06c0DJaawjI3+l0Oq2/dyQgPvSwpJu/y6y0YpXfUbo07/nzWPoVPG4p2A5o/gLbxXOvvorwOaL6K/gEzhSTLW+l/QWjBO5nhxYxYqCWwFwv9280GhARFAoF5PN5jTIajYamkEgYrVYLyWQS3W53zjWWHbi0AymVStplTaJg7wadZAeDAR5//HG0Wi20Wi2vRxwCz8A9yCCL2KwTO4YYBqMY3vDX9+C9zU9hcIWJkyAItMfBlrHmcjkdPJRIJJDJZPR99thwMV9ZWVG7jtOnTysR2OiBEQILL/h7TJ8x+1BEgrAeZMdBEoQnC48jgS0zBS6lmCwpWK1iv/PYXgmrT9jZDgDm7L/5FEcC4B8UNYhOp6N/bFyUKSwyjcWcMe08+GTP9JItueVTH9NUw+EQuVxO3V5p+EczP9p98B4ZDdVqNWxtbWnJrcfhcBJnlSiIsYvj0cZZHGZCOHUiiscrKyvq18TU0sbGhnZT53I57XEQmc4TaTabSCQSyOVyavq3tram7rCpVGpu1C5To9Y1wArg/Pux2+3fVLiicNnls54sPK4Y4TQRiSA8F4JYxCzQkgX/ECzJ8CmMuX8rUDPk55MdNQE7WIieTiQTls7m83mkUin0ej3VGOjNRJM2mvgxBUFBmlFMpVLBzs4OxuOxkgTLHmkOyPkTg8EAtVrtlpxnfZTY+zdp8VJS2nzTwiWfz+PEiRM4ceKEEsbKyoou4nwQmkwm+jvC37H19XWcPXtWu7OpUQDQ0bRMJfE8LH1lmSz1i6joAli8pPyo4cnC41CIEq7tQKG9yMCmlQ46N1/bfXlePqVbU78wUQDQ0lZ2VQdBoMey29leh2mhRx99FFtbWwCgf7D0choMBsjlctr/UK1WVZPgtfr9vqYfSA4XLlzQBqzRaKSlrz6auDrEBTid20KpfQYTXIpWJ26CEjb3PZZVTFycU6kU1tbWcOrUKaTTae1/WF1dVR2MpEKrF6YQ2X2dyWRw9uxZFZrZcW29wRiZkHgYDfBviGmo49IhDgNPFh4HYhEbjrBOEcYiUYXVMywBUTTm9ZkusOZrANRFljYatVpNyYERiJ2MZz2fer0eLl68iEqloo1zLJNl/TwXjkajge3tbVQqFZRKJY1iOCWvVqvpnIjNzU2Nalj+6hvmrh4bSeB9Xwnck/9rfN/H19AaJZFAEiM3xAhD/C3+OvK4QqGgTW9cvNlIx4eR1dVVrK+vIwgCTUvlcjlNQyUSCbTbbUwmE6ytrSEIAq18YoksowW+JkmQoABoBM40Kr+uN5IgPFl47IlF7cDtkJ8oLBJV2D4MK2az8onbbQNdp9NRQ0CWwTabTVSrVS1Bzefz6pHE1JUtV+UiX61Wsbu7qx2x5XL5snvkfhcvXsSFCxfQbDYRBIESjx081Gg0tH/CRxBHi68uTP2dbksBP/BQDx8Y/hecwlnkZqWzO7iASci6IxaLabMc+2JisRiy2ax6MQ0GAzX8s0Rx8uRJrYpi02QQBCgWixoh5HI5rWzie7xGWNTmw1CYGK5XkiA8WXhcBttEd1DDnNUY9tpnUQtyu781AOQfERdl+ihR3I7FYhpJUFdglYpzTo35SBa8F6aqWq0W6vXp/AJqEPl8XtNXjFy2t7extbWFarWKXq+nHj8Uw/v9vrrAeiwH33sG+LWvAHYHwDfeDzzQAIAJthDdcceeBo4iZcoxm82qHrG6uqrpzJWVFRWic7mcEgUfOBKJBNbW1uYa5ZhWAi6lt0gGtrrpMGXj1yM8WXjMgUSxaFleVFRhF39b6bHXHIVwWoYlrnaCHctbeU674NfrdW1co/FeJpNBr9fTfgiK3sCUAJmq4khS3ne329WnTKaOOp2Oppyq1SpEBLlcDgBQKpVUDN/a2rpm4uPNjoQAv/B04EfuAv6/CvDdnwFK+xjpBkGAs2fP6rwIisVsnDt16hROnDiBQqGgXl8sXaVQzbQTf99Y2cRpdSQGRsJMOfF3jb0SV+JScD3Ck4WHwkYUhyWKvTq27eChvc5h36NRnx3/SaKw5at8r9lsqq7AyiNWInF+A11Z2b/Affh+IpFAv99Xu2+a9NEGvF6vo9/va/ktrT3o9cQKKo/l4FQK+L2vAl64Brz1EeCNDwPjiF8n6g+5XA4rKys4efIkRKYurSQIRgP0UWKTJhve+B6r4wDowwdTS/ZhhVb3TD8x3URzwePuhVgmPFl4KMJ9DPvBEktYb7ANeBTt9gP3pdBsIwBbMuuc045qCtmc25DL5VCv11Gv15FKpZRMWC5LoZwNebwmdYjHH39cq2JERImg1WppKSwJw1qMR2kbHkeH5xWB338OsJ4EvuezwPu25t/n0z6FZ9perK6u6hChYrGIXC6nGgTTRADUk4kd2BSj4/G4GvfZoVJ28Q9rEFabsz5ONws8WXgAOLiaiWD0wJSQ/YOJasDb7w+GGgKjABIFq4tosRFOadF0j1rCYDDQCIAWHayMYuWTdeektXi328X29jbq9bouIOzartfrmtbqdruo1+tz0YiPJpaP154FfvXLgSd6wNd/CvhMC2q9walzbIJLp9PaE8Meh5MnT2JlZUUfWthxzRJrahY08mPxRDqd1lGn7OS2Ja78nbYaBGEtZ242eLLwmEsn7SdS20XbmvhFgfuG3yeJ0LjPTn/jHzSf4JmO4h8ftQs2QAFAu93WXgeauVlnV16Hte4UsxlR0KIjk8mg1WppVRQjFhJRpVJR11kSpcfR4NlfnsIvveUkXvC1GbQ6E7zrt+pYe38Z//I08GelaUQRXz2BO9emEcDq6qpWIFGTAC4Ni2K0sbq6CgCqVVBrYpqJI035O0nNwc665jhT6m58bbUIi+Nwf71WuHk/mcdCsBPm7C++NQOMKn3l6yjRmikqaxtuLTtIEjyvTS0NBgOUy2Ukk0lNA7AhjhHIYDDAZDJR8XkwGGijVLVa1fQUtQ5GB/Rm4khT3tdkMvn/2zvzOLmu6s5/T+1Ld1V39a7dtixb3g2y8UKwALMYzBYviVgG8gGUmWHMFgZsyAwMMzAmBIYQSCYOw4QAZrfBA0xsTDAhxiDhBVuyLdmStbRaUu9rVXVtN39UnadbpequtqxWl6z7/Xz6o+7qelVXr1/d8872O+zbt89rtNP16YxrxRmJ48/K5QF+ddcKWuI+fD6hPennA+9uw39pkE//2SE+uTdAvDIXIhqNkkwmPSOhUhvT09PeRr5s2TK6u7urSlX1hkNLZ1XJ1VYgthVf1ZuwhwppONXWG4PqbuqTtcppoThjcQpTz1DYm7odj11o852+rp3P0K9ao2PnHdRTUYG+cDjsNbHl83kvNGX3Rmgprd7x7927l7GxMUZGRqpmZehYU+2D0PyI5i5GR0c9I6IJc8eJ4b3vaiMcFny+I5usP+wjd2Gc2wNt9PQlPBlwW3pDr0O/3+/NkNDGSQ016TWlOk5qKPT6U+9Bcx0qSKmGQkNM6vFq2TVU9w6d7FVOC8UZi1MU21DYP9uzJmoNgnoL891B2dIbtoFQ913v8guFArlczgs1ab5AH1fNHZV7tudp67o0nDU7O8vAwACTk5OeWJ+OKrVDVyoIqMlq9TByuRzZbJbDhw8v1ul2zMGlF4YJh46+8cjkhCte1Me2nW1eniKZTFaNGtXHW1tbPW9BpeL1Z51Qp1VS2vNgX8e28bBzFPWaQe1jTgUDYeOMxSmIbuRaEaRoQrqeEOBczXd2qEoTyXZJqhoIzSNoCAmO1LXryFM7rKSSDLpWDQvNzMx4XoLOgdAcw8zMjBd+0oomNQTaS6Gvof0XmqdwnFguaoXNy+HS8VnIRyFYfb1FwkI6100yWS5Z7enpIRqNVvUvqCKsGgPtzldZ8Pb2dq9bWxvram927BsQVSXWKjy9OdIbnoVU9j2fccbieUq9vgZbRtwOL9l9EPZdu426/fZdlmKHmjRUpOEffU81KPbMCU1caxe1buAaGx4dHfUkPNQL0ZGm2lSnpazT09OIiDfXemZmxjMmajC0H2N4eJiZmRmn0XSCafHDpl7YvAI2JCBTgp99N83LXpIkahmL2Rz8/olWxL+StWvbaGtr8wT/NKSkpbHapQ/lqjjVdbLF+rSstp6B0Gu/tpEUjnjXdmPpqYwzFs9D7PCP/UGw75Zq8xDqYtcqv+rv7YS1ovkNfU+VBNcPoD1cvlAoeCEqPVY3cDUSugYV27Oln3XKXDqd9mYHTE1NeTkInRExOzvrGSX1QETEmzw3ODh4wv4OpxLXX9vC5n+XJBIWvvmDKf7vtyfJVSYPbUiUvYhNfWWD8XjGz8cHk9w100oxmuDcjwgffW+B9WfmyeWEf32wj7v++UxWrChrNOk8a22MS6VSnpdhy7dAuTEvEolUDRrSCqX5DIR61HDEw7Y/D8+XxrrngjMWzyNqNZ1qw0a6idoXvhoBu9nIfp16Lridj9BZEmoI9Gf1GjTvoNPi/H6/ZyS0j0JfW0tgtYM6GAx6iWydWDc2NuYZJg0fjY+Pe8bElgJXw+J6IhaXv/lMF2+5LkFLvHz9XHRemLdd18rtN/Xz7mXCRa2GmSL8v8kYd8x2stPXRiAQpKW3PGwq3tbJbd+LIgLhcLlsta8vViW5YXsS9t1+JBKp2sxV1kNlN/R6tw2EfcNT613XSt0sRC35VGFJjIWI7AGmgCJQMMZsEJEU8B1gDbAHuNEYM1Z5/i3AOyvPf68x5u4lWHbTYt8l2d3T9kVuexS1x9UaCr3L15ATHAk/2SEnfcx+XI/X99ONXsNTxWKRoaEhL9wUjUZJp9MMDAwwMTHh5Rt0LXp8bVnr2NiYZ1hU60nzImo8pqenT/Bf4tRj3RlB3nZDglj0yHUVj/m47PwwV2yKs+3+Wf58qI1fmB6y/jCR1gh9iQQdHR10dXXR0dHhNURq6DIcDtPd3U13d7cn7Kebv27qwWCQSCRSVfVkl8ra4n21BmKuJtJ6hgKaXw32RLGUnsVLjTHD1s83Az83xtwqIjdXfv6IiJwD/DFwLrAMuFdE1hljXMCZ6pCTrZ2kP9f7EED9D4fd/1Cb2NPf6+/07k6rRjRHoKEjDVFpYlq9j5GREa+pSfsbRkdHmZyc9N5PdaD0tcbGxrzkdTab9QQA1YsoFouMjIx4yrGOE8dLLotST/ZLoj7uXtvLLXe3EIuVq5A6KiEkNQSJRALAGyCkBRF9fX20t7d7XdS2xpImt+2eB/1S7PnWc5W41vOeoTpn58JP1TRTGOoNwMbK918D7gM+Unn828aYWeAZEXkauBR4YAnW2DTUhpzq3Q3Zz5nLUKgXoklnqYij2b0WqsqpRsJ250ulkhdS0hyBNjqJiPezrank9/sZGhpiZGTEm/+gG4AK+eXzeWZmZpieniafz3vGYWhoyEtO+/1+T7bDceKJxWIUSi2IOTpEk8vBgXSCVKo8HKirq8v7skX8fL7yTAnNL2ivhMqJ64atEh52T4R6Efa1bRuFuQyEbRzsz05tU6oLP1WzVMbCAPeIiAH+zhhzG9BjjDkIYIw5KCLdlecuB35jHdtfeeyUpZ43AdV3Q7aHYVdx2A1z9p28br6q619bV26/phoSVXIdHx/3Gtn0DlFDUNls1lNt1WY69RL09ROJBIVCgYmJCUZGRhgdHfUqoLTiSZPZrmFu6VFdpra2Nk4bGCNaKmFKPsRqrCsZ4YGHe1m9upeOjg5P0E/nmReLReLxOK2trV7DnHoHiUTCu0HRJjztptbrz56fXovdbQ0LH+Llrd2Fn+qyVMbiSmPMQMUg/ExEnpznufX+onX1rkVkM7AZYNWqVc99lU3GXN6EYt8N2XkDzUHoJg/VnodWLhljqqqP7IS2GhD9wGYyGSYnJ73mORHxul41TKRGws49aC4kGAx6uYtsNsvBgwdJp9NMTEwwNDTkeSyax9DNw7F0JJNJVq5cWZ4uF4/ynsAzvJF97Li1k9QHO4nFDcaAMcJXv7+eRPsa2tvbSSaTVbOro9GoN0tCq5rs0JH2SmhSG6pvcux8BFC18esNkl0WXc/LmAsXfpqbJTEWxpiByr+DInIn5bDSYRHpq3gVfYDWOPYDK63DVwADc7zubcBtABs2bHheTaHRTb2ekdDfQ/mDoR3UtndhVy+pBr9ddqi6RxqW0tfIZDJV710oFJiamvLCQjpYSD2S6elpBgYGvONU/VWrmuzGuqmpKc8rUaPT39/vzc52BqI5aG9vp7e318sjpCTPf5HHOLc0wo9Da/lO+oWE/1ecM08r4vcV2H8oid8fpq2tzdNwSiaTpFIpL8RkazfpBq3aX1oiG4/HvZsevQY17GTnIuyQ6FwhqIVif44c1ZxwYyEiccBnjJmqfP9K4JPAXcDbgVsr//6ocshdwO0i8nnKCe4zgS0net1LRW3eod5FbLvZtiqqJp/tMJJd6mpXQ6lXoOWsdnmiVpvYISX1DuwP8/j4OPv27WNgYIDZ2Vkv5KBVTGpgNMSknoTOm3A9EM2FiLB27VpSqZTnBZwtk3xkdgstpRxf6Xwpj6TOobuSdJ5MlzfxaLREIpFg2bJlnlR4e3s74XCYSCTiVTHZ4VC9zlS+w+7+V8/D9kBs7M9Hvd8vFBd+mp+l8Cx6gDsrf9AAcLsx5p9EZCvwXRF5J7APuAHAGLNdRL4LPA4UgPecCpVQjUJO9vPsLzUCtqGoLXm1E9x2l+rk5KRXimo31dkd03qc5hA0b5HNZtm/fz+Dg4Oe3LgqyNqhLfVKxsbGvBJXleJwNA/d3d2cddZZVeGjV5l+3j65hclgC18+43oGW5fRXhF9bGlpIRwOk8lkCIVCdHZ2kkqlSKVSJJNJT6tJrzX1btXbVRXYWtl7e7b1XHL39cq/ny21peeOo5FjObEnAxs2bDC/+93vlnoZx4xd/jrfxategn5QNNegd2Z2SKpWusDOU0xOTnoD6VV3STd8ewjR7OysN4taQ1AzMzMMDAx4M6jtKiu7qU7nQkxPT7smuSZCrwXtfm5ra6Ozs5OOjg6MMbS3xPiTzCNcNf0kO1tX8/0zr6MQS3p9Mi0tLVWGoLe3l66uLk+8r1Zuo/ZGyO6HUMNhl2fXu1laiMf9bJnvpuxUQkQeNMZsqH28mUpnHRUW8iFQQ6BVTFp9pK64dlSrYdD51PqBLJWOyHTrhu7z+bzKIzvZqGWs2gg3OTkJlFU6R0dHOXDgAKOjo5UQRLQq1DQ8POwpumpfhGPpiUQinhCfjhLVXILOko7FYqyI+njXwbtZNd3P7854Ob9Z/zpSobCnuRSPxwmFQlWFCz09PYRCIU/kr7YqSfsj7EY63ajtAUP6vHqFHFBfGdmxeDhj0WTYrnk9Q6F3VJor0LuwXC7n5Ra0ekg/gDqGVMth9XgNWWkzXSaT8RLNY2NjXhOceh0q7a2vkU6nOXz4MJOTk14Y4eDBgwwMDHhifW5gUPOg6q0q260jSVtaWkiWAxDuAAAaFklEQVQmkyzvLdGezDI42kbJJFhfHOF1v/9HgoVZHr72o4yefRXr/X5aWlpobW31ChtqmzjD4bD3pdjerBqEWrlvvd7nKuZYDG/CsXCcsWgi5oub2hUj+r12tqq6qyav1eOoTXrbH0Z7pKnKaYyPjzM1NcWhQ4cYGhqiWCwyNTXlNb3pe6lK7Pj4uDc/QHskXHip+UilUvT09NDd3e01ven0uEQiQXdXnE2v+VeWdw9RLPkJ+IsceqiDFV/6DZlkD9s2fYl09+mkwmEv0a1GQvMPGjYNh8NVd/zqbSh2ErredT6XoWhUDehYfJyxaCJq47O1yWv9PRyp2FDDoMcDnhegCW84IoGgHoV6DZlMhnQ6zeDgIGNjY0xMTNDf308mkyEcDntGRRvsVKNpdnaWqakpb47E1NTUiT5djgYkEgm6u7vp6+ujq6vLyw9oQjqRSJBIJLj+Ff/Cip4hAv4iQcrX0orzD5G+7gJ2n/cF/C1tdFdyExritHseTEW+xS5rrRWeVE+iXhOpTb1ktfMmmgNnLJqEWj0n24Owa8rtenK7H0INgcpqFItFIpFI1UjIbDbL7OysZyB0kz906BATExNeAtrusdCk9tTUFMPDw2QyGYrFIuPj406or8nQMGQsFqOvr49ly5Z5ndP5fJ5IJOJ1S3d0dJQnzcWFNcv24PfVFBhGfPiuSRKY6vQS1CrUqNeUbt62uqsaBi2wsHMRtpGYC9sgOG+iuXDGogmwK0P0Tn6uD4h+WH2+I2NI1VBoR7UOndcPqW72OtNBBwKNjo5y6NAhxsbGyGQyXre0ynEATE5OMjExwfj4uDczwrH0tLa2kkgkvJGiKp2hd/Xa/awd0h0dHV6+QhVb4/E4LWYAKRmosxcHAmkSiYTXTxMIBIhGo174Uz0VW8RPr081DsfS9+C8iebEGYslxvYebC0nY8xR1UMq9Ke/m52d9RLYqqGkrv7o6CgTExOeoqtOmtOpcePj4wwNDTE9Pe2NOtWZ1CMjI0xPT3tehKN56Ojo8Epbg8Ggl2hOJpNVMx00t9DW1kZXV5fXEe3z+YhGInQd3kH3vT+i7dGfwV8uh1T1VmCMjxyXEAgEvBJpvQHRu/161Ui213Es3oDtTbieh+bCGYslRHMKxWLR+3BpTHhycrJqqpyGhjScpKWuIuJNm9Py2L179/LEE094uYbZ2VnPSJRKJS9prWWxWuKqwn2O54YIHGv7Ur1jRYRVq1YRi8Xo7u721FdbWlq8EJE+5vcJgWCISCRCR0eHJ/onIsTyaVY/9Uu6H7yLyOAzFCMtTF5xA/n0BbS3fx0hh4jBmCBGImRlMz7xEYlECIfD3k2NGgSb2vyDffPz7M+BCzs1I85YLBGaCwCq4r8qqZFOp727OrvzWj0KjRXr9DidFbF792727dvH5OQkoVDIq3hSg6PHa8+E9kQ4nhvBIHz6o51sfluSWFR4eNssN90yxG8fWlhvyaoVAb58azevvCpGycCP/mmaj346S6xlhSeVEY/HSaVSnnprIpHwQpJrVx3mJS/4FW0tY+TyIZ4eeDFjuT8gEo7Svv/3dG39IcnHfo4UcuTWvpDJN76fwhVvohSKYkolJrmSqPk2PrOfov8F5INvJhzo8UT7dOO3vYnaDurj4Qk4b6J5cR3cJxjd+LVKSeO/tqSGLcKnnoaWxGqZrGoxHTx4kKmpKSYmJnjqqacYHx9ncnLSMzaKeiTpdJqDBw96jXWO48M3/7aX178qXjUxbnqmxCWv2sfOXfl5j41FhZ0PrKGrw0cgoFVucGg4wIc+dTaBYNhLWqtukjbC+f1+VvSMcM1l3yYQONLTUiyFyD61nNBtOwgP7aUUS5K58nrSG99CadU5VZu8dlDb3q2di6hNWtcWXbgN/vmF6+BeYmzvwM5NlEolL0ykoSHV6w+Hw56ByOfz5PN5r9ppdHSUgYEBL6SkjXCazM7n88Tjca+qaXBwkKGhoSU+C89P+nr8vOHVcaKR6tBJJCx8/v3tfOHj1QKJoVCQYCAIApFwhJe9LkZ7q59A4MiGGwxCT6rEu1+cZWwgRaojRcBfQnyTmJKBXLmnIRQMsfas+/D7q5sf/b4c8TW7yHV1M/bGD5K99Fp8kXg5VFXZ3NUo2GEfe+PXQgtNUtfKfrtQ0amFMxaLjG0g7LsyLTPUoUAqzFcqlYhGo96oUJ0zreEm7bLW6qSxsTGvGS6bzTI8POzlQbT6yTXKLS5rTwtSzBmIVD8eCAjXvCDMa19Ye0S+8gWQpnSeD2LRo1435CvwiuIDyCPz//1KV6wBOXoQUCkYZfw//xWB8JnErRnWcyWn4Uh+TK9RO+TkvIhTG2csFgm7B0Lv0OwPnJahauhJE9bGGAYHB9m+fTu7du3yRpZqxZImrLWiaXx8nOHhYa/s1XHi6AjC25fBv0/laYkcvYEW8oYf/zbL57ZAT093laheLBbzVFkvimS5OP8YgWB1QjhvgmxbfiPTb1yN3+8nFAoRDoe919A7/s7Q7YTMkxy1hwsEgis9+Xkts9YblXrYasTzdVo7Tj2csVgEamUyNHmtXoYmmjOZjKfJNDMzw/DwMPv27WPbtm3s3LmTwcFBzyvR+dS5XM6T9nYsDRvbYfMK+MNuCPvg10NFDt09zcUvbyEWO3K3npk1fOprhpnes5DOTm+zTyaTBHp6yCSTjMVi/HJ/jnWzO2nxZfD7K6Nuiz7S+Q4OxK4h1tlCMBbDFwphAgFywSClymYeCAQY83XQzQcRjvTAlIhQCL2Zlnhnld5Yo9BRrcCfw6G4BPdxRKuV9C7f5yuXHaqh0CR1Op2mUCgwPj7OgQMH2L9/PwMDA+zZs4cdO3bwzDPPnLQzHhK0s5qziNPKOCPsZQcZFj43u4eVrOQM/AQ4xH728zQlFlaC6SfAKtbSzQry5OnnaQY5sOD3XndGkJvfm+KFF4TZ9mSOz/z1KI8+Xp7W1xWEdyyDd6+AM2Mwlod/PAh/3w/bZ8Dvh4+9P8V7/qSNRKuPBx8r8nff6GAivYzOzk7i8bgn3Nfa2kpLS4un2WWMIR5Ns3HDrzlt2R6MEcYzlzE8+24Cwfaq4VShUOioslUAX/Fh4uaLBNiFkTZ88XdB7B1eIto1tzkWylwJbmcsjhPFYtGb+qbdrvF4HMDLTWQyGcbHxxkbG2P37t3s2LGDffv2MTMzw4EDB9i9ezczMwvfWJuNDnq5gMvwUb4rLZkSJYps4Z9J07g892wuppfVBKS8GRZNgTTTbOGfMdQPmyh+/LyIqwkTwy9lTaKCKdDP0zzNtobvffH5Ye67cwWRMAQCPopFQ3bW8In/OMBlBzO8sQuCPtiajfK96ST3zrZhQpGqRrhoNOoZgtWrV7Nq1SrvRkElvVXt1ZbptsNLoVDImwOhXqXOeFCDofmvetLempCGhUndOxy1uGqoRUK9idHRUbLZbLlDNhqt0vifmppi//79XrPc7t27GRwc9IT4Dh8+XHek6Omnn87s7CwHDiz87ngpOZsX4Jcjl5RPfAhwFufxuDww77ERE6ePNfjxe4/5JUCUOMtZwZDsm/f4PrOGMNGq4wMSYBVncoinyMv8MiVf+GQnLfEjIRq/X4jHhM/+jy4mbz7AnaVeflpazqFYO6G2EOtiMWKxGNFo1Ms9dHR0eHOmC4UCAwMDlEqlqu5pnQGh40VVv0u1ldQAaCl1sDKJTmeZl0olL/xkGwgbp6nkWAycsXgOaK/D6OgoxWKRWCzmdbpms1l+/vOf88gjj7B9+3b6+/sZGRnxBPyi0WjDbundu3efoP/JcydIiLCEj3pc8LE60MVDG+c//mcDHfz1jhKZor/q8QBB3tPbw83nzW8sPvZwL1tGjr6cW/wl7j43xRXdB+c9vvTCSP3Hl4W4PreBcGsH0WiU07q66Ovro62tzZPS6Onp8RrlSqUSe/fuZdu2bQSDQTo6Oryxou3t7d73uolr/4Ju+sYYT+AxEAh4RkST09okN5dyqws7ORYLZyyOEVtDyQ45/fSnP+V973tfw6a355OsxtoYvHNZgX/ZDfk6Uc08s9z81PyvMZGZZbZupKnI9nS64fF7Z9NAiVpFvGwJbh+c5a6J+Y+/ZbJEa8fRd+GZLOQIEq14BWrkNfc0PDzMzp07KRaL3nCoyclJEokEZ599Np2VxHYikSAcDns3C7aRsDHGkMlkiEQi3phTW5a+kafgqpcci4UzFs+SUqnEyMgIg4ODFAoFwuEwW7Zs4a1vfetSL+2EEhJ4U3e5KuhlKSiUShwY3ceTYyuxL6uCKfB4fgc/2TP/6wmDXEmBEH58cmRDLBrDDyb2kGmw2cfZxaWsxm8dWzIlZkyWLx8cbfj/Kf7NGP/1zzqIW9VMszlh67Yz2LjxElKplFfarPkJoKq0GSAej7N27VrOO+88UqmUl6+wu59rw0e1XdGpVIpkMuk1bbqQkqMZcMaiDsYYyD+Cmf0FSByJXov4l3uJ6NHRUXbt2jWngQgG4U3XtHDx+WGefibPt384xUx64YUEnR1+Nr2plb4eP7/8dYZ77ks/K2G6c88Kcd21LRgD3//xNE/szC34WJ8PXrUxxh9cHuXAwQLfunOK0bEjt/xnxcoVQW/vg84Q7E7DLU/BPwzAYO5hziVAJ8soUcSHn/08zQB7Gr6vwfAgv+QiriBiYhgMJUpsZ+uCqqlmmGQ7W1lvXohQTvK2dse46h0X86LMeiYmJojFYnR1ddHa2ko6nSadTpPL5SozqKPsPvgo69dsx5gAfn8Rwldz7qUfZu1FRxLKoVCIQqHgybKICLFYjNbWVq/iSb0G7XtRFWHtX4Aj4SI7hFQ7YtQZCkczcdJUQ4nIq4G/AvzAV4wxt873/GOthjLGYCZuhuw/AVnK9tTHaPFDPL7rNK666qp5j0+1+3jgJyvp6fLT2uInkxUymRKXvWYvu/Y0bpq78tIIP/nmcvx+iEV9TE2XeOjRLK/eNEAu1/hv9bEPtHPzTSmCFemIfMHwyc+N8tkvjzU8NhwW7v3ecs5fH6a1xUc6XaJYgtdtOsCq/iybV8BL2iFfgh8OwW398PNRqF1ViDAdLd2cu+Es7r3v3obvq5xzzjlceOGF9CaWs7x3OadfsJo77ryDp556ikcffdSb3qeNY+FwmHXr1nH55Zdz1VVXcdZZZ9GWbGfomRFS3e2MpIe45557yGazhEIh+vr6qjbtrkr+obe31ytKCPrTSGk/xreM8UkfMzMziIgn+qj9LVr5pBLhtWEfnTVSq7tUzzjo9zbOUDiWipO6dFZE/MBO4BVAP7AV2GSMeXyuY47ZWMz+EjP+PjDVfQ7pTIllFzzD1HT9Es5EIsHrX/96PnpTljNXbsMnR3oDikXD/VuzvPRN/fO+d2dnBzvu76EtUW1UZtIlbvnUMF/+6vyxmLduupyv/MUYwUB1X0ImU+LCl+2b11hde+21fOSmLl503m/x+6qfVxrO4//gHnalywbiawdh0HJWPvzhD3PNNdewevVqEokEoVCInTt3smHDUddbFTfccANvectbWL9+Pd3d3V7Vj4jwve99j02bNlU9PxQK0d7ezrnnnsuNN97I1VdfTU9PjzcT2uaOO+7gW9/6FqVSiRUrVrB27VoSiQR9fX2sXLmSnp4er1S1djMuFArs37+fw4cPeyNDo9Eo0WjUG0VqJ5lryefzZDKZqqol2yg0yinYTXQu9+A40ZzsxuJy4BPGmFdVfr4FwBjzP+c65liNRWn8Q5C966jHCzNF9nzxMOO/mT8kctE3TifQ6j/qcVMwPLxpF6V5vIPo6hBnf2Yl/ujRd5IzT2V54kP7533v3uvaWfbmDnyBmrvUXIkD3xjh8I/m1xg6569WEVtzdEVTIVPi3dfv4+sP5Y/yIk4kyWSSdevWVSV96zE6OsrMzAxtbW2cf/75Xs9DX1+fV100H4cOHSrLaHR20tfX502kCwaP1l+qRy6X88abqhFbaNLZVTM5lpqTvc9iOWDvlP3Ai2qfJCKbgc0Aq1atOrZ3kgAg1AZXDDCRg+EGkaQ5JHcwwHAOSvMc35I7OqSj5Ium4Xu3FnSzqd5kjIHpfOO1F4r1333WwK/H5l7bYnLllVce5TU0IpVKsW7dOl772tce03XQ29vLmjVr6OrqOqYNOxQKEY/Hj+lYV83kaFZOFs/iBuBVxph3VX5+G3CpMeamuY459jDUbzFjm4FMzSJiSPcDiBytDmpTmvzvkP4OYCeV/RC6HF/qq/O/tzGYoZdBqbYJL4okPobEbpz/+MI+zPBrgdoGtDDSdQ/i75t/7TPfgKnPctT/3b8G6bzbbWAOxynAXJ7FyZI56wdWWj+vAAYW440k/CKIbQLCQAgkCkSRti82NBQA0vIBCJwJEgOCIHHw9SDJTzc+VgRp/zJIonwcQSAK4RdD9LrGxwdWQevNlbVHKl9hSPx5Q0MBILE/hvBl5ffUtUsSafuSMxQOxynOyeJZBCgnuF8OHKCc4H6zMWb7XMc8V20oU9gNs78qb/qRVyC+toUfa0qQ+w0UngT/KghfhdSZNzD38RnI3gulIQhdggTPf3ZrLx4qHy8C4Zcj/t5n8d4G8o9C/kHwdUPkakTqdzc7HI7nHyd1ghtARF4DfIFy6exXjTGfmu/5zTpW1eFwOJqZkz3BjTHmp8BPl3odDofDcSpysuQsHA6Hw7GEOGPhcDgcjoY4Y+FwOByOhjhj4XA4HI6GOGPhcDgcjoY4Y+FwOByOhjhj4XA4HI6GnDRNec8WERkC9h6Hl+oEho/D65wI3FoXB7fWxcGtdfF4LutdbYzpqn3weWssjhci8rt63YzNiFvr4uDWuji4tS4ei7FeF4ZyOBwOR0OcsXA4HA5HQ5yxaMxtS72AZ4Fb6+Lg1ro4uLUuHsd9vS5n4XA4HI6GOM/C4XA4HA1xxsLhcDgcDXHGYg5E5NUiskNEnhaRm5d6PY0QkT0i8piIPCIiTTX1SUS+KiKDIrLNeiwlIj8Tkacq/7Yv5RqVOdb6CRE5UDm3j1QGcS05IrJSRH4hIk+IyHYReV/l8aY7t/OstenOrYhERGSLiPy+stb/Vnm8Gc/rXGs97ufV5SzqICJ+ymNcX0F5/vdWYJMx5vElXdg8iMgeYIMxpukah0TkJcA08I/GmPMqj/0FMGqMubVijNuNMR9ZynVW1lVvrZ8Apo0xf7mUa6tFRPqAPmPMQyLSCjwIvBF4B012budZ64002bmV8sD5uDFmWsrzkP8VeB/whzTfeZ1rra/mOJ9X51nU51LgaWPMbmNMDvg28IYlXtNJizHmX4DRmoffAHyt8v3XKG8cS84ca21KjDEHjTEPVb6fAp4AltOE53aetTYdpsx05cdg5cvQnOd1rrUed5yxqM9yYL/1cz9NemFbGOAeEXlQRDYv9WIWQI8x5iCUNxKge4nX04j/JCKPVsJUSx5+qEVE1gAXA7+lyc9tzVqhCc+tiPhF5BFgEPiZMaZpz+sca4XjfF6dsaiP1Hms2eN1VxpjXgBcA7ynEk5xHB/+FjgDuAg4CHxuaZdTjYi0AD8A3m+MmVzq9cxHnbU25bk1xhSNMRcBK4BLReS8pV7TXMyx1uN+Xp2xqE8/sNL6eQUwsERrWRDGmIHKv4PAnZRDac3M4UocW+PZg0u8njkxxhyufCBLwN/TROe2Eqf+AfBNY8wdlYeb8tzWW2szn1sAY8w4cB/lHEBTnlfFXutinFdnLOqzFThTRE4TkRDwx8BdS7ymORGReCVpiIjEgVcC2+Y/asm5C3h75fu3Az9awrXMi24QFd5Ek5zbSnLz/wBPGGM+b/2q6c7tXGttxnMrIl0i0lb5PgpcDTxJc57XumtdjPPqqqHmoFJq9gXAD3zVGPOpJV7SnIjI6ZS9CYAAcHszrVdEvgVspCybfBj4OPBD4LvAKmAfcIMxZskTy3OsdSNld94Ae4A/1dj1UiIiLwZ+BTwGlCoPf5RyLqCpzu08a91Ek51bEbmAcgLbT/mG+rvGmE+KSAfNd17nWuvXOc7n1RkLh8PhcDTEhaEcDofD0RBnLBwOh8PREGcsHA6Hw9EQZywcDofD0RBnLBwOh8PREGcsHI55EJFiRbVze0XZ84Mi4qv8boOIfHGeY9eIyJtP3GodjsXDlc46HPMgItPGmJbK993A7cD9xpiPL+DYjcCHjDHXLu4qHY7Fx3kWDscCqUipbKYs0CYislFEfgwgIldZswMernTU3wr8QeWxD1Q8jV+JyEOVrysqx24UkftE5Psi8qSIfLPS8YyIXCIiv654NVtEpLUiHPdZEdlaEYr706U6J45Th8BSL8DhOJkwxuyuhKFqFUc/BLzHGHN/RSwvC9yM5VmISAx4hTEmKyJnAt8CNlSOvxg4l7IG2f3AlSKyBfgO8EfGmK0ikgAywDuBCWPMJSISBu4XkXuMMc8s5v/dcWrjjIXD8eypp0p8P/B5EfkmcIcxpr/iHNgEgS+JyEVAEVhn/W6LMaYfoCI3vQaYAA4aY7YCqKKsiLwSuEBErq8cmwTOBJyxcCwazlg4HM+Cig5XkbLi6Hp9vDI97SfAa4DfiMjVdQ7/AGW9qQsph4Cz1u9mre+LlD+bQn1pfAFuMsbc/Rz+Kw7Hs8LlLByOBSIiXcD/Br5kaipDROQMY8xjxpjPAL8DzgamgFbraUnKnkIJeBtl8bf5eBJYJiKXVN6jVUQCwN3Af6hIfiMi6ypqww7HouE8C4djfqKVsFAQKABfBz5f53nvF5GXUvYKHgf+P2V11YKI/B74B+BvgB+IyA3AL4CZ+d7YGJMTkT8C/roiP52hLEH9FcphqocqifAhmmDEp+P5jSuddTgcDkdDXBjK4XA4HA1xxsLhcDgcDXHGwuFwOBwNccbC4XA4HA1xxsLhcDgcDXHGwuFwOBwNccbC4XA4HA35N//U1tIFxXtTAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -550,9 +520,25 @@ } ], "source": [ - "plt.plot(*ripley.k_function(points, support=20))\n", - "plt.plot(kp1.d, kp1.ev)\n", - "plt.plot(kp1.d, kp1.k)" + "plt.plot(k_test.support, k_test.simulations.T, color='k', alpha=.01)\n", + "plt.plot(k_test.support, k_test.statistic, color='orangered')\n", + "\n", + "plt.scatter(k_test.support, k_test.statistic, \n", + " cmap='viridis', c=k_test.pvalue < .05,\n", + " zorder=4 # make sure they plot on top\n", + " )\n", + "\n", + "plt.xlabel('Distance')\n", + "plt.ylabel('K Function')\n", + "plt.title('K Function Plot')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can see that the envelopes are generally above the observed function, meaining that our point pattern is dispersed. We can draw this conclusion because the distances are *too small*, suggesting the pattern is less clustered than otherwise woudl be expected. When points are too regular, their distances tend to be smaller than if they were distributed randomly. " ] }, { @@ -561,51 +547,30 @@ "source": [ "#### $L$ function - \"interevent\"\n", "\n", - "$L$ function is a scaled version of $K$ function, defined as:\n", - "$$L(d) = \\sqrt{\\frac{K(d)}{\\pi}}-d$$" + "The $L$ function is a scaled version of $K$ function, defined in order to assist with interpretation. The expected value of the $K(d)$ function *increases* with $d$; this makes sense, since the number of pairs of points closer than $d$ will increase as $d$ increases. So, we can define a normalization of $K$ that *removes* this increase as $d$ increases. \n", + "\n", + "$$L(d) = \\sqrt{\\frac{K(d)}{\\pi}}-d$$\n", + "\n", + "For a pattern that is spatially random, $L(d)$ is $0$ at all $d$ values. So, we can use this standardization to make it easier to visualize the results of the $K$ function:" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "lp1 = L(pp)\n", - "lp1.plot()" + "l_test = ripley.l_test(points, keep_simulations=True)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -617,170 +582,81 @@ } ], "source": [ - "plt.plot(*ripley.l_function(points, support=20, linearized=True))\n", - "plt.plot(lp1.d, lp1.l)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simulation Envelopes\n", + "plt.plot(l_test.support, l_test.simulations.T, color='k', alpha=.01)\n", + "plt.plot(l_test.support, l_test.statistic, color='orangered')\n", + "\n", + "plt.scatter(l_test.support, l_test.statistic, \n", + " cmap='viridis', c=l_test.pvalue < .05,\n", + " zorder=4 # make sure they plot on top\n", + " )\n", "\n", - "A [Simulation envelope](http://www.esajournals.org/doi/pdf/10.1890/13-2042.1) is a computer intensive technique for inferring whether an observed pattern significantly deviates from what would be expected under a specific process. Here, we always use CSR as the benchmark. In order to construct a simulation envelope for a given function, we need to simulate CSR a lot of times, say $1000$ times. Then, we can calculate the function for each simulated point pattern. For every distance $d$, we sort the function values of the $1000$ simulated point patterns. Given a confidence level, say $95\\%$, we can acquire the $25$th and $975$th value for every distance $d$. Thus, a simulation envelope is constructed. " + "plt.xlabel('Distance')\n", + "plt.ylabel('K Function')\n", + "plt.title('K Function Plot')\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Simulation Envelope for G function\n", + "## CSR Example\n", "\n", - "**Genv** class in pysal." + "In this example, we are going to generate a point pattern as the \"observed\" point pattern. This ensures that the data generating process is completely spatially random. Then, we will simulate CSR in the same domain for 100 times and construct evaluate the ripley functions for these simulations. " ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "realizations = PoissonPointProcess(pp.window, pp.n, 100, asPP=True) # simulate CSR 100 times\n", - "genv = Genv(pp, intervals=20, realizations=realizations) # call Genv to generate simulation envelope\n", - "genv" + "import geopandas\n", + "df = geopandas.read_file(ps.examples.get_path(\"vautm17n.shp\"))\n", + "state = df.geometry.cascaded_union" ] }, { - "cell_type": "code", - "execution_count": 15, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0. , 0. ],\n", - " [ 1.73156208, 0. ],\n", - " [ 3.46312417, 0. ],\n", - " [ 5.19468625, 0. ],\n", - " [ 6.92624834, 0. ],\n", - " [ 8.65781042, 0. ],\n", - " [10.3893725 , 0.16666667],\n", - " [12.12093459, 0.16666667],\n", - " [13.85249667, 0.16666667],\n", - " [15.58405875, 0.16666667],\n", - " [17.31562084, 0.25 ],\n", - " [19.04718292, 0.25 ],\n", - " [20.77874501, 0.25 ],\n", - " [22.51030709, 0.58333333],\n", - " [24.24186917, 0.58333333],\n", - " [25.97343126, 0.83333333],\n", - " [27.70499334, 0.83333333],\n", - " [29.43655542, 0.83333333],\n", - " [31.16811751, 0.91666667],\n", - " [32.89967959, 0.91666667],\n", - " [34.63124168, 1. ],\n", - " [36.36280376, 1. ]])" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "genv.observed " + "Generate the point pattern **pp** (size 100) from CSR as the \"observed\" point pattern." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 36, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "genv.plot()" + "pattern = ripley.simulate(state, size=100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In the above figure, **LB** and **UB** comprise the simulation envelope. **CSR** is the mean function calculated from the simulated data. **G** is the function estimated from the observed point pattern. It is well below the simulation envelope. We can infer that the underlying point process is a regular one." + "before we go any further, let's visualize these simulated values:" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "GtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", - " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", - " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0. , 0. , 0. , 0. ,\n", - " 0.16666667, 0.16666667, 0.16666667, 0.16666667, 0.25 ,\n", - " 0.25 , 0.25 , 0.41666667, 0.58333333, 0.75 ,\n", - " 0.83333333, 0.83333333, 0.91666667, 0.91666667, 1. ]), pvalue=array([0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 1.097e-01,\n", - " 4.070e-02, 1.130e-02, 2.700e-03, 5.100e-03, 4.000e-04, 1.000e-04,\n", - " 1.000e-04, 1.800e-03, 1.960e-02, 4.800e-02, 2.120e-02, 6.490e-02,\n", - " 2.500e-02, 0.000e+00]), replications=array([[0. , 0. , 0. , ..., 1. , 1. ,\n", - " 1. ],\n", - " [0. , 0. , 0.16666667, ..., 0.91666667, 1. ,\n", - " 1. ],\n", - " [0. , 0.16666667, 0.33333333, ..., 1. , 1. ,\n", - " 1. ],\n", - " ...,\n", - " [0. , 0. , 0. , ..., 1. , 1. ,\n", - " 1. ],\n", - " [0. , 0. , 0. , ..., 1. , 1. ,\n", - " 1. ],\n", - " [0. , 0.18181818, 0.18181818, ..., 0.90909091, 0.90909091,\n", - " 1. ]]))" + "" ] }, - "execution_count": 17, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" - } - ], - "source": [ - "g_test = ripley.g_test(points, keep_replications=True)\n", - "g_test" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -792,12 +668,8 @@ } ], "source": [ - "plt.fill_between(g_test.support, \n", - " *np.percentile(g_test.replications, \n", - " q=(2.5, 97.5), axis=0),\n", - " color='grey', alpha=.2, label='95% CI')\n", - "plt.plot(g_test.support, g_test.statistic, color='orangered', label='Observed')\n", - "plt.legend()\n", + "df.plot()\n", + "plt.scatter(*pattern.T, color='orangered', marker='.')\n", "plt.show()" ] }, @@ -805,120 +677,60 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Simulation Envelope for F function\n", - "\n", - "**Fenv** class in pysal." + "And, let's check if there are 100 points:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "(100, 2)" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "fenv = Fenv(pp, intervals=20, realizations=realizations)\n", - "fenv.plot()" + "pattern.shape" ] }, { - "cell_type": "code", - "execution_count": 20, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "FtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", - " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", - " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([0. , 0.016, 0.06 , 0.117, 0.205, 0.303, 0.426, 0.558, 0.701,\n", - " 0.809, 0.881, 0.941, 0.974, 0.997, 1. , 1. , 1. , 1. ,\n", - " 1. , 1. ]), pvalue=array([0. , 0.4534, 0.3764, 0.1065, 0.193 , 0.2546, 0.4801, 0.2192,\n", - " 0.0436, 0.016 , 0.0133, 0.0077, 0.0072, 0.002 , 0.0033, 0.0174,\n", - " 0.0567, 0.1236, 0.2276, 0. ]), replications=array([[0. , 0.01911469, 0.06136821, ..., 0.98591549, 0.99295775,\n", - " 1. ],\n", - " [0. , 0.017294 , 0.0671414 , ..., 0.98168871, 0.99186165,\n", - " 1. ],\n", - " [0. , 0.01306533, 0.05829146, ..., 0.99296482, 0.99798995,\n", - " 1. ],\n", - " ...,\n", - " [0. , 0.01838611, 0.06945863, ..., 0.97957099, 0.98876404,\n", - " 1. ],\n", - " [0. , 0.01799775, 0.06974128, ..., 0.95500562, 0.98312711,\n", - " 1. ],\n", - " [0. , 0.02002002, 0.06406406, ..., 0.98598599, 0.995996 ,\n", - " 1. ]]))" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "f_test = ripley.f_test(points, keep_replications=True)\n", - "f_test" + "Yep! So, next to simulate a set of realizations in the same manner, we can use the `size` argument again, just like the `numpy.random` simulators. This means that, to simulate $K$ realizations of a pattern of size $N$, then we use `simulate(hull, size=(N,K)`. For just one realization, we can use `size=N`. " ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 39, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.fill_between(f_test.support, \n", - " *np.percentile(f_test.replications, \n", - " q=(2.5, 97.5), axis=0),\n", - " color='grey', alpha=.2, label='95% CI')\n", - "plt.plot(f_test.support, f_test.statistic, color='orangered',\n", - " label='Observed')\n", - "plt.legend()\n", - "plt.show()" + "random_realizations = ripley.simulate(state, size=(100,100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Simulation Envelope for J function\n", - "\n", - "**Jenv** class in pysal." + "To show the random pattern is truly random, we can visualize all of the points:" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 59, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -930,96 +742,38 @@ } ], "source": [ - "jenv = Jenv(pp, intervals=20, realizations=realizations)\n", - "jenv.plot()" + "df.plot(facecolor='none', edgecolor='k')\n", + "plt.scatter(*random_realizations.T, marker='.', s=2)\n", + "plt.scatter(*pattern.T, color='orangered', marker='.')\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 23, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "JtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", - " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009]), statistic=array([ 1. , 1.01010101, 1.0460251 , 1.12485939,\n", - " 1.23304562, 1.17702448, 1.44675926, 1.90694127,\n", - " 2.70562771, 3.65853659, 6.57894737, 11.9047619 ,\n", - " 23.33333333, 104.16666667]), pvalue=array([0.000e+00, 1.153e-01, 2.979e-01, 4.629e-01, 2.510e-01, 3.736e-01,\n", - " 1.873e-01, 7.440e-02, 2.090e-02, 1.270e-02, 2.500e-03, 9.000e-04,\n", - " 7.000e-04, 1.000e-04]), replications=array([[1. , 1.01295642, 1.05392157, ..., 1.34796238, 4.11483254,\n", - " 1. ],\n", - " [1. , 1.01375661, 1.05622933, ..., 0. , 0. ,\n", - " 1. ],\n", - " [1. , 1.01805869, 1.0725327 , ..., 0.85416667, 1.92735043,\n", - " 1. ],\n", - " ...,\n", - " [1. , 1.02508179, 1.10458284, ..., 0. , 0. ,\n", - " 1. ],\n", - " [1. , 1.01360544, 1.06175772, ..., 0. , 0. ,\n", - " 1. ],\n", - " [1. , 1.0190583 , 0.89433294, ..., 1.38990826, 0. ,\n", - " 1. ]]))" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "j_test = ripley.j_test(points, keep_replications=True)\n", - "j_test" + "Let's now compute the `G` function for the observed pattern as well as all the realizations we just made. " ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.fill_between(j_test.support, \n", - " *np.percentile(j_test.replications, \n", - " q=(2.5, 97.5), axis=0),\n", - " color='grey', alpha=.2, label='95% CI')\n", - "plt.plot(j_test.support, j_test.statistic, color='orangered',\n", - " label='Observed')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", + "execution_count": 67, "metadata": {}, + "outputs": [], "source": [ - "#### Simulation Envelope for K function\n", - "\n", - "**Kenv** class in pysal." + "observed_g = ripley.g_function(pattern)\n", + "comparison_g = [ripley.g_function(realization, support=observed_g[0]) \n", + " for realization in random_realizations]" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 68, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1031,607 +785,18 @@ } ], "source": [ - "kenv = Kenv(pp, intervals=20, realizations=realizations)\n", - "kenv.plot()" + "plt.plot(*observed_g, color='orangered')\n", + "[plt.plot(*comparison, color='k', alpha=.01) \n", + " for comparison in comparison_g]\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 26, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "KtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", - " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", - " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([ 0. , 0. , 0. , 0. ,\n", - " 0. , 106.08611111, 106.08611111, 106.08611111,\n", - " 106.08611111, 212.17222222, 212.17222222, 212.17222222,\n", - " 318.25833333, 530.43055556, 636.51666667, 848.68888889,\n", - " 1060.86111111, 1273.03333333, 1273.03333333, 1273.03333333]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4019, 0.2029, 0.0831,\n", - " 0.0258, 0.0465, 0.0119, 0.0022, 0.0029, 0.03 , 0.035 , 0.1135,\n", - " 0.2295, 0.366 , 0.192 , 0.0864]), replications=array([[ 0. , 0. , 0. , ..., 1184.41840317,\n", - " 1263.37963005, 1263.37963005],\n", - " [ 0. , 0. , 0. , ..., 1370.56882369,\n", - " 1423.28300921, 1423.28300921],\n", - " [ 0. , 0. , 0. , ..., 1402.53431485,\n", - " 1697.80469693, 1771.62229245],\n", - " ...,\n", - " [ 0. , 0. , 0. , ..., 1008.49372145,\n", - " 1191.85621626, 1283.53746367],\n", - " [ 0. , 0. , 145.62569697, ..., 946.56703029,\n", - " 1092.19272726, 1237.81842423],\n", - " [ 0. , 0. , 0. , ..., 1386.73502302,\n", - " 1456.07177417, 1456.07177417]]))" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "k_test = ripley.k_test(points, keep_replications=True)\n", - "k_test" + "All other functions work identically!" ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/IPython/core/pylabtools.py:132: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(k_test.support, \n", - " k_test.replications.T, \n", - " color='k', alpha=.01)\n", - "plt.plot(k_test.support, \n", - " k_test.replications[0], \n", - " color='k', label='Simulations')\n", - "plt.plot(k_test.support, k_test.statistic, color='orangered',\n", - " label='Observed')\n", - "plt.title('Alternative Plot Style')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Simulation Envelope for L function\n", - "\n", - "**Lenv** class in pysal." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "lenv = Lenv(pp, intervals=20, realizations=realizations)\n", - "lenv.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "LtestResult(support=array([ 0. , 1.82269693, 3.64539386, 5.46809079, 7.29078772,\n", - " 9.11348465, 10.93618158, 12.75887851, 14.58157544, 16.40427237,\n", - " 18.2269693 , 20.04966623, 21.87236316, 23.69506009, 25.51775702,\n", - " 27.34045395, 29.16315088, 30.98584782, 32.80854475, 34.63124168]), statistic=array([ 0. , -1.82269693, -3.64539386, -5.46809079,\n", - " -7.29078772, -3.30243845, -5.12513538, -6.94783231,\n", - " -8.77052924, -8.18621202, -10.00890895, -11.83160588,\n", - " -11.8073359 , -10.70116577, -11.28365896, -10.90433326,\n", - " -10.7870093 , -10.85579328, -12.67849021, -14.50118714]), pvalue=array([0. , 0. , 0. , 0. , 0. , 0.4044, 0.2031, 0.082 ,\n", - " 0.0252, 0.0439, 0.0095, 0.0018, 0.003 , 0.0297, 0.0311, 0.1075,\n", - " 0.2343, 0.368 , 0.1923, 0.0826]), replications=array([[ 0. , -1.82269693, -3.64539386, ..., -10.41220534,\n", - " -11.35903971, -12.34026217],\n", - " [ 0. , -1.82269693, -3.64539386, ..., -11.48333139,\n", - " -12.7406209 , -14.01340988],\n", - " [ 0. , 3.16139752, 1.33870059, ..., -9.26068377,\n", - " -9.43106958, -10.2142652 ],\n", - " ...,\n", - " [ 0. , 2.81684923, 2.91591525, ..., -13.01696279,\n", - " -14.25036009, -13.37017019],\n", - " [ 0. , -1.82269693, 2.03555805, ..., -6.22315255,\n", - " -8.04584948, -9.22525239],\n", - " [ 0. , -1.82269693, -3.64539386, ..., -14.16457779,\n", - " -15.98727472, -17.80997165]]))" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "l_test = ripley.l_test(points, linearized=True, keep_replications=True)\n", - "l_test" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/lw17329/anaconda3/envs/ana/lib/python3.7/site-packages/IPython/core/pylabtools.py:132: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(l_test.support, \n", - " l_test.replications.T, \n", - " color='k', alpha=.01)\n", - "plt.plot(l_test.support, \n", - " l_test.replications[0], \n", - " color='k', label='Simulations')\n", - "plt.plot(l_test.support, l_test.statistic, color='orangered',\n", - " label='Observed')\n", - "plt.title('Alternative Plot Style')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## CSR Example\n", - "In this example, we are going to generate a point pattern as the \"observed\" point pattern. The data generating process is CSR. Then, we will simulate CSR in the same domain for 100 times and construct a simulation envelope for each function." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "from libpysal.cg import shapely_ext, asShape\n", - "from pointpats import Window\n", - "import geopandas\n", - "df = geopandas.read_file(ps.examples.get_path(\"vautm17n.shp\"))\n", - "state = df.geometry.cascaded_union" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Generate the point pattern **pp** (size 100) from CSR as the \"observed\" point pattern." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([list([1]), list([1, 2])], dtype=object)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = [[1],[1,2]]\n", - "np.asarray(a)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n = 100\n", - "samples = 1\n", - "pp = PoissonPointProcess(Window(asShape(state).parts), \n", - " n, samples, asPP=True)\n", - "pp.realizations[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "100" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pp.n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Simulate CSR in the same domian for 100 times which would be used for constructing simulation envelope under the null hypothesis of CSR." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)\n", - "csrs" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "import importlib\n", - "ripley = importlib.reload(ripley)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "simulations = ripley.simulate(state, size=(100,100))" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAACxCAYAAAAMESCvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dd3hTR7bAf6Niy72ADcYGbHrvHZIAKZCQkN6zIW3Td5PNpr7spmdT2F3ysum9P0JLIVkgJIEQCM2mhWYw2GCbYhv3rjLvD10Z2ZZk2ZZsGeb3ffp0NZo79+hKmjNzzpkzQkqJQqFQKBS+QNfeAigUCoXi1EEpFYVCoVD4DKVUFAqFQuEzlFJRKBQKhc9QSkWhUCgUPsPQ3gK0JZ07d5bJycntLYZCoVB0KNLS0gqklHHe1D2tlEpycjKpqantLYZCoVB0KIQQh7ytq8xfCoVCofAZSqkoFAqFwmcopaJQKBQKn6GUikKhUCh8hlIqCoXCLUu25PDn/9tKRl55e4ui6CAopaJQKNzy0548vt1+hJmvrOHppbsor7G0t0iKAEcpFYVC4ZHE6BCuGtudj3/L4vI3fiO7sLK9RVIEMEqpKBQKj5iMOv5x6VA+uWU8R0uqmP3aWn7dn9/eYikCFKVUFAqFSyxWG3uOlVJVawVgSt/OfHPvFOIjTNz4wSZe/Wk/Npvaj0lRH6VUFAqFSypqrOQWVXGkpJqiiloAUjqH8dU9k7hkRCL/XrmPWz7eXPdec6g2W/kto4DlO49xMF8FAZxKnFZpWhQKhfdEhRoZlxLLhoMnMNtsdeWhQQb+fdVwRvWM4dmlu7nwP2t584ZRDEuK9qpdi9XG9e9tJO1QUV3ZkMRIxvSMxaATXDu+B73jwn3+eRRtg5qpKBQKl/y6P59f9xdw51m9iY8w1XtPCMEfJvRkwZ0TAbjizfV8vvEQ3mxP/v7aTNIOFfH3Cwfx7b2T+dusgeh1Ohan5fDx+izmfLCJwhbMfhSBgTid9qgfM2aMVAklFYqmqaq1MuOVNeh1gmX3nYHJqHdbt7Cilvu/3MaafflcNiqR5y8ZSkiQ+/qXvrEOASy5e3Kj97YcLuLqt9djMui5YWJP/jy9r8e2FG2DECJNSjnGm7pqpqJQKBrx1i8HOFxYyT8uHepRoQDEhgXx4U1juf+cvny1NZfL33QfdrwoNZtt2cVsOVzM5Bd/5uutufXeH9Ujhq/unkzv+HDeXH2AgU8sZ+ILPzWqpwhclFJRKBSN2H20FMDrWYJeJ7j/nH58MGcsOUWVXPiftfyyr37Y8ddbc3lsye84jCO5xVU8tuT3RgojI6+c9GNlda+PllS7rKcITJRSUSgUjcgvqyEhysSArhHNOm/agHiW/mkKCVEmbvpwE6+vyqgLO35p+V7MDUKQq8xW5q5Ir1c2d0U6VWZrk/UUgYlSKgqFoh5Wm2RbdjFn9Ytr0vTlip6dwlhy9yQuGtaNuSvSufOzNMqqzRwtqXZZ/0hxlcfXTZUrAgulVBQKRT30OsG5g7qwZGtuizvy0CAD/3vNCP5+4SB+2pvHxa+vI9SNKa1bdIjH102VKwILpVQUCkU9iipq2ZlbQqTJgEEvWtyOEIJbp6Tw+W3jKa0yU1lrbVQnxKjnoRn965U9NKM/Da/qqp4iMFFKRaFQ1FFRY+GN1RkcLanmvTljG61PaQkTenVi6Z+mcN6gLvxhQk8So0MQ2BNVvnDZUC4ZmViv/iUjExnfK7budUKUyWU9RWCi1qkoFAoAsgsrmf3aWooqzZwzMJ735oxtN1lqLFYWpeXwt693cla/OOZMTKasxkJJlZnOYUFMGxDfIn+PomU0Z52KStOiUCiw2iQPLtyO2Sr5+JZxTOzVqV3lCTbouX58T6w2yXPf72F1ev3w5KSYEJ64cBDnDuqCEC030Sl8j1IqCoWCt9ccYGNmIXOvGMZZ/eLaW5w6bpyYzLmDunCkuIqoECORJiO7j5bywn/3cvunaVwwtCuvXTsKnU4plkBBKRWF4jRn2e9HeXl5OrOGJXDF6KT2FqcRCVEhJESdjPyKjzQxuU9nXlq2l/fWZnLgnHL6dmneehqF/1COeoXiNGeJtlL9rrN6dxhTklGv47rxPQBYkJrNjpxi8stqvEpoqfAvaqaiUJzG2GySwopaTEYd8ZHB7S1Os0jpHEZSTAjv/prJu79mAjCiezT/98cJKgllO6KUikJxGlJZa2HOB5vQCUHaoSL+celQn4QPtyVCCFbcfyaZBRUcKa5i3/Ey/rVyHw8s2MaTFw2ma1TH+jynCkqpKBSnId9uO8LmrCKMesH5Q7py7bju7S1SiwgLNjAkMYohiVGcN7grOp1g7op0Vu4+zryrR3DR8G7tLeJph1IqCsVpwoaDJ/jtwAlmDO7C89/vYXhSFF/8cQImo77D+FKa4u6pfbhwaDdu+Xgzb685wKyhCSoyrI1RjnqF4jTgWEk117yzgVd/2s+sV9diCtLzxg2jCQs2oD/FOt0enUK5dUoKO3NLeWzJ7+0tzmmHUioKxSlOTlElV729vu71GX07s+SuSSS2IEHj11tzmfziz6Q8+r3LTbYChWvH9eCasd35MjWbanPjnGMK/+G1UhFC6IUQW4UQ32mvnxVC7BBCbBNC/CCE6OZU9zEhRIYQIl0IMcOpfLQQ4nftvVeFNucWQgQLIb7UyjcKIZKdzpkjhNivPeY4ladodfdr5wa17lYoFKcmjy7+naLKWr66exJZL87i01vH0z02tNntODbZyi2uQuJ+k61AISbM3iXYVJhxm9Kcmcp9wB6n13OllMOklCOA74AnAIQQg4BrgMHATOANIYQjvu9N4Hagr/aYqZXfChRJKfsA84CXtLZigSeB8cA44EkhRIx2zkvAPCllX6BIa0OhOC3ZfaSUT9dnYW2wCdaxkmrWHSjg1ikpjOwR4/pkL+lom2claNFfGXnl7SzJ6YVXSkUIkQTMAt5zlEkpS52qhAGOX/PFwHwpZY2UMhPIAMYJIRKASCnlemlfofQJcInTOR9rx4uAs7VZzAxgpZSyUEpZBKwEZmrvTdfqop3raEuhOK04UV7DzR9t4u/f7OKOT1OpqLHUvffl5mykhItHtD7DbyBtnuWNGa6grAadgL7xarV9W+Jt9NcrwMNAvW9HCPE8cCNQAkzTihOBDU7VcrQys3bcsNxxTjaAlNIihCgBOjmXNzinE1AspbS4aKseQojbsc+O6NGjh1cfVqHoKNRYrPx14XaKKszceVZv3v31IFe8tZ735owhxKjn3V8Pct6gLqR0Dmv1tbpFh5DrQoF0iw7h6625zF2RzpHiKrpFh/DQjP6tTlXvrk2HGc4xa3KY4YB613SMck1G5TpuS5q820KIC4E8KWVaw/eklI9LKbsDnwP3Ok5x0Yz0UN6Sczy11VDGd6SUY6SUY+LiAidRnkLhC+74NI3V6fn8/aJBPHr+AD68aSw5hZVc/No6Hl28g8paCw/6aHOrh2b0J6RBuvkQo55pA+J87mvx5L/x1gwXbNBhk2CxKZ9KW+KNCp8MzBZCZAHzgelCiM8a1PkCuFw7zgGcV1IlAUe08iQX5fXOEUIYgCig0ENbBUC0VrdhWwrFacPO3BIuG5nIHyb0BODMfnEsuXsSoUF6fth9HJNRz4x5a3wSqXXJyEReuGxoo022Vu3N97mvxZPi8MYM99G6TF75cT8AFqtSKm1Jk0pFSvmYlDJJSpmM3QH/s5TyBiFEX6dqs4G92vG3wDVaRFcKdof8JinlUaBMCDFB84ncCHzjdI4jsusK7RoSWAGcJ4SI0Rz05wErtPdWaXXRznW0pVCcFuw/XkZBeS0DEur7DPp2ieD2M3th0Akqa60+jdS6ZGQi6x6dTuaLs1j36HQuGZnoF1+Lpzab2sP+m225PLV0N2HBBh44t5/KA9bGtGZF/YtCiP6ADTgE3AkgpdwlhFgA7AYswD1SSseQ4y7gIyAEWKY9AN4HPhVCZGCfoVyjtVUohHgW2KzVe0ZKWagdPwLMF0I8B2zV2lAoThs+23CIIL2Oy0c1Tlf/5uoDjcw+jpF+a3wdrvwcnnwtLcVTmw/N6F/PpwJgMui47+y+5JfV8NDCHYxPieWTW8cRbFAKpa1pllKRUq4GVmvHl3uo9zzwvIvyVGCIi/Jq4Eo3bX0AfOCi/CD2MGOF4rRk6Y6jnDe4C53CG2cX9sfswZ2D/PLRiSxOy63XyYcY9TzUCl+OK8XhaNOhFB3KLTrUSFGlmY/XZyEE1Fpt3DW1t1Io7YQKi1AoOiBFFbVU1FiaNAV5W+4N7vwcq/bmu/S1tGZG5M5/42jTYYZLf+78ugidXUdKeWjRDnrEhjKie3SLr61oHSqhpELRwdicVcg172zAapPo3CSC9DTSbymeZj+XjExsdQhxQ7xp89f9+RRXmhnVI5rDhVXcNbU3N0zooWYp7YhSKgpFB+Ot1QfQC8EDM/px0TDXqd0bmoh8sXbEH76T1vL1tiPEhBr58o6JGPXK8BIIKKWiUHQgMgsq+GlvHved3Zd7pvXxWLc1swdXDnl/zH5aQ3mNhZW7j3HF6CSlUAII9U0oFG1E2qFCXl+VQV5pdYvb+GhdJka94PoJ/ssO4W7hIeBz30lr+GHXMarNNp+koFH4DjVTUSjaAKtN8tcF28k6UckrP+5j9vBEbp2SwqBukV63UVJlZmFaDhcN7+bXrX89LTx0rE1pCb5I5eLcRpBBR0yokdGtTJSp8C1qpqJQtAFPL91F1olKAIL0OpbuOMIFr/7K3BV7mzjzJAtTs6mstXLL5BR/iQn4Nxy5NalcGrZRY7FRVm3h2+0qmUYgoZSKQuFnvt6ayxcbD9e9rqi1ogOGJ0Xx7ppM8stqmmzDYrXx4bosxqXEMiQxqkUyeLu5VluGIzcnlYurNiw2GbCp909XlFJRKPzMy8v3NlrdXm2xcbSkGrPNxqfrs5ps48c9x8ktruKWycnNvn5zZwnuEkf6Kxy5LdtQ+B+lVBQKP3OkxLVjPr+shrMHdOHTDYeoqnW/5a3NJnlnzUGSYkI4d1DXZl+/ubMEdwsPgRZvJeyL2Y8/ZlAK36OUikLhZ+JcpFEBe2f4xzNSKKo089Ci7aRmFWJzkab9g3WZbDlczJ+m90Gvc73Y0RMtGeE3TBwJtMon4ovZjz9mUArfo5SKQuFn7pnWu1GZozMclxLLTZOS+XHPca54az1nvLyKl5fvJf1YGQCr9ubx8vJ0zh3UhavGdG/Ujjf4YoTfWp9IU2lXmtuGg7un9nbbRmFFLd9sy6Wk0uz1NRStR9izyJ8ejBkzRqampra3GIrTjG3ZxVzy+joiTQbKqi0uw2kdC/neWXOQPUftCkWvE1htkoEJkXx+23hiw4JadP2GiSDBrtSa06mnPPq9y13wBJD54qwWydUaSqvNTJu7mt5x4Sy4c2JdeVm1mR92HWfpjiOs3V+AxSa5fFQS/7pqeJvLeCohhEiTUo7xpq5ap6JQ+JHSajP3fL6FxOgQlv5pilvFEB5sQCDIKqisK7PaJAad4JbJyS1WKOCblC2BlqLlUEElJypqOVFRyC/78qmosfDttiP8nJ5HrcVGYnQIt56RQn5pDV9tzeHuab3pHRfeLrKebiilolD4kdXp+eQWV/GFFzMNdyGzr/y4nytbaPpy0NqEj96maPHHXvWuyC46qXznfLAJgM7hwVw3rgcXDU9gVI8YhBAUlNewbOcxXv1pP/97zUify6FojFIqCoWf+GBtJp+sz8Jk1DEuJbbJ+oEcMttwthMVYkQI+MuX25i7Ir1Oubjab8X5fF9xwdAEMl+4gOOlNRzML0enE4zpGYOhQQ6wzuHBzJmUzNtrDnDPtD706xLhpkWFr1COeoXCD/y4+zjPfLcbq5RcP75no87OFYEeMuuICJt39QhqLDaKKs31IsGe+naXz/eq94QQgq5RJib16cyEXp3c3uM7zuxFWJCBZ5budhldp/AtSqkoFD6m1mLj0SU7GJgQyY8PnMXfLxzk1XkdJWTWXSRYcZXrKKv2nmnFhAXx6PkDWJtRwMfrs9pVltMBpVQUCh9TVm2moLyWXnFhzdosyhdht21Bc5VEIMy0rh/fg+kD4nlx2V72HS9rb3FOaZRPRaHwMdUWG0LAvmPN77z8sYOir3EXCRYTaqTabAuY/VacEULw0uXDmPnKGv74SSpXjenOpN6dGJoYVWc2a6sgg1MdpVQUCh+y5XARN76/CZNBz33n9G1vcfyCu0iwJy8aDPh2t0lfEhcRzH+uHckz3+2u8/OEBxsYlxJLhMnA8p3HqLHYAP8GGZzqqMWPCoWP2He8jKveXk+kycjnt42ne2xoe4vkNzr6qP5EeQ0bDhby24EC1h84wcGCCpf1ukWZ+O2xs9tYusCjOYsflVJRKHxAdmElV7z1GzYJi++cRI9OgaVQWqsEOroSaYrkR793+97s4d14aEb/U3qQ0BTNUSrKUa9QtBKbTTLnw01U1Fj55JZxAalQWpMM0hcbbAU6iW6CCUKMen7em8cf3t/IifKm970JRCxWm8cs2L5GKRWFopVUma0czK/gouHdGJjg/fbAbUVrk0H6YoOtQMddOPcLlw3l41vGcbSkmts+ScUa4OtcCitq2Xq4qE6JbD1cRJ/HlzHwieVtllhTOeoVilayKj0PgLP6dW5nSVzT2pX6gbzS31c0lR/tvnP68vLydI6VVrud1bQVUkqOlVaTkVdORl45+7XnA3nlnKioBeCpiwYxZ1IyDy7cDkCEyUCEqW26e6VUFIpWsmRLLglRphZtoNUWtDYZZKAlk/QXnsK5HSvxO7UisWdrqTZbufeLrWw4eILyGktdeVSIkT7x4ZwzsAtrMwooKK9hxpCurD9wggP59gCEL26bgK4Fe/G0BKVUFIpWUllr/4O3ZAMtf/P11tw6+ZxpzvoRb5NJnsrM35wNwHXvbuDsgV24cnQS8ZGmNpXh/bWZ/LjnONeM7c7gbpH0jg+nT3w4ceHBCCFIP1bGgrRsbj+jFwlRIVz19noALh+VxNCkqDaTUykVhaIVrNx9nA0HC3ns/AFtel1vorFc7aMCEB1i5KnZg72O3vJF6vyOjNUmySmyz9RqLDbmrkjn3yv3MX1APNeO686ZfeO8yu3WGsxWG4vScpjSpzMvXj7MZZ1//pBOeJCBO8/qzbbsYrIL7TL/9bx+fpWtIUqpKBStYMmWHBKiTNwyJaXNrtlQWbhbqOfKwQ4QFmxotkLoCCv9/YVeJ9j8+DlEhhgINug5mF/Ol6nZLE7LYeXu43SNNPGHiT354xm9CDL4VrmsTs/j3V8PsuVQMVVmK1ePdb0FwpbDRazcfZwHz+uHTid4SPOlDE+KanMzpYr+UihaSFFFLWv3FzC5T2eMfh6pOuNtNNbp4GBvK+IiguvyuPWKC+ex8wey/rGzeeuGUfTrGsHcFelc9uY6MvJ8m1fs5715rMs4wbQBcbx23UhunpzcqI6UkpeW7aVzeBA3T07h4tfWsj+vHIDrJ/T0qTzeoGYqCkULeX1VBhW1Fm4/s1ebXtdbZXG6ONhbisOEmFtcRddIE38+uw/XjXffCbszOc4cksDyncd4bMkOZr26lsdnDeQPE3oiROt9bHdN7c3C1BwsVsmFw7q5rLNmfwEbMwt5evZgQox6sk6c3MBs5pC2Dx7xenglhNALIbYKIb7TXs8VQuwVQuwQQnwlhIh2qvuYECJDCJEuhJjhVD5aCPG79t6rQrvrQohgIcSXWvlGIUSy0zlzhBD7tcccp/IUre5+7dz2C8tQnHYsTsvh4/VZXD4qqc03fvJ235W2SqX/9dZcJr/4MymPfs/kF3/uEIsinRd0AhwrreZ/vtrJde9ucLnnSlMLQGcO6cqK+89kQq9OPPHNLu79YqtP5EyICuHe6X34Yfdx1uzLb/S+zSaZu2IvSTEhXDuuB0LA3VN7c8vkFPY+O5NIk9EncjSH5szZ7wP2OL1eCQyRUg4D9gGPAQghBgHXAIOBmcAbQgjHL/tN4Hagr/aYqZXfChRJKfsA84CXtLZigSeB8cA44EkhRIx2zkvAPCllX6BIa0Oh8Cs2m+T573fz14XbGdMzlr/N8m6vFF/irbJoi1T6HXW1vTt/028HTvDI4h2NFjl6Y3KMjzTx0c1juXlyMt//fpT8Mt+swL/tjBRCg/Qs23m00Xv/3XmUnbmlPHBuP4IMOoQQPDxzAE9cNAiT0fttF3yJV+YvIUQSMAt4HngAQEr5g1OVDcAV2vHFwHwpZQ2QKYTIAMYJIbKASCnleq3NT4BLgGXaOU9p5y8CXtNmMTOAlVLKQu2clcBMIcR8YDpwnXbOx9r5bzbjsysUzUJKyZPf7uLTDYeYM7Enf7twUJv6Uhw0JxrL3w52T51tIDv2PfmVFqblYJWSuVcMrwsT99bkKIRgaKI9fHff8TLiIoJbJaeUklV786mstZIUUz/9j9lq418/7KN/lwguHhE499pbn8orwMOAu3n+LcCX2nEidiXjIEcrM2vHDcsd52QDSCktQogSoJNzeYNzOgHFUkqLi7bqIYS4HfvsiB49enj6jAqFR+auSOfTDYe448xePHr+AJ/YzFtKoERjtSYYoD2TVLrzNwUbdNw7rQ//WrkPKeGfV9oVi7f+qY0HT/C3r3fSq3MYQxJbtzYk/VgZz3y3i3UZJ+gbH97o3ixKyyGzoIL3bhwTUGukmhxmCSEuBPKklGlu3n8csACfO4pcVJMeyltyjqe26hdK+Y6UcoyUckxcXJyrKgqFR6SUbDh4gvd+zeTSkYntrlACCW/9Ow1pb7OZKxOiUSeosdhIirUruK+25vKXL7dhsdqYNiCuUafT0OSYdqiImz7cTEKUifm3TyAqpOX+jMKKWi55fR07c0t5evZglt13Rr30MNVmK6/8uI9RPaI5e2B8i6/jD7yZu08GZmvmq/nAdCHEZ2B3ogMXAtfLkzn0cwDnYOok4IhWnuSivN45QggDEAUUemirAIjW6jZsS6HwKQ8u3ME172wgwmTgvrP7KoXiREuDAdo7SaUrf9NLVwxjRPdonv1uD4O6RfLo+QP4dvsRLvzPWham5tQbtQrg8tH1Z4tLtuRgtUnm3z6x1avtD+SXU2W2Mu/q4cyZlNxoceXHv2VxvLSGR2YG3gCnSfOXlPIxTjrhpwIPSilvEELMBB4BzpJSVjqd8i3whRDi30A37A75TVJKqxCiTAgxAdgI3Aj8x+mcOcB67L6Zn6WUUgixAviHk3P+POAx7b1VWt352rnftPguKBRuyCmqZPGWHG6Y0IPHLxhESFD7OD8DlZautg+ENTSuTIjDkqK45aNUbv5wM2f07czfZg3k+e/3NDKDSGDV3vrRWL3iwqm12vDFHlWO+9A9pvE2CiVVZt5YfYCz+sUxvlenVl/L17RmncprQDCwUtOUG6SUd0opdwkhFgC7sZvF7pFSOoYkdwEfASHYHfTLtPL3gU81p34h9ugxpJSFQohngc1avWccTnvsCm2+EOI5YKvWhkLhM2w2ybyV+wGYMbirUihuaK5/5+utueiEwOqi823vNTR94iP48YGz+HTDIZ79bjfdY0Nd29VprACHdLNve7DrSGmrZyoO/02Ci/vx7pqDlFSZAzb3WrOUipRyNbBaO+7jod7z2CPFGpanAkNclFcDV7pp6wPgAxflB7GHGSsUfuGZ73azeEsOd0/tzZQ+gZnWvqPh8KW4UihgT8759dbcVjvsWxMEEGTQceuUFPLLanjrlwPEhBopcrEXSUMFWFxlr7P7aCnTBrTcz1FjsbI4LYfkTqGEBzfuor/Znkt0qLHNUtk3F5WmRaFww8LUbM4f0pWHZvQPOLt1R8Xd+hAHRZXmVjvsfRUE8Nfz+jGqRzSVtVaCG+T0aug3+nzjIe74NI1uUSbO7Nu6gKC3fznIgfwKnpw92OX7V43uTnGlmSVbAnMtkFIqCoULnvtuNxW1VgZ3izztFYovV8x74zNprcPeV0EARr2OV68dicmoJz4imATNpGXUC56/dEi9mc+wxGg6hQVRXGUmMablJryD+eW8tiqDWcMSmNa/8WxnR04xb6w+wOBukfyxjdMDeYtSKgpFAyprLby3NpNZQxO486ze7S2O3/BGWfg69Ndbn0lrHPa+DAJIignl5SuGkV1UxflDE5h39XDMVskv+/JZnJZDRl4ZNptkaFIUF49IxGqThLbQ9yal5PGvdhJs0PHkhY0zNRw+UcktH20mNiyID28a69I0FggEplQKRTuSV1qDENA9NpTvdhw9JfcRaU36/NasmHe14ZcrWuOw93UizRmDu3LTpGQ+WJfJ7OHdSIoJ4Yddx/lmm30VQ3iwgSGJkRzIr2BMckyL06Ms2ZLL+oMneO6SIY0c/YUVtcz5cBMWm2T+LePafIOw5qCUikLhRG5xFde/t5HoECMxoUavOt6OiLfKwttRv7eO8YYhyFEhRipqLZitJx33rU166Y+dKh+7YABC2Fexl1Vb6B4bwpiesfTtEs7R4mq25xRTUmXmgqEJLWp/QWo2Dy/aAcB14xpn/vhoXSaZBRVcP74HvTqHtfhztAVKqSgUTjz+ld3U892fpnDHp2kdMq+VN/gyfb63sx4HDUOQfZ2uxR87VQYb9Dx50WAenjGA5buOMn9TNl9tzUWvE0zrH8+fp/flrP5xLcoFV1RRW6dQAI6UVNXL87Uuo4AVu44D8PnGw4QY9fzNhXksUFBKRaFwoqz65H7urjpT8Gybb898Vs3BWxORN6P+1prI/JHHzF+50UKC9Fw6MolLRyZxML+cBak5LErL4cc9x4mPCOaK0UncNCm5Weapht/D7NfWseXv5wJ2P8s//ruHgvIazh3UhaKK2laFK7cFSqkoFE4Y9fZIrwv/sxaDTmBxsbeGO9t8c0fsLcFXSstbE5E3o/5AWB3fltzy0WZ+3ptHdKiRS0Ykcu+03hwurOKXfXm8sfoAx0qq+ffVI7xub8PBEwDcNCmZWqutnvlra3Yxu46U8uj5AzpM0IhSKgqFE/OuHsGOnBK2Hi7mrV8OoG+w8tuTbd7faeB9qbR8mT7/dNthclxKLD/vzaO40sxHv2U1et6V/5wAACAASURBVP+uqc3r/Fen5zMwIZKnXKxLOVZSDcCLy/aSmV/BS1cMa5HMbYlSKgqFE5EmI3uOlvLJ+iziI4K5d1of3l5z0KuZgb9H7L5WWr4yEfnDMR7I3HlWb64f34N3f83k3TUH633uuIhgesWFN6u9TVmF1FpsfLo+iz9MTK4rn7tiL19sPFz3OiE6cCO+nFFKRaHQOFZSzcWvr+V4aQ0XDO3KY+cPpHtsKDdOSvbqfH+P2APVzOQPx3igE2Ey8sC5/bh7am9sUhJi1LN4Sy4PLtzOm6szuHd6X6/bmtS7E6vT8yl18ud9sy2X11cd4JyBXbh6bHfO7NeZYEPHyD2nlIrCIyWVZgoqaujdzNFXR+Snvcc5XlrD1WO688B5/ejSzLUA/h6xB7KZKVA2DWtLsgsreXrpbm47I4UJvTpx+ahEVqfnMe/H/Uzu05mRPWKabgQ4s28cq9PzOX9I17qy3UdLAXjzhlHtsrtoa+hY0iralD1HS7ng1V85/5Vf2ZFT3N7i+J28Uvue4l+mZrcor5K/94Rv6d4lCv+wIDWbH/cc55p3NvD00l1Um208f+lQukaauG/+NsprLE03AizfdYz+XSLqzGY5RZW8/ctBAPo+vswnqfTbEjVTUbjkx93HuW/+Vipq7aPueSv38eHNp25S6FqLjRqLre71iO7RLWrHnyP209HM1F6kHyvjq625xEcEM6FXJwZpae2dcURtAXy4LovV6fn888rhzLt6BNe8s56nvt3FP68c7vE6+WU1bM4q5E+auSy3uIpr3tlApMlAeLAh4MOHXaGUiqIeUkreX5vJ8//dg2OAFGLUc9PklPYVzAcUV9aydMdRshwrk7WR4dGSKp78Zhc/7D7Omf3iuOPMXkzsHXibH8HpaWZqDzZmnuCtXw4AEKQllpzpZJ4CuGdaHz7feJhVe/PoFRdGRY2VK9/6jfm3T+Suqb15fdUBbp6czOBu7veqX7n7OFLC+UO6Ul5j4Zp31lNSZebz28YzLKllA5v2RikVRR21FhtPfLOT+ZuzmTm4K12jTHz0WxYPz+zPWf1al867Pak2W/lgXSZvrj5AWbUFnbA7Qtc+Mp3DhZVc/fZ6iqvMXDyiG69cPeK0z0rcEfH1otNrxvbgi42HySyoICkmhLs/T+PFy4dx1ZiTu5uXVltYudu+0t0mYdn9Z3D+K7/y5Le7uHacvV5EsOd96pfvOkbPTqEM6BrBpsxCsgureOP6UR1WoYBSKgrsf8iXlu3laKk9Jv7cgV144/pRVJmtpB8r45nvdhMWZOCqsd2baKntqTZbySyooG98eKN9vAG2Zxfz14Xbycgr55yB8Txwbn+2ZRfzP1/9zgMLtrHxYCFGvY6VfzmTPvER7fAJFK3FH4tOgww6Xr5iGJe98RudwoPpGmXi4UU7KK0yc9sZ9pTzE3rFEhVipNZi438uGECkychjFwzg3i+28sQ3u+gcHkT3WPdBFCVVZn7LKODWKSkIISjRNvnqEdt4C+GOhHLUn+Z8vTWXRxbvqFMoAGszCvh2+xHCgg18ePNYzugbx8OLd7D/eFk7Suqahxft4Pz//ZWRz6zk3yv31ZXXWmz8c0U6l735GxU1Fj6+ZRzvzRnLoG6RjO8VS4hRz4pdxxmQEMHnt41XCiXAcZWm31F2/5fbfLJ/SkOGJUXz9MWD2ZRZSL8uEcwamsBz3+/hnyvSkVISH2Hi6dmDqTJbOZhfAcCsoQlM62+f1U/s3dnjrHd1eh4Wm2SGZlZzKJWoEM+zm0BHzVROc579bnc9BzXUX1BnMuq5blx31uzLb1SvvVl/4ATfbj/CZSMT2ZFbwodrM9mRU0x+WQ1l1RYOF1Zy+agknrhoUL0/au+4cH7661mEBumJDg1qx0+g8AZXM5GHFm4HQb3sxg3xZv3O/206zGs/Z7D2kWkuFcD143uy92gZH67L4p9XDifCZOC1VRkUV9XyzOwhXDyiW932CNMHxNMrLpz354wlt7iKzuHBHq+t19mvp9Ou61AqkUqpKDoqn288xImKWpfvOf8h88td12lvSqrsco3qGcPMIV15bMnvrE7Px6gXjOwRw3mDurBs5zGGP/1DXbqVRBUx1ea01t/hKpOA2UVOtoZ4s37nmaW7qTJbyS6sokcn12anJy4axP68Mv5nye/cNbU3N07sySfrD1FSZeHZiwejE1BjsbE5q5BeceHodILuXpiwJvayB4OsyyhgRPdoSqrMCAERAbr5lrco89dpiNUmeXrprrpd5lzh/Ic8Z2A80aFGHly4nezCSp/I8FtGQavbmjG4Kz1iQ5m3ch/nDe7KD385k/vO7su6R6Zz3bgefL7xcN1iQUf+rtbuXOhvfLl1byDgi50jW5IxwNv1O2NTYgFIPVToto5Rr+PN60dzzqB4/ven/SzbeYzkTqEs3X6ECS/8xI97jvPIzAFcObp5PsdO4cEMTIhk7f4CwD5TiTQZ0ek6dqCIUiqnGWXVZm77eDMfrsvipknJ/OPSoU0uqEuICuGVq0dw6EQlZ//7F/YeK22VDIvTcrjuvY1c/fZ68stqWtRGQXkNDy7cweHCSnpqI8xO4cH85dx+xEeaXI5uHfjC3u4PfL11byDgi/3im5sxwJtFp1JKft57vG5g89XWXJZsyWHr4aK6OtVmK8WVtUgpiQkL4o3rR7P4rol0jwkh60SlVseGTcJnGw7x7fYjzZITYEqfTqQdKqKq1kpxpZno0I5t+gKlVE4rsgsrufzN31izv4DnLhnCU7MHc/noJK9WgU/tH8+K+8/EbLXx2YZDVNRYKK5svlnsaEkVjyzewcge0RRW1nLnZ2lUN7G1LNj/4C8s28PMV9bwzNLdTP/nar7dnstdU3vz2W3jG9VvanTb3vmyXOGLDjjQ8EW+MleZBIw6UbdNgYMQo55Xrh7BukenN2lee/a7PdzyUSoWm91P+Ov+Ah5YsJ1L3/iNJVtyyMgrZ8pLPzPimZUMf/qHutDh0T1jWXzXJG6elIzz1Vs6AJjUpzO1VhuphwopqTJ3eCc9KJ/KKYuzHTshysTFIxL5MjUbi9XGxzePY0rfznV1vV1Q16NTKDdO6MnH6w/x5eZspLSf+8RFg4g0Nf1nyMgr54X/7sFik8y7agQ7j5Rw7xdbueyN33jj+lEka9ukllWb+XJzNunHysgtruJIcRVHiquptdo7gPTjZUztF8fjswbRJ951TjJ3ebKc3w80AjVhZGvwRb4yd5kEGpZNGxDH3BXp/OXLbU36bgZrK+QdqXmCDDpMBh2l1RYeWLCduIhgCspriQk10iXSxF8XbGP5/WeyKbOQuSvSXX6mKrOVl5bvZVr/eKK8nHGMS47FqBesyzihlIoicPl6ay6PLt5BtRatdaSkmjd/OUBcRDCL7pzc7NTczjw+axApncPIOlGJlJJPNxzCqNfx7MWDXa4TAVi+8yiL0nL4aW8eJoOev57bj+TOYSR3DiMsyMBfFmzjwv+s5flLh5BfVsPrqzIoqjTTJTKYbtEhDEmMYsbgrkwfEE//rhGYrZK4CM+RNa6SOzoI1HxZgZwwsqX4Ksmmu4GPo6y5a1X0OoFRJ+oiGmstNizWk9GN+WU16HWCokozz1w8hEcX7+COT9PIyCt3a1YFOFpSzbnzfuHbe6fQNarphKRhwQZGdo9hbUY+ZdUWEmM67nftQCmVU4zyGgtPfrurTqE4Y9CJVikUsI/onFO2mG2SLzYeZnNWIR/eNLZR1EvaoSLu+WIrNim5e2pvbpmcQienUMtpA+L5/s9ncO8XW7hv/jYAzujbmYdm9G/VqmLn0W1ucVVARH81FQXVUfYlaU40V1vlK2vuXjNzV6Q3iiCzSegcHkR5jYVqsw2r9v6hExUMSIjk95ySutmyJ4qrzPzxk1QW3DGRkKCm09VP7tOZeT/a11hdOTqpyfqBjuhoGTBbw5gxY2Rqamp7i+EXMvLK+WzDIRal5bjNjiqAzBdn+fS6UkpW7DrGw4t2EBsWxI0Tk7FJiU1Ksgur+HzjIRKiQlh010QSotyPwmotdl/NgIQIJvXu7LZeR6XhSBrsCqOh/yrQ97j39nO0NSmPfo+rnszdb95T/aV/msJNH25iUu/O7DteRlxEMJuzCqk2N61Q9EIwJjmGjZmF3DI5hScuGtTkOZkFFTywYBvXju3BFaOTAjL6SwiRJqUc401dNVPp4JitNt5YdYD//LwfnRBcMLQr6zJOkF/eOKrKH2YUIQQzhyQQFxHMTR9s5pnvdju9Zx95/f3CQUQ04XMJMui4ZUrHT1rpDm9H0oGeMNLfWya3lOaaDj3VH5IYxbpHp2PU6bj901RyiqpI6RzO3qOlLhWRM1Yp2ZhZyICuEYzq6d1MO6VzGF/dPdmruh0BpVQ6MHuOlvLgwu3sOlLK7OHdePKiQXQKD3Y7mvSFGcXdSHp0z1g2/+0cqs1WdDqBXggMetFhdqvzN6eKEz5QP0dzTYdN1Xf8bitqrOw7XoZNgk5AU4YdAUgg60QFy3ceY8bgrh1uk63WopRKB8RstfHmavvsJCrEyFs3jK6XlttfduymnKEmox6TUSkRV3RUJ3zDQURUiJFiLZ2IM019Dn+b9Zr7m/em/tdbc9mcVYjD9eJ41omTx86EGPU8e/Fg4iNNvL4qg+92HOX5S4cSFaKUiiKAKaqo5Q8fbGRnbikXDe/G07MHExvWOH+VP8wogWr66Ai0pxO+pR26q0GEUW+PmnJ2cjf1OfyRRdgVzf3NN1V/7op0LC60R6ewYMprLMSEGZESjpVUN7qvS7cf4UB+xSkRItxclFLpYPyw+xg7c0t59uLB/GFicpteO1BNH+4IJKd3e+3a2JoO3WXOLaskJtRIaJDB68/RUQcj7n7X+eU1fHTzWG77OJUxyTGsenBq3Qz9YH4576w5yNfbcpnS59QLOPEGr5WKEEIPpAK5UsoLhRBXAk8BA4FxUspUp7qPAbcCVuDPUsoVWvlo4CMgBPgvcJ+UUgohgoFPgNHACeBqKWWWds4c4G9a089JKT/WylOA+UAssAX4g5QyMDMf+pCQIPtXpte1/ZS6I5lw2mp03ByaGhn7Qwm2pkN316kWV5rZ+sR5XsvQ0QYjDjwtoF1/8AQvXj6MBxdu54EF2/jHpUN54ptdLN1xhCC9jmvG9uDe6X3aWOLAoDk9033AHqfXO4HLgDXOlYQQg4BrgMHATOANTSEBvAncDvTVHjO18luBIillH2Ae8JLWVizwJDAeGAc8KYSI0c55CZgnpewLFGltnPIcK7H/yMf3im3za7tKlxFI6yickzH+dcH2DpXyxF95v1rToXuKnGoOvmqnrXH1ewcY2SOat385yILUbO44sxf//f0YU15axX9/P8qdZ/Vm7SPTuWdaH9779aB9zxQv1racSng1UxFCJAGzgOeBBwCklHu09xpWvxiYL6WsATKFEBnAOCFEFhAppVyvnfcJcAmwTDvnKe38RcBrwt7wDGCllLJQO2clMFMIMR+YDlynnfOxdv6b3n/0joOUkp25pSxKy+brbUeIMBnopaU0aUt8YcLxl0mq4czE6iZMJ1BHx/4wEX29NRedtuizId506L7yA3WURZ0N8fR7X7IlhwcWbCcxOoR7pvVmUVoO780Zw4RenZBScvHr69iRU8K7v2bSOTyYK0Yn8cC5/SiurGXxllysNhsmo55go55gg46R3aPp2+XU2CjOW/PXK8DDgDefOhHY4PQ6Rysza8cNyx3nZANIKS1CiBKgk3N5g3M6AcVSSouLtuohhLgd++yIHj16eCF+YHEwv5yHF+0g9VARQQYdMwZ3Zc7Enn7fR91d59+aAAB/mqQ8ZSV2xlVnGgi+F1+biBz32pVC8bZDb+kgwtX9fOGyoe1+j1uCu9+7I09dbFgQD80YwIPn9UcIQV5ZNSfKa9mRU8KdZ/VmRPdoFqVl89YvB9h1pMTtIsrusSGsecj1RmEdjSaVihDiQiBPSpkmhJjqRZuu7or0UN6Sczy1Vb9QyneAd8C+ot5VnUDlux1HeHDhdoINep6ePZhLRiR6naiuNTSn829Oh+xPh603na+rzjRQfC++9le5U7J6IZq1+r25gwh39/OFy4ay7tHpXrfjqt22VEpNXW9xmn18/P7aTO48yz5T+e/vR/k9t4QIk4GYUCPFlbXMHNKV8wZ14YyXV7E2o4BLRiRy/zl9SYgKocZipdps45ttuTz3/R52Hy1lcLcov32mtsIbn8pkYLZmvpoPTBdCfOahfg7gvFtNEnBEK09yUV7vHCGEAYgCCj20VQBEa3UbtnXK8OG6LOIjTDxwbj/eWXOQEc/80CYbN3mbgr25fgB/Omzddb56ITym9A+UdPO+9le5u6c2Kf3aGfvjfrb1PjPeXG9q//iTx3NX8dLyvRj1grMHxFNWbSE0yMCB/HIAdDrBZ7eNZ+VfzmLe1SPo2SmMIIOOCJORuIhgLhmZiBDww67jfvk8bU2TSkVK+ZiUMklKmYzdAf+zlPIGD6d8C1wjhAjWIrT6ApuklEeBMiHEBM1fciPwjdM5c7TjK7RrSGAFcJ4QIkZz0J8HrNDeW6XVRTvX0dYpQ3SIEatN8uKyvW26cZO3nX9zOxB/Omzddcr/umo4mS/OcrvHRqBEJl0yMtGrfW28pb2c4/64n22t+Ju6Xlm1mT//39a69+xJUaew5O7JTOxt3yI4t7iKA/kVdXVSOoe53aahc3gwY3rGsGLXMV9/lHahxetUhBCXAv8B4oDvhRDbpJQzpJS7hBALgN2ABbhHSun4hu7iZEjxMu0B8D7wqebUL8SuvJBSFgohngU2a/WecTjtgUeA+UKI54CtWhunDFJKsk5UkF9W0ygzqr9j/L01xTS3A/Gnw7al9v9ACpP25YLVtnaOO8xF7uzLrbmfba34PV3PZpPc8tHmuvu66sGppHQOw2aTnPHyz2QXnjy3sKKWoopaYlwsTm7IjMFdee77PRw+UUmPTk3vbx/INEupSClXA6u146+Ar9zUex57pFjD8lRgiIvyauBKN219AHzgovwg9jDjU478shre/uVAvZFOQ/w5kva2Q2puh+zvBYAt6ZQ7amRSU7TlYktXueacae39bGvF7+l6eWU1bM6ybzn8t1kDSdEc9unHy+oUyuzh3TDqdaxOz8PmJgqxoc/m5snJgH1x821n9PLDp2o71Ir6dmb3kVLW7M+nosZCRY2VExU1LN95jFqrjUtGdGNTZiFHSqobnefPkbS3HVJLOuRAzMJrMurqPkN0iJGnZg8OOBlbQlvda0+Rd77Yv8YXir85jn5P1zM4bWF8w4SedccDukbw9T2TGdA1osn8d66CGf71wz4Sokz8sOu4UiqKlvP9jqPc88UWwJ4mPizIQFiwntnDu3HX1N70igv3a8ZhT3jTIbVX6hFf4ere1rjY3EzhGXezZgGtivhy0NrfWXMj/Dxdr9ZiY0DXCG6dklJPeQghGNHdu1T37nw2hmpB6qFCCspr6BzueWfTQEZt0tVOHCmuYuYra0iJC+fDm8YSE2p0G6MeCOsoTkUmv/izSzNHYnRIszrD9vh+mnNNf8vnq/voL9zJFxNqbFa6GV/hboMwBy9dPpSrxwbWmjq1SVeAY7NJ/rpgOxab5H+vHuEyy7AzgWgyOhXwhQPYn+tc3CmD5q4j8vc6nED3S7n7PosqzXVRlG05KHDnswkL0lNRa2VxWm7AKZXmcHol+g8QFm3JYf3BEzx10eC6lbmKtscXYbfNWdPjyEvmzVojT2sl3F3z/i+3NWq7LcJxfR0O7Ws8fZ9PfburTdfAgPvwd8fgclNWIRVutgTvCKiZShtTbbay9bA9emT2iG7tLE3g0hYmJV+MsL2Z7bRktuBJGXiaSeUWV/HQwu08vXQXxZVmt2YWX0cPBvJs+qEZ/bn/y20u33O14ZgvQ/Y9/Y4d5dGhRmw2SXbRye/k5715XDS8Y/YPSqn4kYoaC1sPF7M5q5DUQ4X8nlNCabV9BNKzUygGXcfP8+MPfGGy8UYp+SLQwJtw16bS07iS1ZOy8pSSHcBskxRVNu4s3cl3qnPJyESe+naXSwXiDl8o3aZ+x65MmQ7u/3KbUioKO9VmK8t3HmNhWjYbDhZitUmEgIFdI7loeDe6RYfQKSyIswd2weBh7+rT2Tnf2hxhzVFKrkbYvgo/deBJQbiTNTrU6FIxOOTxtC6kKQLJ39FWPDV7sMvvyWTUub3PrcWb37G7cGyrTVJrsRFk6HgeCqVUfESNxUraoSLum7+N/LIauseGcMeZvRjfqxMje0QTafI+EWSgJDlsL1rrQG+NUvp6ay4PLdqO2Wo3HOUWV/HQou2kHipk1d58l1mbHdd0p4Q8zWbcyRps0BFi1LtUVs7X9DRjaYgAnw5QOtLAx933BPgtyKCp33F2YaXH7+/9tZncNbV3q+Voa5RSaQH7j5fxwbpMVu7OA8CoFxSU12C2ShwWLatV0q9LBGf1i/PYlqs/ZkfdftUTzemAokKMLk0V3o4eW6OUnl66q06hODBbJZ9tOFz32pUZw9P34mk28xc3tv6SKjPzrh5R755NGxDH3BXp/OXLbR47RVf4OrzXX5ms/Ymn78lX8jl/1qb2stl3vMxjWwvTspVSOZWRUrI2o4D3fs3kl335BGt7m4QFG7BYbZyoqGXt/oK6PF1HSqqbnF24+2O66yACdYOppmhuB1RR2zjyxagTXo8eW5PWoylfhIPmKHlPsxl3s41u0SH1OkFPKeWd9yqJCjFSUWuppxj9Ye7yduDTEWbdvgoy+HprLo8u3kG1toDWlUIx6uyLJF9evpfSate/NaNeYLZKDnpI0xTIKKXiBXml1Zzz71/qnOxXjE7i5snJdI00EWTQYdTrmP7P1c1O/Ojuj6lvxW59gUhzZl5zV6Q3mikAhJsMXv/x22rdRHOUvLuOy1tZPd3DhhmY22Jm4ItM1oGgVKSU1FhsdWmSKmotVNZaKK+xUlljobzGQmWtvdxRx/6+hbJq+3N5tb3OkZIqmlpLbrZJvv/9KAadICzYQKewIE5U1NYpksToEP54RgoH8isYmBDZNjfBxyil4gXzftxXp1AAFqXlsCgtx8MZJ8ktruJ/vvqdccmxhAbpEdr+HkLg1p5qlZJgvY4aJyUVbNBx2xkp5JVWo9cJDDoder3AoBPohPbsp2iyrYeLeOuXAwQZ9JgMOkxGPSFB9uNgox6T5vAMNugZnxJL99j6WVabY45yV7fYyxkEtC6qK9qN6c0V7pR8czp1b2Vtzj1si/Bef2WydsZmk1RbrFTVWqm22OzPZsfDRpXZSpX2uqrWSnmNhdIqM6XVFsqqzZTXWKg2W6mx2Kgx26ixaMcWGzVaea3V1qQicKATEBZsqEunFGEyEh5soEuEibBgA4u3uO8Tvr13MhEmIxEmA+HBhibzg3VklFLxgodmDGD6gC72iAyrDbP2Y6y1aA+rjbd+OUBZdWOzTYhRz8LUbL7YeNhFy+6paTDrqbHYeHrpbp5eutvjeQadQN/g4ax4hBBYbDYsVolZ+0M5b78phH1TIQHohL1+RY0FvU4QFxFs/wM7/bFd8eJlQ4kKMRIVaiQ6JIj4yGCOl9Y0queqU/ZVRtqWdqxPzR7MQwu3Y7ad7Gl0gF4bSTpwN/NpibnHG1kDKUU/uJ5hBRt0XD4qkZ/3Hqe0yt6xR5gM9QZkdXWNOm7+cFOdcnAoiyonhVHbgjxsQQYdkSYjkSYD4SYDIUY94cEGOoXpCTbqCDY4Hva94YMMOkKC7HVCgwyEB+sJ1ZSGQ4GEBtmPgw06j9v9bjh4wm26mmFJ3uUFOxVQub98hLvEjy9cNpRzBnXheGk1VbVWrROXSAmr0/N4Y9WBegokSK/j5snJjEuJxWy1UWuV2GwSi01itdm0Z4nFan8222zYbBKrDaw2G1ap1bVKrNJep95DSow6HUaDfbaj0/4kQth3BZTSbhKQ2F/bJEgJl45MZFxKbL3P7DAd1JhtrN6Xx33zXTudXaET0K9LBN1jQwnS6zDoBUa9jtyiKjZl2UOxHRh0gvOHdGVEjxiC9AKD3m5yNOoFJqP+ZCdhrN9hOJcH6XVez+RczTTAu5lPa/Jg2bRBS8OBi9lqY/nOY/znp4xGs9cHz+vPtAHxdd+vTZ78nm0252P7DNhssVFcZaa4sharzf49S0ldinbp+A04lVfWWiitslBabaakykxptZnSKgsF5TVU1jY/rFkA8ZHBxEeYCDHavx+TUU+I9jAZdZiCHMdOZfVe1y93KIb2nAF46gMCwdTXGpqT+0spFR/SElt2oETG+AIpJVVmK8WVZoor7R1QSVUtxZVm1mUUsCo9n/IaCyajju4xoYQE6TFrMyZzXUdq78Sqaq0ek+61BJNRd7Ljcuq0dAIEAgR1x0LYFa3jGOyZaO3v22dxUSFGJNQpAbPVxqr0fLfX7xZlwqJ1/JaGyl4bOAQiJqOOqBAjkSaj/TnEPhOI1MoitOMIk8E+S9COI0z20f+Kncf498p9p8RvvClOpf+zM0qpuCGQshQrvENqHbDFqpke6xSQpNZqt4tXa/byWoe93MlmXqOZKKvMVmo080plrWZmqbVSbbFis52cPUoajtZPjuad37PaJCVVZnQ6MOrtMyGjXkf6sbJGARtgH7FeOCyhnlnSYZJ0vA7SzDFBel1dAIjzscNcY5892B3GAHqdDr0Q6HV2ZafX/Gt6cfI69muAQacjWjNLGvSinuKsd4zD/IlHk4/i9EBlKVacMgghMOoFRj2EEPjOzVPZBKJQeINSKgqFD+noG5cpFK1FKRWFwscEcsZehcLfdLxsZQqFQqEIWJRSUSgUCoXPUEpFoVAoFD7jtAopFkLkA4fa6fKdgYJ2ura3KBl9g5Kx9QS6fHB6ydhTSuk55brGaaVU2hMhRKq3cd7thZLRNygZW0+gywdKRncoBWeZZAAABRhJREFU85dCoVAofIZSKgqFQqHwGUqptB3vtLcAXqBk9A1KxtYT6PKBktElyqeiUCgUCp+hZioKhUKh8BlKqSgUCoXCd9hTeauHuwdgAjYB24FdwNNaeSywEtivPcc4nfMYkAGkAzOcykcDv2vvvcpJ82Mw8KVWvhFIdjpnjnaN/cAcD3Lqga3Ad4Eon1Y3S2t/G5AaaHIC0cAiYC+wB5gYYPL11+6d41EK3B9IMmr1/oL9v7IT+D/s/6FAk/E+Tb5dwP2B8FsEPgDygJ1OZe0tU4pWd792blCTfWZzOtjT8YF9a4lw7dio3eAJwMvAo1r5o8BL2vEg7AooWPtCDgB67b1N2DsqASwDztfK7wbe0o6vAb50+kEd1J5jtOMYN3I+AHzBSaUSUPJp9bOAzg3KAkZO4GPgNu04CLuSCRj5GsiqB44BPQNJRiARyARCtNcLgJsCTMYh2BVKKPakuj8CfdtbRuBMYBT1lUp7y7QAuEY7fgu4q8k+s70664740H6EW4Dx2EcHCVp5ApCuHT8GPOZ0zgrtC04A9jqVXwu87VxHOzZgXwErnOto770NXOtCriTgJ2A6J5VKwMjn9H4WjZVKQMgJRGLvDEUgyufiXp4HrAs0GbErlWzsHZQB+E6TNZBkvBJ4z+n134GHA0FGIJn6SqXdZNLeKwAMWvlEYIWn36WUUvlUvEEIoRdCbMM+NV0ppdwIdJFSHgXQnuO16o4/lYMcrSxRO25YXu8cKaUFKAE6eWirIa9g/1M4bzkYSPI5kMAPQog0IcTtASZnLyAf+FAIsVUI8Z4QIiyA5GvINdhNSwSSjFLKXOCfwGHgKFAipfwhkGTEPks5UwjRSQgRClwAdA8wGR20p0ydgGKtrjeyAspR7xVSSquUcgT2GcE4IcQQD9Vd7b0qPZS39Bz7iUJcCORJKdM8yNRu8jVgspRyFHA+cI8Q4swAktOA3fTwppRyJFCB3dwQKPKdvLAQQcBsYKEH+dpFRiFEDHAxdpNMNyBMCHFDIMkopdwDvITdR7EcuxnJ0rBee8roBW0hU4tkVUqlGUgpi4HVwEzguBAiAUB7ztOq5WAf9ThIAo5o5UkuyuudI4QwAFFAoYe2nJkMzBZCZAHzgelCiM8CSL46pJRHtOc84CtgXADJmQPkaLNQsDvsRwWQfM6cD2yRUh7XXgeSjOcAmVLKfCmlGVgCTAowGZFSvi+lHCWlPFM7d3+gyajRnjIVANFaXW9ktdOUfex0fwBxQLR2HAL8ClwIzKW+A+1l7Xgw9R1oBznpQNuM3cnvcKBdoJXfQ30H2gLtOBa7nT9Ge2QCsR5kncpJn0pAyQeEARFOx79hV84BI6f23fbXjp/SZAsY+ZzknA/c7PQ6YGTE7m/chd3/KLAHP/wpkGTU6sZrzz2wR/vFBIKMNPaptKtM2GfDzo76u5vsM9ujo+5ID2AY9lDdHdhtsU9o5Z2wO8f3a8/OP4zHsUdjpKNFXmjlY7Q2DgCvcTLUz6R9eRnYIzd6OZ1zi1aegVNH4kbWqZxUKgElH3afxXZOhmY/HmhyAiOAVO27/lr7gwWMfFq9UOAEEOVUFmgyPo29o94JfIq94ws0GX8FdmP/PZ4dCPcRu4/sKGDGPnu4NQBk6qXVzdDODW6qz1RpWhQKhULhM5RPRaFQKBQ+QykVhUKhUPgMpVQUCoVC4TOUUlEoFAqFz1BKRaFQKBQ+QykVhUKhUPgMpVQUCoVC4TP+H3l14ta+nPFEAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(*simulations[23].T)\n", - "geopandas.GeoDataFrame(geometry=[state]).boundary.plot(ax=plt.gca())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Construct the simulation envelope for $G$ function." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "genv = Genv(pp.realizations[0], realizations=csrs)\n", - "genv.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.000e+00, 0.000e+00, 4.764e-01, 3.136e-01, 5.690e-02, 5.910e-02,\n", - " 2.610e-02, 8.900e-03, 1.000e-04, 1.000e-04, 4.000e-04, 1.000e-04,\n", - " 2.000e-04, 2.600e-03, 1.000e-03, 4.500e-03, 1.470e-02, 1.169e-01,\n", - " 2.012e-01, 0.000e+00])" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ripley.g_test(simulations[10], hull=state).pvalue" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since the \"observed\" $G$ is well contained by the simulation envelope, we infer that the underlying point process is a random process." - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.16, 0.6 , 0.85, 0.95, 0.97, 0.98, 0.99, 0.99, 0.99, 1. ,\n", - " 1. ])" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "genv.low # lower bound of the simulation envelope for G" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.4 , 0.79, 0.97, 1. , 1. , 1. , 1. , 1. , 1. , 1. ,\n", - " 1. ])" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "genv.high # higher bound of the simulation envelope for G" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Construct the simulation envelope for $F$ function." - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fenv = Fenv(pp.realizations[0], realizations=csrs)\n", - "fenv.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Construct the simulation envelope for $J$ function." - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "jenv = Jenv(pp.realizations[0], realizations=csrs)\n", - "jenv.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Construct the simulation envelope for $K$ function." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "kenv = Kenv(pp.realizations[0], realizations=csrs)\n", - "kenv.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Construct the simulation envelope for $L$ function." - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "lenv = Lenv(pp.realizations[0], realizations=csrs)\n", - "lenv.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 77b3e7b3739e0f300fdda8f82601d093c80eca8b Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 15:27:50 +0100 Subject: [PATCH 31/67] split distance statistics into random, geometry, and keep distance stats separate --- pointpats/distance_statistics.py | 1790 +++++++++++++----------------- pointpats/geometry.py | 351 ++++++ pointpats/random.py | 381 +++++++ 3 files changed, 1496 insertions(+), 1026 deletions(-) create mode 100644 pointpats/geometry.py create mode 100644 pointpats/random.py diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index 4269e15..82164d8 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -1,1027 +1,765 @@ -""" -Distance statistics for planar point patterns - -""" -__author__ = "Serge Rey sjsrey@gmail.com" -__all__ = ['DStatistic', 'G', 'F', 'J', 'K', 'L', 'Envelopes', 'Genv', 'Fenv', 'Jenv', 'Kenv', 'Lenv'] - -from .process import PoissonPointProcess as csr -import numpy as np -from matplotlib import pyplot as plt - - -class DStatistic(object): - """ - Abstract Base Class for distance statistics. - - Parameters - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - - Attributes - ---------- - d : array - The distance domain sequence. - - """ - def __init__(self, name): - self.name = name - - def plot(self, qq=False): - """ - Plot the distance function - - Parameters - ---------- - qq: Boolean - If False the statistic is plotted against distance. If Frue, the - quantile-quantile plot is generated, observed vs. CSR. - """ - - # assuming mpl - x = self.d - if qq: - plt.plot(self.ev, self._stat) - plt.plot(self.ev, self.ev) +import numpy +import warnings +from scipy import spatial, interpolate +from collections import namedtuple +from .geometry import ( + area as _area, + k_neighbors as _k_neighbors, + build_best_tree as _build_best_tree, +) + + +from ._deprecated_distance_statistics import G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv + +__all__ = [ + "f_function", + "g_function", + "k_function", + "j_function", + "l_function", + "f_test", + "g_test", + "k_test", + "j_test", + "l_test", +] + + +def _prepare(coordinates, support, distances, metric, hull, edge_correction): + """ + prepare the arguments to convert into a standard format + 1. cast the coordinates to a numpy array + 2. precomputed metrics must have distances provided + 3. metrics must be callable or string + 4. warn if distances are specified and metric is not default + 5. make distances a numpy.ndarray + 6. construct the support, accepting: + - num_steps -> a linspace with len(support) == num_steps + from zero to a quarter of the bounding box's smallest side + - (stop, ) -> a linspace with len(support) == 20 + from zero to stop + - (start, stop) -> a linspace with len(support) == 20 + from start to stop + - (start, stop, num_steps) -> a linspace with len(support) == num_steps + from start to stop + - numpy.ndarray -> passed through + """ + # Throw early if edge correction is requested + if edge_correction is not None: + raise NotImplementedError("Edge correction is not currently implemented.") + + # cast to coordinate array + if isinstance(coordinates, TREE_TYPES): + tree = coordinates + coordinates = tree.data + else: + coordinates = numpy.asarray(coordinates) + hull = _prepare_hull(coordinates, hull) + + # evaluate distances + if (distances is None) and metric == "precomputed": + raise ValueError( + "If metric =`precomputed` then distances must" + " be provided as a (n,n) numpy array." + ) + if not (isinstance(metric, str) or callable(metric)): + raise TypeError( + f"`metric` argument must be callable or a string. Recieved: {metric}" + ) + if distances is not None and metric != "euclidean": + warnings.warn( + "Distances were provided. The specified metric will be ignored." + " To use precomputed distances with a custom distance metric," + " do not specify a `metric` argument.", + stacklevel=2, + ) + metric = "euclidean" + + if support is None: + support = 20 + + if isinstance(support, int): # if just n_steps, use the max nnd + # this is O(n log n) for kdtrees & balltrees + tmp_tree = _build_best_tree(coordinates, metric=metric) + max_dist = _k_neighbors(tmp_tree, coordinates, 1)[0].max() + support = numpy.linspace(0, max_dist, num=support) + # otherwise, we need to build it using (start, stop, step) semantics + elif isinstance(support, tuple): + if len(support) == 1: # assuming this is with zero implicit start + support = numpy.linspace(0, support[0], num=20) # default support n bins + elif len(support) == 2: + support = numpy.linspace(*support, num=20) # default support n bins + elif len(support) == 3: + support = numpy.linspace(support[0], support[1], num=support[2]) + else: # try to use it as is + try: + support = numpy.asarray(support) + except: + raise TypeError( + "`support` must be a tuple (either (start, stop, step), (start, stop) or (stop,))," + " an int describing the number of breaks to use to evalute the function," + " or an iterable containing the breaks to use to evaluate the function." + " Recieved object of type {}: {}".format(type(support), support) + ) + + return coordinates, support, distances, metric, hull, edge_correction + + +# ------------------------------------------------------------# +# Statistical Functions # +# ------------------------------------------------------------# + + +def f_function( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + coordinates, support, distances, metric, hull, _ = _prepare( + coordinates, support, distances, metric, hull, edge_correction + ) + if distances is not None: + n = coordinates.shape[0] + if distances.ndim == 2: + k, p = distances.shape + if k == p == n: + warnings.warn( + f"A full distance matrix is not required for this function, and" + f" the intput matrix is a square {n},{n} matrix. Only the" + f" distances from p random points to their nearest neighbor within" + f" the pattern is required, as an {n},p matrix. Assuming the" + f" provided distance matrix has rows pertaining to input" + f" pattern and columns pertaining to the output points.", + stacklevel=2, + ) + distances = distances.min(axis=0) + elif k == n: + distances = distances.min(axis=0) + else: + raise ValueError( + f"Distance matrix should have the same rows as the input" + f" coordinates with p columns, where n may be equal to p." + f" Recieved an {k},{p} distance matrix for {n} coordinates" + ) + elif distances.ndim == 1: + p = len(distances) + else: + # Do 1000 empties. Users can control this by computing their own + # empty space distribution. + n_empty_points = 1000 + + randoms = poisson(hull=hull, size=(n_empty_points, 1)) + try: + tree + except NameError: + tree = _build_best_tree(coordinates, metric) + finally: + distances, _ = tree.query(randoms, k=1) + distances = distances.squeeze() + + counts, bins = numpy.histogram(distances, bins=support) + fracs = numpy.cumsum(counts) / counts.sum() + + return bins, numpy.asarray([0, *fracs]) + + +def g_function( + coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, n) or (n,) + distances from every point in the point to another point in `coordinates` + metric: str or callable + distance metric to use when building search tree + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + + coordinates, support, distances, metric, *_ = _prepare( + coordinates, support, distances, metric, None, edge_correction + ) + if distances is not None: + if distances.ndim == 2: + if distances.shape[0] == distances.shape[1] == coordinates.shape[0]: + warnings.warn( + "The full distance matrix is not required for this function," + " only the distance to the nearest neighbor within the pattern." + " Computing this and discarding the rest.", + stacklevel=2, + ) + distances = distances.min(axis=1) + else: + k, p = distances.shape + n = coordinates.shape[0] + raise ValueError( + " Input distance matrix has an invalid shape: {k},{p}." + " Distances supplied can either be 2 dimensional" + " square matrices with the same number of rows" + " as `coordinates` ({n}) or 1 dimensional and contain" + " the shortest distance from each point in " + " `coordinates` to some other point in coordinates." + ) + elif distances.ndim == 1: + if distances.shape[0] != coordinates.shape[0]: + raise ValueError( + f"Distances are not aligned with coordinates! Distance" + f" matrix must be (n_coordinates, n_coordinates), but recieved" + f" {distances.shape} instead of ({coordinates.shape[0]},)" + ) else: - plt.plot(x, self._stat, label='{}'.format(self.name)) - plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') - plt.plot(x, self.ev, label='CSR') - plt.title("{} distance function".format(self.name)) - - -class G(DStatistic): - """ - Estimates the nearest neighbor distance distribution function G for a - point pattern. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - d : array - The distance domain sequence. - G : array - The cumulative nearest neighbor distance distribution over d. - - Notes - ----- - In the analysis of planar point processes, the estimate of :math:`G` is - typically compared to the value expected from a completely spatial - random (CSR) process given as: - - .. math:: - - G(d) = 1 - e^{-\lambda \pi d^2} - - where :math:`\lambda` is the intensity (points per unit area) of the point - process and :math:`d` is distance. - - For a clustered pattern, the empirical function will be above the - expectation, while for a uniform pattern the empirical function falls below - the expectation. - - """ - - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): - res = _g(pp, intervals, dmin, dmax, d) - self.d = res[:, 0] - self.G = self._stat = res[:, 1] - self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d) - self.pp = pp - super(G, self).__init__(name="G") - - -class F(DStatistic): - """ - Estimates the empty space distribution function for a point pattern: F(d). - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intervals : int - The length of distance domain sequence. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - - Attributes - ---------- - d : array - The distance domain sequence. - G : array - The cumulative empty space nearest event distance distribution - over d. - - Notes - ----- - In the analysis of planar point processes, the estimate of :math:`F` is - typically compared to the value expected from a process that displays - complete spatial randomness (CSR): - - .. math:: - - F(d) = 1 - e^{-\lambda \pi d^2} - - where :math:`\lambda` is the intensity (points per unit area) of the point - process and :math:`d` is distance. - - The expectation is identical to the expectation for the :class:`G` function - for a CSR process. However, for a clustered pattern, the empirical G - function will be below the expectation, while for a uniform pattern the - empirical function falls above the expectation. - - """ - - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): - res = _f(pp, n, intervals, dmin, dmax, d) - self.d = res[:, 0] - self.F = self._stat = res[:, 1] - self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d) - super(F, self).__init__(name="F") - - -class J(DStatistic): - """ - Estimates the J function for a point pattern :cite:`VanLieshout1996` - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intervals : int - The length of distance domain sequence. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - - Attributes - ---------- - d : array - The distance domain sequence. - j : array - F function over d. - - Notes - ----- - - The :math:`J` function is a ratio of the hazard functions defined for - :math:`G` and :math:`F`: - - .. math:: - - J(d) = \\frac{1-G(d) }{1-F(d)} - - where :math:`G(d)` is the nearest neighbor distance distribution function - (see :class:`G`) - and :math:`F(d)` is the empty space function (see :class:`F`). - - For a CSR process the J function equals 1. Empirical values larger than 1 - are indicative of uniformity, while values below 1 suggest clustering. - - - """ - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): - res = _j(pp, n, intervals, dmin, dmax, d) - self.d = res[:, 0] - self.j = self._stat = res[:, 1] - self.ev = self.j / self.j - super(J, self).__init__(name="J") - - -class K(DStatistic): - """ - Estimates the K function for a point pattern. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - - Attributes - ---------- - d : array - The distance domain sequence. - k : array - K function over d. - - Notes - ----- - - The :math:`K` function is estimated using - - .. math:: - - \\hat{K}(h) = \\frac{a}{n (n-1)} \\sum_{i} \\sum_{j \\ne i} I(d_{i,j} \\le h) - - where :math:`a` is the area of the window, :math:`n` the number of event points, and :math:`I(d_{i,j} \le h)` is an indicator function returning 1 when points i and j are separated by a distance of :math:`h` or less, 0 otherwise. - - """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): - res = _k(pp, intervals, dmin, dmax, d) - self.d = res[:, 0] - self.k = self._stat = res[:, 1] - self.ev = np.pi * self.d * self.d - super(K, self).__init__(name="K") - - -class L(DStatistic): - """ - Estimates the :math:`L` function for a point pattern :cite:`Sullivan2010`. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - - Attributes - ---------- - d : array - The distance domain sequence. - l : array - L function over d. - - Notes - ----- - - In the analysis of planar point processes, the :math:`L` function - is a scaled version of :math:`K` function. Its estimate is also - typically compared to the value expected from a process that displays - complete spatial randomness (CSR): - - .. math:: - - L(d) = \\sqrt{\\frac{K(d)}{\\pi}}-d - - where :math:`K(d)` is the estimator for the :math:`K` function - and :math:`d` is distance. - - The expectation under the null of CSR is 0 (a horizonal line at 0). - For a clustered pattern, the empirical :math:`L` - function will be above the expectation, while for a uniform pattern the - empirical function falls below the expectation. - - """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): - res = _l(pp, intervals, dmin, dmax, d) - self.d = res[:, 0] - self.l = self._stat = res[:, 1] - super(L, self).__init__(name="L") - - def plot(self): - # assuming mpl - x = self.d - plt.plot(x, self._stat, label='{}'.format(self.name)) - plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') - plt.title("{} distance function".format(self.name)) - - -def _g(pp, intervals=10, dmin=0.0, dmax=None, d=None): - """ - Estimate the nearest neighbor distances function G. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intevals : int - Number of intervals to evaluate F over. - dmin : float - Lower limit of distance range. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be set - to maximum nearest neighor distance. - d : sequence - The distance domain sequence. If d is specified, intervals, dmin - and dmax are ignored. - - Returns - ------- - : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the point pattern. The second - column is the cumulative nearest neighbor distance distribution. - - Notes - ----- - See :class:`G`. - - """ - if d is None: - w = pp.max_nnd/intervals - if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] - cdf = [0] * len(d) - for i, d_i in enumerate(d): - smaller = [nndi for nndi in pp.nnd if nndi <= d_i] - cdf[i] = len(smaller)*1./pp.n - return np.vstack((d, cdf)).T - - -def _f(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): - """ - F empty space function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intevals : int - Number of intervals to evaluate F over. - dmin : float - Lower limit of distance range. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be set - to maximum nearest neighor distance. - d : sequence - The distance domain sequence. If d is specified, intervals, dmin - and dmax are ignored. - - Returns - ------- - : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the point pattern. The second - column is corresponding F function. - - Notes - ----- - See :class:`.F` - - """ - - # get a csr pattern in window of pp - c = csr(pp.window, n, 1, asPP=True).realizations[0] - # for each point in csr pattern find the closest point in pp and the - # associated distance - nnids, nnds = pp.knn_other(c, k=1) - - if d is None: - w = pp.max_nnd/intervals - if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] - cdf = [0] * len(d) - - for i, d_i in enumerate(d): - smaller = [nndi for nndi in nnds if nndi <= d_i] - cdf[i] = len(smaller)*1./n - return np.vstack((d, cdf)).T - - -def _j(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): - """ - J function: Ratio of hazard functions for F and G. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intevals : int - Number of intervals to evaluate F over. - dmin : float - Lower limit of distance range. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be set - to maximum nearest neighor distance. - d : sequence - The distance domain sequence. If d is specified, intervals, dmin - and dmax are ignored. - - Returns - ------- - : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the point pattern. The second - column is corresponding J function. - - Notes - ----- - See :class:`.J` - - """ - - F = _f(pp, n, intervals=intervals, dmin=dmin, dmax=dmax, d=d) - G = _g(pp, intervals=intervals, dmin=dmin, dmax=dmax, d=d) - FC = 1 - F[:, 1] - GC = 1 - G[:, 1] - last_id = len(GC) + 1 - if np.any(FC == 0): - last_id = np.where(FC == 0)[0][0] - - return np.vstack((F[:last_id, 0], GC[:last_id]/FC[:last_id])).T - - -def _k(pp, intervals=10, dmin=0.0, dmax=None, d=None): - """ - Interevent K function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intevals : int - Number of intervals to evaluate F over. - dmin : float - Lower limit of distance range. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be set to one-quarter of the minimum side of the minimum bounding rectangle. - d : sequence - The distance domain sequence. If d is specified, intervals, dmin - and dmax are ignored. - - Returns - ------- - kcdf : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the point pattern. The second - column is corresponding K function. - - Notes - ----- - - See :class:`.K` - """ - - if d is None: - w = pp.rot/intervals - if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] - den = pp.lambda_window * (pp.n - 1) - kcdf = np.asarray([(di, len(pp.tree.query_pairs(di)) * 2 / den ) for di in d]) - return kcdf - - -def _l(pp, intervals=10, dmin=0.0, dmax=None, d=None): - """ - Interevent L function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intevals : int - Number of intervals to evaluate F over. - dmin : float - Lower limit of distance range. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be set - to length of bounding box diagonal. - d : sequence - The distance domain sequence. If d is specified, intervals, dmin - and dmax are ignored. - - Returns - ------- - kf : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the point pattern. The second - column is corresponding L function. - - Notes - ----- - See :class:`.L` - - """ - - kf = _k(pp, intervals, dmin, dmax, d) - kf[:, 1] = np.sqrt(kf[:, 1] / np.pi) - kf[:, 0] - return kf - - -class Envelopes(object): - """ - Abstract base class for simulation envelopes. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - The maximum of the distance domain. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - 1-alpha is the confidence level for the envelope. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is the specific function ("G", "F", "J", - "K" or "L") over the distance domain sequence for the - observed point pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - """ - def __init__(self, *args, **kwargs): - # setup arguments - self.name = kwargs['name'] - - # calculate observed function - self.pp = args[0] - self.observed = self.calc(*args, **kwargs) - self.d = self.observed[:, 0] # domain to be used in all realizations - - # do realizations - self.mapper(kwargs['realizations']) - - def mapper(self, realizations): - reals = realizations.realizations - res = np.asarray([self.calc(reals[p]) for p in reals]) - - # When calculating the J function for all the simulations, the length - # of the returned interval domains might be different. - - if self.name == "J": - res = [] - for p in reals: - j = self.calc(reals[p]) - if j.shape[0] < self.d.shape[0]: - diff = self.d.shape[0]-j.shape[0] - for i in range(diff): - j = np.append(j, [[self.d[i+diff], np.inf]], axis=0) - res.append(j) - res = np.array(res) - - res = res[:, :, -1] - res.sort(axis=0) - nres = len(res) - self.low = res[np.int(nres * self.pct/2.)] - self.high = res[np.int(nres * (1-self.pct/2.))] - self.mean = res.mean(axis=0) - - def calc(self, *args, **kwargs): - print('implement in subclass') - - def plot(self): - # assuming mpl - x = self.d - plt.plot(x, self.observed[:, 1], label='{}'.format(self.name)) - plt.plot(x, self.mean, 'g-.', label='CSR') - plt.plot(x, self.low, 'r-.', label='LB') - plt.plot(x, self.high, 'r-.', label="UB") - plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') - plt.title("{} Simulation Envelopes".format(self.name)) - plt.legend(loc=0) - - -class Genv(Envelopes): - """ - Simulation envelope for G function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be - set to maximum nearest neighbor distance. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - which means 95% confidence level for the envelopes. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is cumulative nearest neighbor distance - distribution (G function) for the observed point pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - Examples - -------- - .. plot:: - - >>> import libpysal as ps - >>> from pointpats import Genv, PoissonPointProcess, Window - >>> from libpysal.cg import shapely_ext - >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) - >>> polys = [shp for shp in va] - >>> state = shapely_ext.cascaded_union(polys) - >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] - >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) - >>> genv_bb = Genv(pp, realizations=csrs) - >>> genv_bb.plot() - - """ - - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, - realizations=None): - self.pp = pp - self.intervals = intervals - self.dmin = dmin - self.dmax = dmax - self.d = d - self.pct = pct - super(Genv, self).__init__(pp, realizations=realizations, name="G") - - def calc(self, *args, **kwargs): - pp = args[0] - return _g(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) - - -class Fenv(Envelopes): - """ - Simulation envelope for F function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be - set to maximum nearest neighbor distance. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - which means 95% confidence level for the envelopes. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is F function for the observed point - pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - Examples - -------- - .. plot:: - - >>> import libpysal as ps - >>> from libpysal.cg import shapely_ext - >>> from pointpats import PoissonPointProcess,Window,Fenv - >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) - >>> polys = [shp for shp in va] - >>> state = shapely_ext.cascaded_union(polys) - >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] - >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) - >>> fenv = Fenv(pp, realizations=csrs) - >>> fenv.plot() - - """ - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): - self.pp = pp - self.n = n - self.intervals = intervals - self.dmin = dmin - self.dmax = dmax - self.d = d - self.pct = pct - super(Fenv, self).__init__(pp, realizations=realizations, name="F") - - def calc(self, *args, **kwargs): - pp = args[0] - return _f(pp, self.n, intervals=self.intervals, dmin=self.dmin, - dmax=self.dmax, d=self.d) - - -class Jenv(Envelopes): - """ - Simulation envelope for J function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - n : int - Number of empty space points (random points). - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be - set to maximum nearest neighbor distance. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - which means 95% confidence level for the envelopes. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is J function for the observed point - pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - Examples - -------- - .. plot:: - - >>> import libpysal as ps - >>> from pointpats import Jenv, PoissonPointProcess, Window - >>> from libpysal.cg import shapely_ext - >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) - >>> polys = [shp for shp in va] - >>> state = shapely_ext.cascaded_union(polys) - >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] - >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) - >>> jenv = Jenv(pp, realizations=csrs) - >>> jenv.plot() - - """ - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): - self.pp = pp - self.n = n - self.intervals = intervals - self.dmin = dmin - self.dmax = dmax - self.d = d - self.pct = pct - super(Jenv, self).__init__(pp, realizations=realizations, name="J") - - def calc(self, *args, **kwargs): - pp = args[0] - return _j(pp, self.n, intervals=self.intervals, dmin=self.dmin, - dmax=self.dmax, d=self.d) - - -class Kenv(Envelopes): - """ - Simulation envelope for K function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be - set to maximum nearest neighbor distance. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - which means 95% confidence level for the envelope. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is K function for the observed point - pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - Examples - -------- - .. plot:: - - >>> import libpysal as ps - >>> from pointpats import Kenv, PoissonPointProcess, Window - >>> from libpysal.cg import shapely_ext - >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) - >>> polys = [shp for shp in va] - >>> state = shapely_ext.cascaded_union(polys) - >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] - >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) - >>> kenv = Kenv(pp, realizations=csrs) - >>> kenv.plot() - - """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): - self.pp = pp - self.intervals = intervals - self.dmin = dmin - self.dmax = dmax - self.d = d - self.pct = pct - super(Kenv, self).__init__(pp, realizations=realizations, name="K") - - def calc(self, *args, **kwargs): - pp = args[0] - return _k(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) - - -class Lenv(Envelopes): - """ - Simulation envelope for L function. - - Parameters - ---------- - pp : :class:`.PointPattern` - Point Pattern instance. - intervals : int - The length of distance domain sequence. Default is 10. - dmin : float - The minimum of the distance domain. - dmax : float - Upper limit of distance range. If dmax is None, dmax will be - set to maximum nearest neighbor distance. - d : sequence - The distance domain sequence. - If d is specified, intervals, dmin and dmax are ignored. - pct : float - 1-alpha, alpha is the significance level. Default is 0.05, - which means 95% confidence level for the envelopes. - realizations: :class:`.PointProcess` - Point process instance with more than 1 realizations. - - Attributes - ---------- - name : string - Name of the function. ("G", "F", "J", "K" or "L") - observed : array - A 2-dimensional numpy array of 2 columns. The first column is - the distance domain sequence for the observed point pattern. - The second column is L function for the observed point - pattern. - low : array - A 1-dimensional numpy array. Lower bound of the simulation - envelope. - high : array - A 1-dimensional numpy array. Higher bound of the simulation - envelope. - mean : array - A 1-dimensional numpy array. Mean values of the simulation - envelope. - - Examples - -------- - .. plot:: - - >>> import libpysal as ps - >>> from pointpats import Lenv, PoissonPointProcess, Window - >>> from libpysal.cg import shapely_ext - >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) - >>> polys = [shp for shp in va] - >>> state = shapely_ext.cascaded_union(polys) - >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] - >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) - >>> lenv = Lenv(pp, realizations=csrs) - >>> lenv.plot() - - """ - - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): - self.pp = pp - self.intervals = intervals - self.dmin = dmin - self.dmax = dmax - self.d = d - self.pct = pct - super(Lenv, self).__init__(pp, realizations=realizations, name="L") - - def calc(self, *args, **kwargs): - pp = args[0] - return _l(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) + raise ValueError( + "Distances supplied can either be 2 dimensional" + " square matrices with the same number of rows" + " as `coordinates` or 1 dimensional and contain" + " the shortest distance from each point in " + " `coordinates` to some other point in coordinates." + " Input matrix was {distances.ndim} dimensioanl" + ) + else: + try: + tree + except NameError: + tree = _build_best_tree(coordinates, metric) + finally: + distances, indices = _k_neighbors(tree, coordinates, k=1) + + counts, bins = numpy.histogram(distances.squeeze(), bins=support) + fracs = numpy.cumsum(counts) / counts.sum() + + return bins, numpy.asarray([0, *fracs]) + + +def j_function( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + truncate=True, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: tuple of numpy.ndarray + precomputed distances to use to evaluate the j function. + The first must be of shape (n,n) or (n,) and is used in the g function. + the second must be of shape (n,p) or (p,) (with p possibly equal to n) + used in the f function. + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern for the f function. + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + truncate: bool (default: True) + whether or not to truncate the results when the F function reaches one. If the + F function is one but the G function is less than one, this function will return + numpy.nan values. + """ + if distances is not None: + g_distances, f_distances = distances + else: + g_distances = f_distances = None + fsupport, fstats = f_function( + coordinates, + support=support, + distances=f_distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + ) + + gsupport, gstats = g_function( + coordinates, + support=support, + distances=g_distances, + metric=metric, + edge_correction=edge_correction, + ) + + if isinstance(support, numpy.ndarray): + if not numpy.allclose(gsupport, support): + gfunction = interpolate.interp1d(gsupport, gstats, fill_value=1) + gstats = gfunction(support) + gsupport = support + if not (numpy.allclose(gsupport, fsupport)): + ffunction = interpolate.interp1d(fsupport, fstats, fill_value=1) + fstats = ffunction(gsupport) + fsupport = gsupport + + with numpy.errstate(invalid="ignore", divide="ignore"): + hazard_ratio = (1 - gstats) / (1 - fstats) + if truncate: + both_zero = (gstats == 1) & (fstats == 1) + hazard_ratio[both_zero] = 1 + is_inf = numpy.isinf(hazard_ratio) + first_inf = is_inf.argmax() + if not is_inf.any(): + first_inf = len(hazard_ratio) + if first_inf < len(hazard_ratio) and isinstance(support, int): + warnings.warn( + f"requested {support} bins to evaluate the J function, but" + f" it reaches infinity at d={gsupport[first_inf]:.4f}, meaning only" + f" {first_inf} bins will be used to characterize the J function.", + stacklevel=2, + ) + else: + first_inf = len(gsupport) + 1 + return (gsupport[:first_inf], hazard_ratio[:first_inf]) + + +def k_function( + coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + """ + coordinates, support, distances, metric, hull, edge_correction = _prepare( + coordinates, support, distances, metric, None, edge_correction + ) + n = coordinates.shape[0] + upper_tri_n = n * (n - 1) * 0.5 + if distances is not None: + if distances.ndim == 1: + if distances.shape[0] != upper_tri_n: + raise ValueError( + f"Shape of inputted distances is not square, nor is the upper triangular" + f" matrix matching the number of input points. The shape of the input matrix" + f" is {distances.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + ) + upper_tri_distances = distances + elif distances.shape[0] == distances.shape[1] == n: + upper_tri_distances = distances[numpy.triu_indices_from(distances, k=1)] + else: + raise ValueError( + f"Shape of inputted distances is not square, nor is the upper triangular" + f" matrix matching the number of input points. The shape of the input matrix" + f" is {distances.shape}, but required shape is ({upper_tri_n},) or ({n},{n})" + ) + else: + upper_tri_distances = spatial.distance.pdist(coordinates, metric=metric) + n_pairs_less_than_d = (upper_tri_distances < support.reshape(-1, 1)).sum(axis=1) + intensity = n / _area(hull) + k_estimate = ((n_pairs_less_than_d * 2) / n) / intensity + return support, k_estimate + + +def l_function( + coordinates, + support=None, + permutations=9999, + distances=None, + metric="euclidean", + edge_correction=None, + linearized=False, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + linearized : bool + whether or not to subtract l from its expected value (support) at each + distance bin. This centers the l function on zero for all distances. + Proposed by Besag (1977) #TODO: fix besag ref + """ + + support, k_estimate = k_function( + coordinates, + support=support, + distances=distances, + metric=metric, + edge_correction=edge_correction, + ) + + l = numpy.sqrt(k_estimate / numpy.pi) + + if linearized: + return support, l - support + return support, l + + +# ------------------------------------------------------------# +# Statistical Tests based on Ripley Functions # +# ------------------------------------------------------------# + +FtestResult = namedtuple( + "FtestResult", ("support", "statistic", "pvalue", "simulations") +) +GtestResult = namedtuple( + "GtestResult", ("support", "statistic", "pvalue", "simulations") +) +JtestResult = namedtuple( + "JtestResult", ("support", "statistic", "pvalue", "simulations") +) +KtestResult = namedtuple( + "KtestResult", ("support", "statistic", "pvalue", "simulations") +) +LtestResult = namedtuple( + "LtestResult", ("support", "statistic", "pvalue", "simulations") +) + +_ripley_dispatch = { + "F": (f_function, FtestResult), + "G": (g_function, GtestResult), + "J": (j_function, JtestResult), + "K": (k_function, KtestResult), + "L": (l_function, LtestResult), +} + + +def _ripley_test( + calltype, + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_simulations=False, + n_simulations=9999, + **kwargs, +): + stat_function, result_container = _ripley_dispatch.get(calltype) + core_kwargs = dict(support=support, metric=metric, edge_correction=edge_correction,) + tree = _build_best_tree(coordinates, metric=metric) + + if calltype in ("F", "J"): # these require simulations + core_kwargs["hull"] = hull + # amortize to avoid doing this every time + empty_space_points = poisson(coordinates, size=(1000, 1)) + if distances is None: + empty_space_distances, _ = _k_neighbors(tree, empty_space_points, k=1) + if calltype == "F": + distances = empty_space_distances.squeeze() + else: # calltype == 'J': + n_distances, _ = _k_neighbors(tree, coordinates, k=1) + distances = (n_distances.squeeze(), empty_space_distances.squeeze()) + else: + pass + core_kwargs.update(**kwargs) + + observed_support, observed_statistic = stat_function( + tree, distances=distances, **core_kwargs + ) + core_kwargs["support"] = observed_support + + if keep_simulations: + simulations = numpy.empty((len(observed_support), n_simulations)).T + pvalues = numpy.ones_like(observed_support) + for i_replication in range(n_simulations): + random_i = poisson(tree.data) + if calltype in ("F", "J"): + random_tree = _build_best_tree(random_i, metric) + empty_distances, _ = random_tree.query(empty_space_points, k=1) + if calltype == "F": + core_kwargs["distances"] = empty_distances.squeeze() + else: # calltype == 'J': + n_distances, _ = _k_neighbors(random_tree, random_i, k=1) + core_kwargs["distances"] = ( + n_distances.squeeze(), + empty_distances.squeeze(), + ) + rep_support, simulations_i = stat_function(random_i, **core_kwargs) + pvalues += simulations_i >= observed_statistic + if keep_simulations: + simulations[i_replication] = simulations_i + pvalues /= n_simulations + 1 + pvalues = numpy.minimum(pvalues, 1 - pvalues) + return result_container( + observed_support, + observed_statistic, + pvalues, + simulations if keep_simulations else None, + ) + + +def f_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_simulations=False, + n_simulations=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_simulations: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's simulations attribute + n_simulations: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + + return _ripley_test( + "F", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_simulations=keep_simulations, + n_simulations=n_simulations, + ) + + +def g_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_simulations=False, + n_simulations=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_simulations: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's simulations attribute + n_simulations: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "G", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_simulations=keep_simulations, + n_simulations=n_simulations, + ) + + +def j_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + truncate=True, + keep_simulations=False, + n_simulations=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_simulations: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's simulations attribute + n_simulations: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "J", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_simulations=keep_simulations, + n_simulations=n_simulations, + truncate=truncate, + ) + + +def k_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + keep_simulations=False, + n_simulations=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_simulations: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's simulations attribute + n_simulations: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "K", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + keep_simulations=keep_simulations, + n_simulations=n_simulations, + ) + + +def l_test( + coordinates, + support=None, + distances=None, + metric="euclidean", + hull=None, + edge_correction=None, + linearized=False, + keep_simulations=False, + n_simulations=9999, +): + """ + coordinates : numpy.ndarray, (n,2) + input coordinates to function + support : tuple of length 1, 2, or 3, int, or numpy.ndarray + tuple, encoding (stop,), (start, stop), or (start, stop, num) + int, encoding number of equally-spaced intervals + numpy.ndarray, used directly within numpy.histogram + distances: numpy.ndarray, (n, p) or (p,) + distances from every point in a random point set of size p + to some point in `coordinates` + metric: str or callable + distance metric to use when building search tree + hull: bounding box, scipy.spatial.ConvexHull, shapely.geometry.Polygon, or pygeos.Geometry + the hull used to construct a random sample pattern, if distances is None + edge_correction: bool or str + whether or not to conduct edge correction. Not yet implemented. + keep_simulations: bool + whether or not to keep the simulation envelopes. If so, + will be returned as the result's simulations attribute + n_simulations: int + how many simulations to conduct, assuming that the reference pattern + has complete spatial randomness. + """ + return _ripley_test( + "L", + coordinates, + support=support, + distances=distances, + metric=metric, + hull=hull, + edge_correction=edge_correction, + linearized=linearized, + keep_simulations=keep_simulations, + n_simulations=n_simulations, + ) diff --git a/pointpats/geometry.py b/pointpats/geometry.py new file mode 100644 index 0000000..6ed2a4c --- /dev/null +++ b/pointpats/geometry.py @@ -0,0 +1,351 @@ +import numpy +from scipy import spatial +from functools import singledispatch +from libpysal.cg import alpha_shape_auto +from libpysal.cg.kdtree import Arc_KDTree + + +# ------------------------------------------------------------# +# Utilities and dispatching # +# ------------------------------------------------------------# + +TREE_TYPES = (spatial.KDTree, spatial.cKDTree, Arc_KDTree) +try: + from sklearn.neighbors import KDTree, BallTree + + TREE_TYPES = (*TREE_TYPES, KDTree, BallTree) +except ModuleNotFoundError: + pass + +HULL_TYPES = ( + numpy.ndarray, + spatial.qhull.ConvexHull, +) + +## Define default dispatches and special dispatches without GEOS + +### AREA +@singledispatch +def area(shape): + """ + If a shape has an area attribute, return it. + Works for: + shapely.geometry.Polygon + """ + return shape.area + + +@area.register +def _(shape: spatial.qhull.ConvexHull): + """ + If a shape is a convex hull from scipy, + assure it's 2-dimensional and then use its volume. + """ + assert shape.points.shape[1] == 2 + return shape.volume + + +@area.register +def _(shape: numpy.ndarray): + """ + If a shape describes a bounding box, compute length times width + """ + assert len(shape) == 4, "shape is not a bounding box!" + width, height = shape[2] - shape[0], shape[3] - shape[1] + return numpy.abs(width * height) + + +### bounding box +@singledispatch +def bbox(shape): + """ + If a shape has bounds, use those. + Works for: + shapely.geometry.Polygon + """ + return bbox(numpy.asarray(shape)) + + +@bbox.register +def _(shape: numpy.ndarray): + """ + If a shape is an array of points, compute the minima/maxima + or let it pass through if it's 1 dimensional & length 4 + """ + if (shape.ndim == 1) & (len(shape) == 4): + return shape + return numpy.array([*shape.min(axis=0), *shape.max(axis=0)]) + + +@bbox.register +def _(shape: spatial.qhull.ConvexHull): + """ + For scipy.spatial.ConvexHulls, compute the bounding box from + their boundary points. + """ + return bbox(shape.points[shape.vertices]) + + +### contains + + +@singledispatch +def contains(shape, x, y): + """ + Try to use the shape's contains method directly on XY. + Does not currently work on anything. + """ + raise NotImplementedError() + return shape.contains((x, y)) + + +@contains.register +def _(shape: numpy.ndarray, x: float, y: float): + """ + If provided an ndarray, assume it's a bbox + and return whether the point falls inside + """ + xmin, xmax = shape[0], shape[2] + ymin, ymax = shape[1], shape[3] + in_x = (xmin <= x) and (x <= xmax) + in_y = (ymin <= y) and (y <= ymax) + return in_x & in_y + + +@contains.register +def _(shape: spatial.Delaunay, x: float, y: float): + """ + For points and a delaunay triangulation, use the find_simplex + method to identify whether a point is inside the triangulation. + + If the returned simplex index is -1, then the point is not + within a simplex of the triangulation. + """ + return shape.find_simplex((x, y)) > 0 + + +@contains.register +def _(shape: spatial.qhull.ConvexHull, x: float, y: float): + """ + For convex hulls, convert their exterior first into a Delaunay triangulation + and then use the delaunay dispatcher. + """ + exterior = shape.points[shape.vertices] + delaunay = spatial.Delaunay(exterior) + return contains(delaunay, x, y) + + +### centroid +@singledispatch +def centroid(shape): + """ + Assume the input is a shape with a centroid method: + """ + return shape.centroid + + +@centroid.register +def _(shape: numpy.ndarray): + """ + Handle point arrays or bounding boxes + """ + from .centrography import mean_center + + if shape.ndim == 2: + return mean_center(shape).squeeze() + elif shape.ndim == 1: + assert shape.shape == (4,) + xmin, ymin, xmax, ymax = shape + return numpy.column_stack( + (numpy.mean((xmin, xmax)), numpy.mean((ymin, ymax))) + ).squeeze() + else: + raise TypeError( + f"Centroids are only implemented in 2 dimensions," + f" but input has {shape.ndim} dimensinos" + ) + + +@centroid.register +def _(shape: spatial.qhull.ConvexHull): + """ + Treat convex hulls as arrays of points + """ + return centroid(shape.points[shape.vertices]) + + +try: + from shapely.geometry.base import BaseGeometry as _BaseGeometry + from shapely.geometry import ( + Polygon as _ShapelyPolygon, + MultiPolygon as _ShapelyMultiPolygon, + ) + from shapely.geometry import Point as _ShapelyPoint + + HULL_TYPES = (*HULL_TYPES, _ShapelyPolygon, _ShapelyMultiPolygon) + HAS_SHAPELY = True + + @contains.register + def _(shape: _BaseGeometry, x: float, y: float): + """ + If we know we're working with a shapely polygon, + then use the contains method & cast input coords to a shapely point + """ + return shape.contains(_ShapelyPoint((x, y))) + + @bbox.register + def _(shape: _BaseGeometry): + """ + If a shape is an array of points, compute the minima/maxima + or let it pass through if it's 1 dimensional & length 4 + """ + return numpy.asarray(list(shape.bounds)) + + @centroid.register + def _(shape: _BaseGeometry): + """ + Handle shapely, which requires explicit centroid extraction + """ + return numpy.asarray(list(shape.centroid.coords)).squeeze() + + +except ModuleNotFoundError: + HAS_SHAPELY = False + + +try: + import pygeos + + HAS_PYGEOS = True + HULL_TYPES = (*HULL_TYPES, pygeos.Geometry) + + @area.register + def _(shape: pygeos.Geometry): + """ + If we know we're working with a pygeos polygon, + then use pygeos.area + """ + return pygeos.area(shape) + + @contains.register + def _(shape: pygeos.Geometry, x: float, y: float): + """ + If we know we're working with a pygeos polygon, + then use pygeos.within casting the points to a pygeos object too + """ + return pygeos.within(pygeos.points((x, y)), shape) + + @bbox.register + def _(shape: pygeos.Geometry): + """ + If we know we're working with a pygeos polygon, + then use pygeos.bounds + """ + return pygeos.bounds(shape) + + @centroid.register + def _(shape: pygeos.Geometry): + """ + if we know we're working with a pygeos polygon, + then use pygeos.centroid + """ + return pygeos.coordinates.get_coordinates(pygeos.centroid(shape)).squeeze() + + +except ModuleNotFoundError: + HAS_PYGEOS = False + +# ------------------------------------------------------------# +# Constructors for trees, prepared inputs, & neighbors # +# ------------------------------------------------------------# + + +def build_best_tree(coordinates, metric): + """ + Build the best query tree that can support the application. + Chooses from: + 1. sklearn.KDTree if available and metric is simple + 2. sklearn.BallTree if available and metric is complicated + 3. scipy.spatial.cKDTree if nothing else + """ + coordinates = numpy.asarray(coordinates) + tree = spatial.cKDTree + try: + from sklearn.neighbors import KDTree, BallTree + + if metric in KDTree.valid_metrics: + tree = lambda coordinates: KDTree(coordinates, metric=metric) + elif metric in BallTree.valid_metrics: + tree = lambda coordinates: BallTree(coordinates, metric=metric) + elif callable(metric): + warnings.warn( + "Distance metrics defined in pure Python may " + " have unacceptable performance!", + stacklevel=2, + ) + tree = lambda coordinates: BallTree(coordinates, metric=metric) + else: + raise KeyError( + f"Metric {metric} not found in set of available types." + f"BallTree metrics: {BallTree.valid_metrics}, and" + f"scikit KDTree metrics: {KDTree.valid_metrics}." + ) + except ModuleNotFoundError as e: + if metric not in ("l2", "euclidean"): + raise KeyError( + f"Metric {metric} requested, but this requires" + f" scikit-learn to use. Without scikit-learn, only" + f" euclidean distance metric is supported." + ) + return tree(coordinates) + + +def k_neighbors(tree, coordinates, k, **kwargs): + """ + Query a kdtree for k neighbors, handling the self-neighbor case + in the case of coincident points. + """ + distances, indices = tree.query(coordinates, k=k + 1, **kwargs) + n, ks = distances.shape + assert ks == k + 1 + full_indices = numpy.arange(n) + other_index_mask = indices != full_indices.reshape(n, 1) + has_k_indices = other_index_mask.sum(axis=1) == (k + 1) + other_index_mask[has_k_indices, -1] = False + distances = distances[other_index_mask].reshape(n, k) + indices = indices[other_index_mask].reshape(n, k) + return distances, indices + + +def prepare_hull(coordinates, hull=None): + """ + Construct a hull from the coordinates given a hull type + Will either return: + - a bounding box array of [xmin, ymin, xmax, ymax] + - a scipy.spatial.ConvexHull object from the Qhull library + - a shapely shape using alpha_shape_auto + """ + if isinstance(hull, numpy.ndarray): + assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" + assert hull.ndim == 1, f"bounding box provided is not shaped correctly! {hull}" + return hull + if (hull is None) or (hull == "bbox"): + return bbox(coordinates) + if HAS_SHAPELY: # protect the isinstance check if import has failed + if isinstance(hull, (_ShapelyPolygon, _ShapelyMultiPolygon)): + return hull + if HAS_PYGEOS: + if isinstance(hull, pygeos.Geometry): + return hull + if isinstance(hull, str): + if hull.startswith("convex"): + return spatial.ConvexHull(coordinates) + elif hull.startswith("alpha") or hull.startswith("α"): + return alpha_shape_auto(coordinates) + elif isinstance(hull, spatial.qhull.ConvexHull): + return hull + raise ValueError( + f"Hull type {hull} not in the set of valid options:" + f" (None, 'bbox', 'convex', 'alpha', 'α', " + f" shapely.geometry.Polygon, pygeos.Geometry)" + ) diff --git a/pointpats/random.py b/pointpats/random.py new file mode 100644 index 0000000..dfe55b4 --- /dev/null +++ b/pointpats/random.py @@ -0,0 +1,381 @@ +import numpy +from .geometry import ( + spatial, + area as _area, + centroid as _centroid, + contains as _contains, + bbox as _bbox, + prepare_hull as _prepare_hull, + HULL_TYPES, +) + +# ------------------------------------------------------------ # +# Utilities # +# ------------------------------------------------------------ # + + +def parse_size_and_intensity(hull, intensity=None, size=None): + if size is None: + if intensity is not None: + # if intensity is provided, assume + # n_observations + n_observations = int(_area(hull) * intensity) + else: + # default to 100 points + n_observations = 100 + intensity = n_observations / _area(hull) + n_simulations = 1 + size = (n_observations, n_simulations) + elif isinstance(size, tuple): + if len(size) == 2 and intensity is None: + n_observations, n_simulations = size + intensity = n_observations / _area(hull) + elif len(size) == 2 and intensity is not None: + raise ValueError( + "Either intensity or size as (n observations, n simulations)" + " can be provided. Providing both creates statistical conflicts." + " between the requested intensity and implied intensity by" + " the number of observations and the area of the hull. If" + " you want to specify the intensity, use the intensity argument" + " and set size equal to the number of simulations." + ) + else: + raise ValueError( + f"Intensity and size not understood. Provide size as a tuple" + f" containing (number of observations, number of simulations)" + f" with no specified intensity, or an intensity and size equal" + f" to the number of simulations." + f" Recieved: `intensity={intensity}, size={size}`" + ) + elif isinstance(size, int): + # assume int size with specified intensity means n_simulations at x intensity + if intensity is not None: + n_observations = int(intensity * _area(hull)) + n_simulations = size + else: # assume we have one replication at the specified number of points + n_simulations = 1 + n_observations = size + intensity = n_observations / _area(hull) + else: + raise ValueError( + f"Intensity and size not understood. Provide size as a tuple" + f" containing (number of observations, number of simulations)" + f" with no specified intensity, or an intensity and size equal" + f" to the number of simulations." + f" Recieved: `intensity={intensity}, size={size}`" + ) + return (n_observations, n_simulations, intensity) + + +# ------------------------------------------------------------ # +# Distributions # +# ------------------------------------------------------------ # + + +def poisson(hull, intensity=None, size=None): + """ + Simulate a poisson random point process with a specified intensity. + + Parameters + ---------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy convexh hull + intensity : float + the number of observations per unit area in the hull to use. If provided, then + size must be an integer describing the number of replications to use. + size : tuple or int + a tuple of (n_observations, n_replications), where the first number is the number + of points to simulate in each replication and the second number is the number of + total replications. So, (10, 4) indicates 10 points, 4 times. + If an integer is provided and intensity is None, n_replications is assumed to be 1. + If size is an integer and intensity is also provided, then size indicates n_replications, + and the number of observations is computed from the intensity. + + Returns + -------- + : numpy.ndarray + either an (n_replications, n_observations, 2) or (n_observations,2) array containing + the simulated realizations. + """ + if isinstance(hull, numpy.ndarray): + if hull.shape == (4,): + hull = hull + else: + hull = _prepare_hull(hull) + n_observations, n_simulations, intensity = parse_size_and_intensity( + hull, intensity=intensity, size=size + ) + + result = numpy.empty((n_simulations, n_observations, 2)) + + bbox = _bbox(hull) + + for i_replication in range(n_simulations): + generating = True + i_observation = 0 + while i_observation < n_observations: + x, y = ( + numpy.random.uniform(bbox[0], bbox[2]), + numpy.random.uniform(bbox[1], bbox[3]), + ) + if _contains(hull, x, y): + result[i_replication, i_observation] = (x, y) + i_observation += 1 + return result.squeeze() + + +def normal(hull, center=None, cov=1, size=None): + """ + Simulate a multivariate random normal point cluster + + Parameters + ---------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy convexh hull + center : iterable of shape (2, ) + A point where the simulations will be centered. + cov : float or a numpy array of shape (2,2) + either the standard deviation of an independent and identically distributed + normal distribution, or a 2 by 2 covariance matrix expressing the covariance + of the x and y for the distribution. + size : tuple or int + a tuple of (n_observations, n_replications), where the first number is the number + of points to simulate in each replication and the second number is the number of + total replications. So, (10, 4) indicates 10 points, 4 times. + If an integer is provided, n_replications is assumed to be 1. + + Returns + -------- + : numpy.ndarray + either an (n_replications, n_observations, 2) or (n_observations,2) array containing + the simulated realizations. + """ + if isinstance(hull, numpy.ndarray): + if hull.shape == (4,): + hull = hull + else: + hull = _prepare_hull(hull) + if center is None: + center = _centroid(hull) + n_observations, n_simulations, intensity = parse_size_and_intensity( + hull, intensity=None, size=size + ) + if isinstance(cov, (int, float)): + sd = cov + cov = numpy.eye(2) * sd + elif isnstance(cov, numpy.ndarray): + if cov.ndim == 2: + assert cov.shape == (2, 2), "Bivariate covariance matrices must be 2 by 2" + elif cov.ndim == 3: + assert cov.shape[1:] == ( + 2, + 2, + ), "3-dimensional covariance matrices must have shape (n_simulations, 2,2)" + assert ( + cov.shape[0] == n_simulations + ), "3-dimensional covariance matrices must have shape (n_simulations, 2,2)" + else: + raise ValueError( + "`cov` argument must be a float (signifying a standard deviation)" + " or a 2 by 2 array expressing the covariance matrix of the " + " bivariate normal distribution." + ) + result = numpy.empty((n_simulations, n_observations, 2)) + + bbox = _bbox(hull) + + for i_replication in range(n_simulations): + generating = True + i_observation = 0 + replication_cov = cov[i] if cov.ndim == 3 else cov + while i_observation < n_observations: + x, y = numpy.random.multivariate_normal(center, cov) + if _contains(hull, x, y): + result[i_replication, i_observation] = (x, y) + i_observation += 1 + return result.squeeze() + + +def cluster_poisson( + hull, intensity=None, size=None, n_seeds=2, cluster_radius=None, +): + """ + Simulate a cluster poisson random point process with a specified intensity & number of seeds. + A cluster poisson process is a poisson process where the center of each "cluster" is + itself distributed according to a spatial poisson process. + + Parameters + ---------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy convexh hull + intensity : float + the number of observations per unit area in the hull to use. If provided, then + size must be an integer describing the number of replications to use. + size : tuple or int + a tuple of (n_observations, n_replications), where the first number is the number + of points to simulate in each replication and the second number is the number of + total replications. So, (10, 4) indicates 10 points, 4 times. + If an integer is provided and intensity is None, n_replications is assumed to be 1. + If size is an integer and intensity is also provided, then size indicates n_replications, + and the number of observations is computed from the intensity. + n_seeds : int + the number of sub-clusters to use. + cluster_radius : float or iterable + the radius of each cluster. If a float, the same radius is used for all clusters. + If an array, then there must be the same number of radii as clusters. + If None, 50% of the minimum inter-point distance is used, which may fluctuate across + replications. + + Returns + -------- + : numpy.ndarray + either an (n_replications, n_observations, 2) or (n_observations,2) array containing + the simulated realizations. + """ + hull = _prepare_hull( + hull, hull + ) # should work if input is either point set or a hull. + + if isinstance(cluster_radius, numpy.ndarray): + cluster_radii = cluster_radius.flatten() + assert len(cluster_radii) == n_seeds, ( + f"number of radii provided ({len(cluster_radii)})" + f"does not match number of clusters requested" + f" ({n_seeds})." + ) + elif isinstance(cluster_radius, (int, float)): + cluster_radii = [cluster_radius] * n_seeds + + n_observations, n_simulations, intensity = parse_size_and_intensity( + hull, intensity=intensity, size=size + ) + + result = numpy.empty((n_simulations, n_observations, 2)) + hull_area = _area(hull) + for i_replication in range(n_simulations): + seeds = poisson(hull, size=(n_seeds, n_simulations)) + if cluster_radius is None: + # default cluster radius is one half the minimum distance between seeds + cluster_radii = [spatial.distance.pdist(seeds).min() * 0.5] * n_seeds + clusters = numpy.array_split(result[i_replication], n_seeds) + for i_cluster, radius in enumerate(cluster_radii): + seed = seeds[i_cluster] + cluster_points = clusters[i_cluster] + n_in_cluster = len(cluster_points) + if n_in_cluster == 1: + clusters[i_cluster] = seed + continue + if n_in_cluster < 1: + raise Exception( + "There are too many clusters requested for the " + " inputted number of samples. Reduce `n_seeds` or" + " increase the number of sampled points." + ) + candidates = _uniform_circle( + n_in_cluster - 1, radius=radius, center=seed, hull=hull + ) + clusters[i_cluster] = numpy.row_stack((seed, candidates)) + result[i_replication] = numpy.row_stack(clusters) + return result.squeeze() + + +def cluster_normal(hull, cov=1, size=None, n_seeds=2): + hull = _prepare_hull( + hull, hull + ) # should work if input is either point set or a hull. + n_observations, n_simulations, intensity = parse_size_and_intensity( + hull, intensity=intensity, size=size + ) + + result = numpy.empty((n_simulations, n_observations, 2)) + for i_replication in range(n_simulations): + seeds = poisson(hull, size=(n_seeds, n_simulations)) + clusters = numpy.array_split(result[i_replication], n_seeds) + for i_cluster, radius in enumerate(cluster_radii): + seed = seeds[i_cluster] + cluster_points = clusters[i_cluster] + n_in_cluster = len(cluster_points) + if n_in_cluster == 1: + clusters[i_cluster] = seed + continue + if n_in_cluster < 1: + raise Exception( + "There are too many clusters requested for the " + " inputted number of samples. Reduce `n_seeds` or" + " increase the number of sampled points." + ) + candidates = normal(hull, center=seed, cov=cov, size=n_in_cluster - 1) + clusters[i_cluster] = numpy.row_stack((seed, candidates)) + result[i_replication] = numpy.row_stack(clusters) + return result.squeeze() + + +def _uniform_circle(n, radius=1.0, center=(0.0, 0.0), burn=2, verbose=False, hull=None): + """ + Generate n points within a circle of given radius. + + Parameters + ---------- + n : int + Number of points. + radius : float + Radius of the circle. + center : tuple + Coordinates of the center. + burn : int + number of coordinates to simulate at a time. This is the "chunk" + size sent to numpy.random.uniform each iteration of the rejection sampler + + Returns + ------- + : array + (n, 2), coordinates of generated points + + """ + + good = numpy.zeros((n, 2), float) + c = 0 + center_x, center_y = center + r = radius + r2 = r * r + it = 0 + while c < n: + x = numpy.random.uniform(-r, r, (burn * n, 1)) + y = numpy.random.uniform(-r, r, (burn * n, 1)) + if hull is None: + in_hull = True + else: + in_hull = numpy.asarray( + [_contains(hull, xi + center_x, yi + center_y) for xi, yi in zip(x, y)] + ) + ids, *_ = numpy.where((x * x + y * y <= r2) & in_hull) + candidates = numpy.hstack((x, y))[ids] + nc = candidates.shape[0] + need = n - c + if nc > need: # more than we need + good[c:] = candidates[:need] + else: # use them all and keep going + good[c : c + nc] = candidates + c += nc + it += 1 + if verbose: + print("Iterations: {}".format(it)) + return good + numpy.asarray(center) From b9fd24d2d376fcebe272e9351a9fa36cf57fd366 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 15:29:52 +0100 Subject: [PATCH 32/67] move ripley in --- pointpats/distance_statistics.py | 38 ++++++++++++++++---------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index 82164d8..fdf9f49 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -12,11 +12,11 @@ from ._deprecated_distance_statistics import G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv __all__ = [ - "f_function", - "g_function", - "k_function", - "j_function", - "l_function", + "f", + "g", + "k", + "j", + "l", "f_test", "g_test", "k_test", @@ -110,7 +110,7 @@ def _prepare(coordinates, support, distances, metric, hull, edge_correction): # ------------------------------------------------------------# -def f_function( +def f( coordinates, support=None, distances=None, @@ -183,7 +183,7 @@ def f_function( return bins, numpy.asarray([0, *fracs]) -def g_function( +def g( coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, ): """ @@ -255,7 +255,7 @@ def g_function( return bins, numpy.asarray([0, *fracs]) -def j_function( +def j( coordinates, support=None, distances=None, @@ -291,7 +291,7 @@ def j_function( g_distances, f_distances = distances else: g_distances = f_distances = None - fsupport, fstats = f_function( + fsupport, fstats = f( coordinates, support=support, distances=f_distances, @@ -300,7 +300,7 @@ def j_function( edge_correction=edge_correction, ) - gsupport, gstats = g_function( + gsupport, gstats = g( coordinates, support=support, distances=g_distances, @@ -339,7 +339,7 @@ def j_function( return (gsupport[:first_inf], hazard_ratio[:first_inf]) -def k_function( +def k( coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, ): """ @@ -389,7 +389,7 @@ def k_function( return support, k_estimate -def l_function( +def l( coordinates, support=None, permutations=9999, @@ -420,7 +420,7 @@ def l_function( Proposed by Besag (1977) #TODO: fix besag ref """ - support, k_estimate = k_function( + support, k_estimate = k( coordinates, support=support, distances=distances, @@ -456,11 +456,11 @@ def l_function( ) _ripley_dispatch = { - "F": (f_function, FtestResult), - "G": (g_function, GtestResult), - "J": (j_function, JtestResult), - "K": (k_function, KtestResult), - "L": (l_function, LtestResult), + "F": (f, FtestResult), + "G": (g, GtestResult), + "J": (j, JtestResult), + "K": (k, KtestResult), + "L": (l, LtestResult), } @@ -476,7 +476,7 @@ def _ripley_test( n_simulations=9999, **kwargs, ): - stat_function, result_container = _ripley_dispatch.get(calltype) + stat, result_container = _ripley_dispatch.get(calltype) core_kwargs = dict(support=support, metric=metric, edge_correction=edge_correction,) tree = _build_best_tree(coordinates, metric=metric) From bf18813b653b73b288de29286849fe9f4af7b3e3 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 15:30:15 +0100 Subject: [PATCH 33/67] move deprecated classes to deprecated_distance_statistics module --- pointpats/_deprecated_distance_statistics.py | 1027 ++++++++++++++++++ 1 file changed, 1027 insertions(+) create mode 100644 pointpats/_deprecated_distance_statistics.py diff --git a/pointpats/_deprecated_distance_statistics.py b/pointpats/_deprecated_distance_statistics.py new file mode 100644 index 0000000..4269e15 --- /dev/null +++ b/pointpats/_deprecated_distance_statistics.py @@ -0,0 +1,1027 @@ +""" +Distance statistics for planar point patterns + +""" +__author__ = "Serge Rey sjsrey@gmail.com" +__all__ = ['DStatistic', 'G', 'F', 'J', 'K', 'L', 'Envelopes', 'Genv', 'Fenv', 'Jenv', 'Kenv', 'Lenv'] + +from .process import PoissonPointProcess as csr +import numpy as np +from matplotlib import pyplot as plt + + +class DStatistic(object): + """ + Abstract Base Class for distance statistics. + + Parameters + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + + Attributes + ---------- + d : array + The distance domain sequence. + + """ + def __init__(self, name): + self.name = name + + def plot(self, qq=False): + """ + Plot the distance function + + Parameters + ---------- + qq: Boolean + If False the statistic is plotted against distance. If Frue, the + quantile-quantile plot is generated, observed vs. CSR. + """ + + # assuming mpl + x = self.d + if qq: + plt.plot(self.ev, self._stat) + plt.plot(self.ev, self.ev) + else: + plt.plot(x, self._stat, label='{}'.format(self.name)) + plt.ylabel("{}(d)".format(self.name)) + plt.xlabel('d') + plt.plot(x, self.ev, label='CSR') + plt.title("{} distance function".format(self.name)) + + +class G(DStatistic): + """ + Estimates the nearest neighbor distance distribution function G for a + point pattern. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + d : array + The distance domain sequence. + G : array + The cumulative nearest neighbor distance distribution over d. + + Notes + ----- + In the analysis of planar point processes, the estimate of :math:`G` is + typically compared to the value expected from a completely spatial + random (CSR) process given as: + + .. math:: + + G(d) = 1 - e^{-\lambda \pi d^2} + + where :math:`\lambda` is the intensity (points per unit area) of the point + process and :math:`d` is distance. + + For a clustered pattern, the empirical function will be above the + expectation, while for a uniform pattern the empirical function falls below + the expectation. + + """ + + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): + res = _g(pp, intervals, dmin, dmax, d) + self.d = res[:, 0] + self.G = self._stat = res[:, 1] + self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d) + self.pp = pp + super(G, self).__init__(name="G") + + +class F(DStatistic): + """ + Estimates the empty space distribution function for a point pattern: F(d). + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intervals : int + The length of distance domain sequence. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + + Attributes + ---------- + d : array + The distance domain sequence. + G : array + The cumulative empty space nearest event distance distribution + over d. + + Notes + ----- + In the analysis of planar point processes, the estimate of :math:`F` is + typically compared to the value expected from a process that displays + complete spatial randomness (CSR): + + .. math:: + + F(d) = 1 - e^{-\lambda \pi d^2} + + where :math:`\lambda` is the intensity (points per unit area) of the point + process and :math:`d` is distance. + + The expectation is identical to the expectation for the :class:`G` function + for a CSR process. However, for a clustered pattern, the empirical G + function will be below the expectation, while for a uniform pattern the + empirical function falls above the expectation. + + """ + + def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): + res = _f(pp, n, intervals, dmin, dmax, d) + self.d = res[:, 0] + self.F = self._stat = res[:, 1] + self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d) + super(F, self).__init__(name="F") + + +class J(DStatistic): + """ + Estimates the J function for a point pattern :cite:`VanLieshout1996` + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intervals : int + The length of distance domain sequence. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + + Attributes + ---------- + d : array + The distance domain sequence. + j : array + F function over d. + + Notes + ----- + + The :math:`J` function is a ratio of the hazard functions defined for + :math:`G` and :math:`F`: + + .. math:: + + J(d) = \\frac{1-G(d) }{1-F(d)} + + where :math:`G(d)` is the nearest neighbor distance distribution function + (see :class:`G`) + and :math:`F(d)` is the empty space function (see :class:`F`). + + For a CSR process the J function equals 1. Empirical values larger than 1 + are indicative of uniformity, while values below 1 suggest clustering. + + + """ + def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): + res = _j(pp, n, intervals, dmin, dmax, d) + self.d = res[:, 0] + self.j = self._stat = res[:, 1] + self.ev = self.j / self.j + super(J, self).__init__(name="J") + + +class K(DStatistic): + """ + Estimates the K function for a point pattern. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + + Attributes + ---------- + d : array + The distance domain sequence. + k : array + K function over d. + + Notes + ----- + + The :math:`K` function is estimated using + + .. math:: + + \\hat{K}(h) = \\frac{a}{n (n-1)} \\sum_{i} \\sum_{j \\ne i} I(d_{i,j} \\le h) + + where :math:`a` is the area of the window, :math:`n` the number of event points, and :math:`I(d_{i,j} \le h)` is an indicator function returning 1 when points i and j are separated by a distance of :math:`h` or less, 0 otherwise. + + """ + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): + res = _k(pp, intervals, dmin, dmax, d) + self.d = res[:, 0] + self.k = self._stat = res[:, 1] + self.ev = np.pi * self.d * self.d + super(K, self).__init__(name="K") + + +class L(DStatistic): + """ + Estimates the :math:`L` function for a point pattern :cite:`Sullivan2010`. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + + Attributes + ---------- + d : array + The distance domain sequence. + l : array + L function over d. + + Notes + ----- + + In the analysis of planar point processes, the :math:`L` function + is a scaled version of :math:`K` function. Its estimate is also + typically compared to the value expected from a process that displays + complete spatial randomness (CSR): + + .. math:: + + L(d) = \\sqrt{\\frac{K(d)}{\\pi}}-d + + where :math:`K(d)` is the estimator for the :math:`K` function + and :math:`d` is distance. + + The expectation under the null of CSR is 0 (a horizonal line at 0). + For a clustered pattern, the empirical :math:`L` + function will be above the expectation, while for a uniform pattern the + empirical function falls below the expectation. + + """ + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): + res = _l(pp, intervals, dmin, dmax, d) + self.d = res[:, 0] + self.l = self._stat = res[:, 1] + super(L, self).__init__(name="L") + + def plot(self): + # assuming mpl + x = self.d + plt.plot(x, self._stat, label='{}'.format(self.name)) + plt.ylabel("{}(d)".format(self.name)) + plt.xlabel('d') + plt.title("{} distance function".format(self.name)) + + +def _g(pp, intervals=10, dmin=0.0, dmax=None, d=None): + """ + Estimate the nearest neighbor distances function G. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intevals : int + Number of intervals to evaluate F over. + dmin : float + Lower limit of distance range. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be set + to maximum nearest neighor distance. + d : sequence + The distance domain sequence. If d is specified, intervals, dmin + and dmax are ignored. + + Returns + ------- + : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the point pattern. The second + column is the cumulative nearest neighbor distance distribution. + + Notes + ----- + See :class:`G`. + + """ + if d is None: + w = pp.max_nnd/intervals + if dmax: + w = dmax/intervals + d = [w*i for i in range(intervals + 2)] + cdf = [0] * len(d) + for i, d_i in enumerate(d): + smaller = [nndi for nndi in pp.nnd if nndi <= d_i] + cdf[i] = len(smaller)*1./pp.n + return np.vstack((d, cdf)).T + + +def _f(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): + """ + F empty space function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intevals : int + Number of intervals to evaluate F over. + dmin : float + Lower limit of distance range. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be set + to maximum nearest neighor distance. + d : sequence + The distance domain sequence. If d is specified, intervals, dmin + and dmax are ignored. + + Returns + ------- + : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the point pattern. The second + column is corresponding F function. + + Notes + ----- + See :class:`.F` + + """ + + # get a csr pattern in window of pp + c = csr(pp.window, n, 1, asPP=True).realizations[0] + # for each point in csr pattern find the closest point in pp and the + # associated distance + nnids, nnds = pp.knn_other(c, k=1) + + if d is None: + w = pp.max_nnd/intervals + if dmax: + w = dmax/intervals + d = [w*i for i in range(intervals + 2)] + cdf = [0] * len(d) + + for i, d_i in enumerate(d): + smaller = [nndi for nndi in nnds if nndi <= d_i] + cdf[i] = len(smaller)*1./n + return np.vstack((d, cdf)).T + + +def _j(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): + """ + J function: Ratio of hazard functions for F and G. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intevals : int + Number of intervals to evaluate F over. + dmin : float + Lower limit of distance range. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be set + to maximum nearest neighor distance. + d : sequence + The distance domain sequence. If d is specified, intervals, dmin + and dmax are ignored. + + Returns + ------- + : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the point pattern. The second + column is corresponding J function. + + Notes + ----- + See :class:`.J` + + """ + + F = _f(pp, n, intervals=intervals, dmin=dmin, dmax=dmax, d=d) + G = _g(pp, intervals=intervals, dmin=dmin, dmax=dmax, d=d) + FC = 1 - F[:, 1] + GC = 1 - G[:, 1] + last_id = len(GC) + 1 + if np.any(FC == 0): + last_id = np.where(FC == 0)[0][0] + + return np.vstack((F[:last_id, 0], GC[:last_id]/FC[:last_id])).T + + +def _k(pp, intervals=10, dmin=0.0, dmax=None, d=None): + """ + Interevent K function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intevals : int + Number of intervals to evaluate F over. + dmin : float + Lower limit of distance range. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be set to one-quarter of the minimum side of the minimum bounding rectangle. + d : sequence + The distance domain sequence. If d is specified, intervals, dmin + and dmax are ignored. + + Returns + ------- + kcdf : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the point pattern. The second + column is corresponding K function. + + Notes + ----- + + See :class:`.K` + """ + + if d is None: + w = pp.rot/intervals + if dmax: + w = dmax/intervals + d = [w*i for i in range(intervals + 2)] + den = pp.lambda_window * (pp.n - 1) + kcdf = np.asarray([(di, len(pp.tree.query_pairs(di)) * 2 / den ) for di in d]) + return kcdf + + +def _l(pp, intervals=10, dmin=0.0, dmax=None, d=None): + """ + Interevent L function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intevals : int + Number of intervals to evaluate F over. + dmin : float + Lower limit of distance range. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be set + to length of bounding box diagonal. + d : sequence + The distance domain sequence. If d is specified, intervals, dmin + and dmax are ignored. + + Returns + ------- + kf : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the point pattern. The second + column is corresponding L function. + + Notes + ----- + See :class:`.L` + + """ + + kf = _k(pp, intervals, dmin, dmax, d) + kf[:, 1] = np.sqrt(kf[:, 1] / np.pi) - kf[:, 0] + return kf + + +class Envelopes(object): + """ + Abstract base class for simulation envelopes. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + The maximum of the distance domain. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + 1-alpha is the confidence level for the envelope. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is the specific function ("G", "F", "J", + "K" or "L") over the distance domain sequence for the + observed point pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + """ + def __init__(self, *args, **kwargs): + # setup arguments + self.name = kwargs['name'] + + # calculate observed function + self.pp = args[0] + self.observed = self.calc(*args, **kwargs) + self.d = self.observed[:, 0] # domain to be used in all realizations + + # do realizations + self.mapper(kwargs['realizations']) + + def mapper(self, realizations): + reals = realizations.realizations + res = np.asarray([self.calc(reals[p]) for p in reals]) + + # When calculating the J function for all the simulations, the length + # of the returned interval domains might be different. + + if self.name == "J": + res = [] + for p in reals: + j = self.calc(reals[p]) + if j.shape[0] < self.d.shape[0]: + diff = self.d.shape[0]-j.shape[0] + for i in range(diff): + j = np.append(j, [[self.d[i+diff], np.inf]], axis=0) + res.append(j) + res = np.array(res) + + res = res[:, :, -1] + res.sort(axis=0) + nres = len(res) + self.low = res[np.int(nres * self.pct/2.)] + self.high = res[np.int(nres * (1-self.pct/2.))] + self.mean = res.mean(axis=0) + + def calc(self, *args, **kwargs): + print('implement in subclass') + + def plot(self): + # assuming mpl + x = self.d + plt.plot(x, self.observed[:, 1], label='{}'.format(self.name)) + plt.plot(x, self.mean, 'g-.', label='CSR') + plt.plot(x, self.low, 'r-.', label='LB') + plt.plot(x, self.high, 'r-.', label="UB") + plt.ylabel("{}(d)".format(self.name)) + plt.xlabel('d') + plt.title("{} Simulation Envelopes".format(self.name)) + plt.legend(loc=0) + + +class Genv(Envelopes): + """ + Simulation envelope for G function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be + set to maximum nearest neighbor distance. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + which means 95% confidence level for the envelopes. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is cumulative nearest neighbor distance + distribution (G function) for the observed point pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + Examples + -------- + .. plot:: + + >>> import libpysal as ps + >>> from pointpats import Genv, PoissonPointProcess, Window + >>> from libpysal.cg import shapely_ext + >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) + >>> polys = [shp for shp in va] + >>> state = shapely_ext.cascaded_union(polys) + >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] + >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) + >>> genv_bb = Genv(pp, realizations=csrs) + >>> genv_bb.plot() + + """ + + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, + realizations=None): + self.pp = pp + self.intervals = intervals + self.dmin = dmin + self.dmax = dmax + self.d = d + self.pct = pct + super(Genv, self).__init__(pp, realizations=realizations, name="G") + + def calc(self, *args, **kwargs): + pp = args[0] + return _g(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, + d=self.d) + + +class Fenv(Envelopes): + """ + Simulation envelope for F function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be + set to maximum nearest neighbor distance. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + which means 95% confidence level for the envelopes. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is F function for the observed point + pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + Examples + -------- + .. plot:: + + >>> import libpysal as ps + >>> from libpysal.cg import shapely_ext + >>> from pointpats import PoissonPointProcess,Window,Fenv + >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) + >>> polys = [shp for shp in va] + >>> state = shapely_ext.cascaded_union(polys) + >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] + >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) + >>> fenv = Fenv(pp, realizations=csrs) + >>> fenv.plot() + + """ + def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, + pct=0.05, realizations=None): + self.pp = pp + self.n = n + self.intervals = intervals + self.dmin = dmin + self.dmax = dmax + self.d = d + self.pct = pct + super(Fenv, self).__init__(pp, realizations=realizations, name="F") + + def calc(self, *args, **kwargs): + pp = args[0] + return _f(pp, self.n, intervals=self.intervals, dmin=self.dmin, + dmax=self.dmax, d=self.d) + + +class Jenv(Envelopes): + """ + Simulation envelope for J function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + n : int + Number of empty space points (random points). + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be + set to maximum nearest neighbor distance. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + which means 95% confidence level for the envelopes. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is J function for the observed point + pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + Examples + -------- + .. plot:: + + >>> import libpysal as ps + >>> from pointpats import Jenv, PoissonPointProcess, Window + >>> from libpysal.cg import shapely_ext + >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) + >>> polys = [shp for shp in va] + >>> state = shapely_ext.cascaded_union(polys) + >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] + >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) + >>> jenv = Jenv(pp, realizations=csrs) + >>> jenv.plot() + + """ + def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, + pct=0.05, realizations=None): + self.pp = pp + self.n = n + self.intervals = intervals + self.dmin = dmin + self.dmax = dmax + self.d = d + self.pct = pct + super(Jenv, self).__init__(pp, realizations=realizations, name="J") + + def calc(self, *args, **kwargs): + pp = args[0] + return _j(pp, self.n, intervals=self.intervals, dmin=self.dmin, + dmax=self.dmax, d=self.d) + + +class Kenv(Envelopes): + """ + Simulation envelope for K function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be + set to maximum nearest neighbor distance. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + which means 95% confidence level for the envelope. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is K function for the observed point + pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + Examples + -------- + .. plot:: + + >>> import libpysal as ps + >>> from pointpats import Kenv, PoissonPointProcess, Window + >>> from libpysal.cg import shapely_ext + >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) + >>> polys = [shp for shp in va] + >>> state = shapely_ext.cascaded_union(polys) + >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] + >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) + >>> kenv = Kenv(pp, realizations=csrs) + >>> kenv.plot() + + """ + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, + pct=0.05, realizations=None): + self.pp = pp + self.intervals = intervals + self.dmin = dmin + self.dmax = dmax + self.d = d + self.pct = pct + super(Kenv, self).__init__(pp, realizations=realizations, name="K") + + def calc(self, *args, **kwargs): + pp = args[0] + return _k(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, + d=self.d) + + +class Lenv(Envelopes): + """ + Simulation envelope for L function. + + Parameters + ---------- + pp : :class:`.PointPattern` + Point Pattern instance. + intervals : int + The length of distance domain sequence. Default is 10. + dmin : float + The minimum of the distance domain. + dmax : float + Upper limit of distance range. If dmax is None, dmax will be + set to maximum nearest neighbor distance. + d : sequence + The distance domain sequence. + If d is specified, intervals, dmin and dmax are ignored. + pct : float + 1-alpha, alpha is the significance level. Default is 0.05, + which means 95% confidence level for the envelopes. + realizations: :class:`.PointProcess` + Point process instance with more than 1 realizations. + + Attributes + ---------- + name : string + Name of the function. ("G", "F", "J", "K" or "L") + observed : array + A 2-dimensional numpy array of 2 columns. The first column is + the distance domain sequence for the observed point pattern. + The second column is L function for the observed point + pattern. + low : array + A 1-dimensional numpy array. Lower bound of the simulation + envelope. + high : array + A 1-dimensional numpy array. Higher bound of the simulation + envelope. + mean : array + A 1-dimensional numpy array. Mean values of the simulation + envelope. + + Examples + -------- + .. plot:: + + >>> import libpysal as ps + >>> from pointpats import Lenv, PoissonPointProcess, Window + >>> from libpysal.cg import shapely_ext + >>> va = ps.io.open(ps.examples.get_path("vautm17n.shp")) + >>> polys = [shp for shp in va] + >>> state = shapely_ext.cascaded_union(polys) + >>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0] + >>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True) + >>> lenv = Lenv(pp, realizations=csrs) + >>> lenv.plot() + + """ + + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, + pct=0.05, realizations=None): + self.pp = pp + self.intervals = intervals + self.dmin = dmin + self.dmax = dmax + self.d = d + self.pct = pct + super(Lenv, self).__init__(pp, realizations=realizations, name="L") + + def calc(self, *args, **kwargs): + pp = args[0] + return _l(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, + d=self.d) From 991e0c40280d654b0aaa9f26220d09bc0872f12a Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:00:54 +0100 Subject: [PATCH 34/67] use different defaults for the normal simulators given their structure --- pointpats/random.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/pointpats/random.py b/pointpats/random.py index dfe55b4..d93b113 100644 --- a/pointpats/random.py +++ b/pointpats/random.py @@ -130,7 +130,7 @@ def poisson(hull, intensity=None, size=None): return result.squeeze() -def normal(hull, center=None, cov=1, size=None): +def normal(hull, center=None, cov=None, size=None): """ Simulate a multivariate random normal point cluster @@ -172,6 +172,12 @@ def normal(hull, center=None, cov=1, size=None): n_observations, n_simulations, intensity = parse_size_and_intensity( hull, intensity=None, size=size ) + if cov is None: + bbox = _bbox(hull) + width = bbox[2] - bbox[0] + height = bbox[3] - bbox[1] + cov = numpy.maximum(width / 2, height / 2) ** 2 + if isinstance(cov, (int, float)): sd = cov cov = numpy.eye(2) * sd @@ -192,6 +198,7 @@ def normal(hull, center=None, cov=1, size=None): " or a 2 by 2 array expressing the covariance matrix of the " " bivariate normal distribution." ) + result = numpy.empty((n_simulations, n_observations, 2)) bbox = _bbox(hull) @@ -297,20 +304,22 @@ def cluster_poisson( return result.squeeze() -def cluster_normal(hull, cov=1, size=None, n_seeds=2): - hull = _prepare_hull( - hull, hull - ) # should work if input is either point set or a hull. +def cluster_normal(hull, cov=None, size=None, n_seeds=2): + if isinstance(hull, numpy.ndarray): + if hull.shape == (4,): + hull = hull + else: + hull = _prepare_hull(hull) n_observations, n_simulations, intensity = parse_size_and_intensity( - hull, intensity=intensity, size=size + hull, intensity=None, size=size ) - result = numpy.empty((n_simulations, n_observations, 2)) for i_replication in range(n_simulations): seeds = poisson(hull, size=(n_seeds, n_simulations)) + if cov is None: + cov = spatial.distance.pdist(seeds).mean() ** 2 clusters = numpy.array_split(result[i_replication], n_seeds) - for i_cluster, radius in enumerate(cluster_radii): - seed = seeds[i_cluster] + for i_cluster, seed in enumerate(seeds): cluster_points = clusters[i_cluster] n_in_cluster = len(cluster_points) if n_in_cluster == 1: From 3782ac5e02a7ee58efe4d8567bc4d843fe83e08e Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:01:08 +0100 Subject: [PATCH 35/67] use more numerically-stable normal simulator --- pointpats/random.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pointpats/random.py b/pointpats/random.py index d93b113..6523468 100644 --- a/pointpats/random.py +++ b/pointpats/random.py @@ -207,8 +207,12 @@ def normal(hull, center=None, cov=None, size=None): generating = True i_observation = 0 replication_cov = cov[i] if cov.ndim == 3 else cov + replication_sd = numpy.diagonal(replication_cov) ** 0.5 + replication_cor = (1 / replication_sd) * replication_cov * (1 / replication_sd) + while i_observation < n_observations: - x, y = numpy.random.multivariate_normal(center, cov) + candidate = numpy.random.multivariate_normal((0, 0), replication_cor) + x, y = center + candidate * replication_sd if _contains(hull, x, y): result[i_replication, i_observation] = (x, y) i_observation += 1 From b482fa9aadad5d252a48a4296ca497b5feac3fad Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:01:21 +0100 Subject: [PATCH 36/67] hull is infact not idempotent --- pointpats/random.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pointpats/random.py b/pointpats/random.py index 6523468..c3b0047 100644 --- a/pointpats/random.py +++ b/pointpats/random.py @@ -261,9 +261,11 @@ def cluster_poisson( either an (n_replications, n_observations, 2) or (n_observations,2) array containing the simulated realizations. """ - hull = _prepare_hull( - hull, hull - ) # should work if input is either point set or a hull. + if isinstance(hull, numpy.ndarray): + if hull.shape == (4,): + hull = hull + else: + hull = _prepare_hull(hull) if isinstance(cluster_radius, numpy.ndarray): cluster_radii = cluster_radius.flatten() From 71c0242aa4cc3d2ef75fd1ce879f1b31189f9c78 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:01:36 +0100 Subject: [PATCH 37/67] fix contains check zip --- pointpats/random.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pointpats/random.py b/pointpats/random.py index c3b0047..86da75f 100644 --- a/pointpats/random.py +++ b/pointpats/random.py @@ -379,9 +379,12 @@ def _uniform_circle(n, radius=1.0, center=(0.0, 0.0), burn=2, verbose=False, hul in_hull = True else: in_hull = numpy.asarray( - [_contains(hull, xi + center_x, yi + center_y) for xi, yi in zip(x, y)] - ) - ids, *_ = numpy.where((x * x + y * y <= r2) & in_hull) + [ + _contains(hull, xi + center_x, yi + center_y) + for xi, yi in numpy.column_stack((x, y)) + ] + ).reshape(-1, 1) + ids, *_ = numpy.where(((x * x + y * y) <= r2) & in_hull) candidates = numpy.hstack((x, y))[ids] nc = candidates.shape[0] need = n - c From fd7bca84c10e6b75ce51e55f417e0f0801f9c48d Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:08:45 +0100 Subject: [PATCH 38/67] flesh out docstrings in random.py --- pointpats/random.py | 67 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 65 insertions(+), 2 deletions(-) diff --git a/pointpats/random.py b/pointpats/random.py index 86da75f..b447956 100644 --- a/pointpats/random.py +++ b/pointpats/random.py @@ -15,6 +15,34 @@ def parse_size_and_intensity(hull, intensity=None, size=None): + """ + Given a hull, an intensity, and a size int/tuple, correctly + compute the resulting missing quantities. Defaults to 100 points in one + replication, meaning the intensity will be computed on the fly + if nothing is provided. + + Parameters + ---------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy convexh hull + intensity : float + the number of observations per unit area in the hull to use. If provided, + then the number of observations is determined using the intensity * area(hull) and + the size is assumed to represent n_replications (if provided). + size : tuple or int + a tuple of (n_observations, n_replications), where the first number is the number + of points to simulate in each replication and the second number is the number of + total replications. So, (10, 4) indicates 10 points, 4 times. + If an integer is provided and intensity is None, n_replications is assumed to be 1. + If size is an integer and intensity is also provided, then size indicates n_replications, + and the number of observations is computed on the fly using intensity and area. + """ if size is None: if intensity is not None: # if intensity is provided, assume @@ -146,10 +174,11 @@ def normal(hull, center=None, cov=None, size=None): - a scipy convexh hull center : iterable of shape (2, ) A point where the simulations will be centered. - cov : float or a numpy array of shape (2,2) + cov : float or a numpy array of shape (2,2) either the standard deviation of an independent and identically distributed normal distribution, or a 2 by 2 covariance matrix expressing the covariance - of the x and y for the distribution. + of the x and y for the distribution. Default is half of the width or height + of the hull's bounding box, whichever is larger. size : tuple or int a tuple of (n_observations, n_replications), where the first number is the number of points to simulate in each replication and the second number is the number of @@ -311,6 +340,40 @@ def cluster_poisson( def cluster_normal(hull, cov=None, size=None, n_seeds=2): + """ + Simulate a cluster poisson random point process with a specified intensity & number of seeds. + A cluster poisson process is a poisson process where the center of each "cluster" is + itself distributed according to a spatial poisson process. + + Parameters + ---------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy convexh hull + cov : float, int, or numpy.ndarray of shape (2,2) + The covariance structure for clusters. By default, this is the squared + average distance between cluster seeds. + size : tuple or int + a tuple of (n_observations, n_replications), where the first number is the number + of points to simulate in each replication and the second number is the number of + total replications. So, (10, 4) indicates 10 points, 4 times. + If an integer is provided and intensity is None, n_replications is assumed to be 1. + If size is an integer and intensity is also provided, then size indicates n_replications, + and the number of observations is computed from the intensity. + n_seeds : int + the number of sub-clusters to use. + + Returns + -------- + : numpy.ndarray + either an (n_replications, n_observations, 2) or (n_observations,2) array containing + the simulated realizations. + """ if isinstance(hull, numpy.ndarray): if hull.shape == (4,): hull = hull From 7b48ef80ee116a1a87f5f6aee615bfc274b0e271 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:35:54 +0100 Subject: [PATCH 39/67] add docs to geometry --- pointpats/geometry.py | 61 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/pointpats/geometry.py b/pointpats/geometry.py index 6ed2a4c..e0ead1d 100644 --- a/pointpats/geometry.py +++ b/pointpats/geometry.py @@ -267,6 +267,31 @@ def build_best_tree(coordinates, metric): 1. sklearn.KDTree if available and metric is simple 2. sklearn.BallTree if available and metric is complicated 3. scipy.spatial.cKDTree if nothing else + + Parameters + ---------- + coordinates : numpy.ndarray + array of coordinates over which to build the tree. + metric : string or callable + either a metric supported by sklearn KDTrees or BallTrees, or a callabe function. + If sklearn is not installed, then this must be euclidean. + + Returns + ------- + : a distance tree + a KDTree from either scikit-learn or scipy, or a BallTree if available. + + Notes + ----- + This will return a scikit-learn KDTree if the metric is supported and + sklearn can be imported. + If the metric is not supported by KDTree, a BallTree will be used if + sklearn can be imported. + If the metric is a user-defined callable function, a Ball Tree will be used + if sklearn can be imported. + If sklearn can't be imported, then a scipy.spatial.KDTree will be used + if the metric is euclidean. + Otherwise, an error will be raised. """ coordinates = numpy.asarray(coordinates) tree = spatial.cKDTree @@ -304,6 +329,23 @@ def k_neighbors(tree, coordinates, k, **kwargs): """ Query a kdtree for k neighbors, handling the self-neighbor case in the case of coincident points. + + Arguments + ---------- + tree : distance tree + a distance tree, such as a scipy KDTree or sklearn KDTree or BallTree + that supports a query argument. + coordinates : numpy.ndarray of shape n,2 + coordinates to query for their neighbors within the tree. + k : int + number of neighbors to query in the tree + **kwargs : mappable + arguments that may need to be passed down to the tree.query() function + + Returns + -------- + a tuple of (distances, indices) that is assured to not include the point itself + in its query result. """ distances, indices = tree.query(coordinates, k=k + 1, **kwargs) n, ks = distances.shape @@ -324,6 +366,25 @@ def prepare_hull(coordinates, hull=None): - a bounding box array of [xmin, ymin, xmax, ymax] - a scipy.spatial.ConvexHull object from the Qhull library - a shapely shape using alpha_shape_auto + + Parameters + --------- + coordinates : numpy.ndarray of shape (n,2) + Points to use to construct a hull + hull : string or a pre-computed hull + A string denoting what kind of hull to compute (if required) or a hull + that has already been computed + + Returns + -------- + hull : A geometry-like object + This encodes the "space" in which to simulate the normal pattern. All points will + lie within this hull. Supported values are: + - a bounding box encoded in a numpy array as numpy.array([xmin, ymin, xmax, ymax]) + - an (N,2) array of points for which the bounding box will be computed & used + - a shapely polygon/multipolygon + - a pygeos geometry + - a scipy.spatial.qhull.ConvexHull """ if isinstance(hull, numpy.ndarray): assert len(hull) == 4, f"bounding box provided is not shaped correctly! {hull}" From 0e48cb266d2167095715fcb908b8785d4df60e7d Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:36:07 +0100 Subject: [PATCH 40/67] finalize docstrings in new distance_statistics module --- pointpats/distance_statistics.py | 155 ++++++++++++++++++++++++++++++- 1 file changed, 152 insertions(+), 3 deletions(-) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index fdf9f49..0f165ee 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -119,7 +119,14 @@ def f( edge_correction=None, ): """ - coordinates : numpy.ndarray, (n,2) + Ripley's F function + + The so-called "empty space" function, this is the cumulative density function of + the distances from a random set of points to the known points in the pattern. + + Parameters + ---------- + coordinates : numpy.ndarray of shape (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray tuple, encoding (stop,), (start, stop), or (start, stop, num) @@ -134,6 +141,11 @@ def f( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. + + Returns + ------- + a tuple containing the support values used to evalute the function + and the values of the function at each distance value in the support. """ coordinates, support, distances, metric, hull, _ = _prepare( coordinates, support, distances, metric, hull, edge_correction @@ -187,7 +199,14 @@ def g( coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, ): """ - coordinates : numpy.ndarray, (n,2) + Ripley's G function + + The G function is computed from the cumulative density function of the nearest neighbor + distances between points in the pattern. + + Parameters + ----------- + coordinates : numpy.ndarray of shape (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray tuple, encoding (stop,), (start, stop), or (start, stop, num) @@ -199,6 +218,12 @@ def g( distance metric to use when building search tree edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. + + Returns + ------- + a tuple containing the support values used to evalute the function + and the values of the function at each distance value in the support. + """ coordinates, support, distances, metric, *_ = _prepare( @@ -265,6 +290,12 @@ def j( truncate=True, ): """ + Ripely's J function + + The so-called "spatial hazard" function, this is a function relating the F and G functions. + + Parameters + ----------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -286,6 +317,11 @@ def j( whether or not to truncate the results when the F function reaches one. If the F function is one but the G function is less than one, this function will return numpy.nan values. + + Returns + ------- + a tuple containing the support values used to evalute the function + and the values of the function at each distance value in the support. """ if distances is not None: g_distances, f_distances = distances @@ -343,6 +379,11 @@ def k( coordinates, support=None, distances=None, metric="euclidean", edge_correction=None, ): """ + Ripley's K function + + This function counts the number of pairs of points that are closer than a given distance. + As d increases, K approaches the number of point pairs. + coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -358,6 +399,11 @@ def k( the hull used to construct a random sample pattern, if distances is None edge_correction: bool or str whether or not to conduct edge correction. Not yet implemented. + + Returns + ------- + a tuple containing the support values used to evalute the function + and the values of the function at each distance value in the support. """ coordinates, support, distances, metric, hull, edge_correction = _prepare( coordinates, support, distances, metric, None, edge_correction @@ -399,6 +445,14 @@ def l( linearized=False, ): """ + Ripley's L function + + This is a scaled and shifted version of the K function that accounts for the K function's + increasing expected value as distances increase. This means that the L function, for a + completely random pattern, should be close to zero at all distance values in the support. + + Parameters + ---------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -417,7 +471,12 @@ def l( linearized : bool whether or not to subtract l from its expected value (support) at each distance bin. This centers the l function on zero for all distances. - Proposed by Besag (1977) #TODO: fix besag ref + Proposed by Besag (1977) + + Returns + ------- + a tuple containing the support values used to evalute the function + and the values of the function at each distance value in the support. """ support, k_estimate = k( @@ -541,6 +600,16 @@ def f_test( n_simulations=9999, ): """ + Ripley's F function + + The so-called "empty space" function, this is the cumulative density function of + the distances from a random set of points to the known points in the pattern. + + When the estimated statistic is larger than simulated values at a given distance, then + the pattern is considered "dispersed" or "regular" + + Parameters + ----------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -562,6 +631,15 @@ def f_test( n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. + + Returns + ------- + a named tuple with properties + - support, the exact distance values used to evalute the statistic + - statistic, the values of the statistic at each distance + - pvalue, the percent of simulations that were as extreme as the observed value + - simulations, the distribution of simulated statistics (shaped (n_simulations, n_support_points)) + or None if keep_simulations=False (which is the default) """ return _ripley_test( @@ -588,6 +666,15 @@ def g_test( n_simulations=9999, ): """ + Ripley's G function + + The G function is computed from the cumulative density function of the nearest neighbor + distances between points in the pattern. + + When the G function is below the simulated values, it suggests dispersion. + + Parameters + ---------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -609,6 +696,15 @@ def g_test( n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. + + Returns + ------- + a named tuple with properties + - support, the exact distance values used to evalute the statistic + - statistic, the values of the statistic at each distance + - pvalue, the percent of simulations that were as extreme as the observed value + - simulations, the distribution of simulated statistics (shaped (n_simulations, n_support_points)) + or None if keep_simulations=False (which is the default) """ return _ripley_test( "G", @@ -635,6 +731,13 @@ def j_test( n_simulations=9999, ): """ + Ripley's J function + + The so-called "spatial hazard" function, this is a function relating the F and G functions. + + When the J function is consistently below 1, then it indicates clustering. + When consistently above 1, it suggests dispersion. + coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -656,6 +759,15 @@ def j_test( n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. + + Returns + ------- + a named tuple with properties + - support, the exact distance values used to evalute the statistic + - statistic, the values of the statistic at each distance + - pvalue, the percent of simulations that were as extreme as the observed value + - simulations, the distribution of simulated statistics (shaped (n_simulations, n_support_points)) + or None if keep_simulations=False (which is the default) """ return _ripley_test( "J", @@ -682,6 +794,15 @@ def k_test( n_simulations=9999, ): """ + Ripley's K function + + This function counts the number of pairs of points that are closer than a given distance. + As d increases, K approaches the number of point pairs. + + When the K function is below simulated values, it suggests that the pattern is dispersed. + + Parameters + ---------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -703,6 +824,15 @@ def k_test( n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. + + Returns + ------- + a named tuple with properties + - support, the exact distance values used to evalute the statistic + - statistic, the values of the statistic at each distance + - pvalue, the percent of simulations that were as extreme as the observed value + - simulations, the distribution of simulated statistics (shaped (n_simulations, n_support_points)) + or None if keep_simulations=False (which is the default) """ return _ripley_test( "K", @@ -729,6 +859,16 @@ def l_test( n_simulations=9999, ): """ + Ripley's L function + + This is a scaled and shifted version of the K function that accounts for the K function's + increasing expected value as distances increase. This means that the L function, for a + completely random pattern, should be close to zero at all distance values in the support. + + When the L function is negative, this suggests dispersion. + + Parameters + ---------- coordinates : numpy.ndarray, (n,2) input coordinates to function support : tuple of length 1, 2, or 3, int, or numpy.ndarray @@ -750,6 +890,15 @@ def l_test( n_simulations: int how many simulations to conduct, assuming that the reference pattern has complete spatial randomness. + + Returns + ------- + a named tuple with properties + - support, the exact distance values used to evalute the statistic + - statistic, the values of the statistic at each distance + - pvalue, the percent of simulations that were as extreme as the observed value + - simulations, the distribution of simulated statistics (shaped (n_simulations, n_support_points)) + or None if keep_simulations=False (which is the default) """ return _ripley_test( "L", From 96aa8d2345c8beec84e84fc414a2236fae222e50 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:38:03 +0100 Subject: [PATCH 41/67] add deprecation warnings --- pointpats/_deprecated_distance_statistics.py | 174 +++++++++++++------ 1 file changed, 122 insertions(+), 52 deletions(-) diff --git a/pointpats/_deprecated_distance_statistics.py b/pointpats/_deprecated_distance_statistics.py index 4269e15..085c323 100644 --- a/pointpats/_deprecated_distance_statistics.py +++ b/pointpats/_deprecated_distance_statistics.py @@ -3,11 +3,25 @@ """ __author__ = "Serge Rey sjsrey@gmail.com" -__all__ = ['DStatistic', 'G', 'F', 'J', 'K', 'L', 'Envelopes', 'Genv', 'Fenv', 'Jenv', 'Kenv', 'Lenv'] +__all__ = [ + "DStatistic", + "G", + "F", + "J", + "K", + "L", + "Envelopes", + "Genv", + "Fenv", + "Jenv", + "Kenv", + "Lenv", +] from .process import PoissonPointProcess as csr import numpy as np from matplotlib import pyplot as plt +import warnings class DStatistic(object): @@ -25,8 +39,15 @@ class DStatistic(object): The distance domain sequence. """ + def __init__(self, name): self.name = name + warnings.warn( + f"This class is deprecated! Please use the alternative function" + f" {name.lower()} in pointpats.distance_statistics.", + DeprecationWarning, + stacklevel=2, + ) def plot(self, qq=False): """ @@ -45,10 +66,10 @@ def plot(self, qq=False): plt.plot(self.ev, self._stat) plt.plot(self.ev, self.ev) else: - plt.plot(x, self._stat, label='{}'.format(self.name)) + plt.plot(x, self._stat, label="{}".format(self.name)) plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') - plt.plot(x, self.ev, label='CSR') + plt.xlabel("d") + plt.plot(x, self.ev, label="CSR") plt.title("{} distance function".format(self.name)) @@ -210,6 +231,7 @@ class J(DStatistic): """ + def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): res = _j(pp, n, intervals, dmin, dmax, d) self.d = res[:, 0] @@ -255,6 +277,7 @@ class K(DStatistic): where :math:`a` is the area of the window, :math:`n` the number of event points, and :math:`I(d_{i,j} \le h)` is an indicator function returning 1 when points i and j are separated by a distance of :math:`h` or less, 0 otherwise. """ + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): res = _k(pp, intervals, dmin, dmax, d) self.d = res[:, 0] @@ -309,6 +332,7 @@ class L(DStatistic): empirical function falls below the expectation. """ + def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): res = _l(pp, intervals, dmin, dmax, d) self.d = res[:, 0] @@ -318,9 +342,9 @@ def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None): def plot(self): # assuming mpl x = self.d - plt.plot(x, self._stat, label='{}'.format(self.name)) + plt.plot(x, self._stat, label="{}".format(self.name)) plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') + plt.xlabel("d") plt.title("{} distance function".format(self.name)) @@ -356,14 +380,14 @@ def _g(pp, intervals=10, dmin=0.0, dmax=None, d=None): """ if d is None: - w = pp.max_nnd/intervals + w = pp.max_nnd / intervals if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] + w = dmax / intervals + d = [w * i for i in range(intervals + 2)] cdf = [0] * len(d) for i, d_i in enumerate(d): smaller = [nndi for nndi in pp.nnd if nndi <= d_i] - cdf[i] = len(smaller)*1./pp.n + cdf[i] = len(smaller) * 1.0 / pp.n return np.vstack((d, cdf)).T @@ -408,15 +432,15 @@ def _f(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): nnids, nnds = pp.knn_other(c, k=1) if d is None: - w = pp.max_nnd/intervals + w = pp.max_nnd / intervals if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] + w = dmax / intervals + d = [w * i for i in range(intervals + 2)] cdf = [0] * len(d) for i, d_i in enumerate(d): smaller = [nndi for nndi in nnds if nndi <= d_i] - cdf[i] = len(smaller)*1./n + cdf[i] = len(smaller) * 1.0 / n return np.vstack((d, cdf)).T @@ -462,7 +486,7 @@ def _j(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None): if np.any(FC == 0): last_id = np.where(FC == 0)[0][0] - return np.vstack((F[:last_id, 0], GC[:last_id]/FC[:last_id])).T + return np.vstack((F[:last_id, 0], GC[:last_id] / FC[:last_id])).T def _k(pp, intervals=10, dmin=0.0, dmax=None, d=None): @@ -499,12 +523,12 @@ def _k(pp, intervals=10, dmin=0.0, dmax=None, d=None): """ if d is None: - w = pp.rot/intervals + w = pp.rot / intervals if dmax: - w = dmax/intervals - d = [w*i for i in range(intervals + 2)] + w = dmax / intervals + d = [w * i for i in range(intervals + 2)] den = pp.lambda_window * (pp.n - 1) - kcdf = np.asarray([(di, len(pp.tree.query_pairs(di)) * 2 / den ) for di in d]) + kcdf = np.asarray([(di, len(pp.tree.query_pairs(di)) * 2 / den) for di in d]) return kcdf @@ -591,9 +615,16 @@ class Envelopes(object): envelope. """ - def __init__(self, *args, **kwargs): + + def __init__(self, *args, **kwargs): # setup arguments - self.name = kwargs['name'] + self.name = kwargs["name"] + warnings.warn( + f"This class is deprecated! Please use the alternative statistical test" + f" {self.name.lower()}_test in pointpats.distance_statistics.", + DeprecationWarning, + stacklevel=2, + ) # calculate observed function self.pp = args[0] @@ -601,7 +632,7 @@ def __init__(self, *args, **kwargs): self.d = self.observed[:, 0] # domain to be used in all realizations # do realizations - self.mapper(kwargs['realizations']) + self.mapper(kwargs["realizations"]) def mapper(self, realizations): reals = realizations.realizations @@ -615,31 +646,31 @@ def mapper(self, realizations): for p in reals: j = self.calc(reals[p]) if j.shape[0] < self.d.shape[0]: - diff = self.d.shape[0]-j.shape[0] + diff = self.d.shape[0] - j.shape[0] for i in range(diff): - j = np.append(j, [[self.d[i+diff], np.inf]], axis=0) + j = np.append(j, [[self.d[i + diff], np.inf]], axis=0) res.append(j) res = np.array(res) res = res[:, :, -1] res.sort(axis=0) nres = len(res) - self.low = res[np.int(nres * self.pct/2.)] - self.high = res[np.int(nres * (1-self.pct/2.))] + self.low = res[np.int(nres * self.pct / 2.0)] + self.high = res[np.int(nres * (1 - self.pct / 2.0))] self.mean = res.mean(axis=0) def calc(self, *args, **kwargs): - print('implement in subclass') + print("implement in subclass") def plot(self): # assuming mpl x = self.d - plt.plot(x, self.observed[:, 1], label='{}'.format(self.name)) - plt.plot(x, self.mean, 'g-.', label='CSR') - plt.plot(x, self.low, 'r-.', label='LB') - plt.plot(x, self.high, 'r-.', label="UB") + plt.plot(x, self.observed[:, 1], label="{}".format(self.name)) + plt.plot(x, self.mean, "g-.", label="CSR") + plt.plot(x, self.low, "r-.", label="LB") + plt.plot(x, self.high, "r-.", label="UB") plt.ylabel("{}(d)".format(self.name)) - plt.xlabel('d') + plt.xlabel("d") plt.title("{} Simulation Envelopes".format(self.name)) plt.legend(loc=0) @@ -704,8 +735,9 @@ class Genv(Envelopes): """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, - realizations=None): + def __init__( + self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, realizations=None + ): self.pp = pp self.intervals = intervals self.dmin = dmin @@ -716,8 +748,9 @@ def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, def calc(self, *args, **kwargs): pp = args[0] - return _g(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) + return _g( + pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, d=self.d + ) class Fenv(Envelopes): @@ -781,8 +814,18 @@ class Fenv(Envelopes): >>> fenv.plot() """ - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): + + def __init__( + self, + pp, + n=100, + intervals=10, + dmin=0.0, + dmax=None, + d=None, + pct=0.05, + realizations=None, + ): self.pp = pp self.n = n self.intervals = intervals @@ -794,8 +837,14 @@ def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, def calc(self, *args, **kwargs): pp = args[0] - return _f(pp, self.n, intervals=self.intervals, dmin=self.dmin, - dmax=self.dmax, d=self.d) + return _f( + pp, + self.n, + intervals=self.intervals, + dmin=self.dmin, + dmax=self.dmax, + d=self.d, + ) class Jenv(Envelopes): @@ -859,8 +908,18 @@ class Jenv(Envelopes): >>> jenv.plot() """ - def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): + + def __init__( + self, + pp, + n=100, + intervals=10, + dmin=0.0, + dmax=None, + d=None, + pct=0.05, + realizations=None, + ): self.pp = pp self.n = n self.intervals = intervals @@ -872,8 +931,14 @@ def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None, def calc(self, *args, **kwargs): pp = args[0] - return _j(pp, self.n, intervals=self.intervals, dmin=self.dmin, - dmax=self.dmax, d=self.d) + return _j( + pp, + self.n, + intervals=self.intervals, + dmin=self.dmin, + dmax=self.dmax, + d=self.d, + ) class Kenv(Envelopes): @@ -935,8 +1000,10 @@ class Kenv(Envelopes): >>> kenv.plot() """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): + + def __init__( + self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, realizations=None + ): self.pp = pp self.intervals = intervals self.dmin = dmin @@ -947,8 +1014,9 @@ def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, def calc(self, *args, **kwargs): pp = args[0] - return _k(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) + return _k( + pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, d=self.d + ) class Lenv(Envelopes): @@ -1011,8 +1079,9 @@ class Lenv(Envelopes): """ - def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, - pct=0.05, realizations=None): + def __init__( + self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05, realizations=None + ): self.pp = pp self.intervals = intervals self.dmin = dmin @@ -1023,5 +1092,6 @@ def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, def calc(self, *args, **kwargs): pp = args[0] - return _l(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, - d=self.d) + return _l( + pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax, d=self.d + ) From 5b1fa0d7ded03f2168c26ea7c3d80498ddc93f00 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:41:42 +0100 Subject: [PATCH 42/67] update process.py with deprecation warning in init --- pointpats/process.py | 53 ++++++++++++++++++++++++++++---------------- 1 file changed, 34 insertions(+), 19 deletions(-) diff --git a/pointpats/process.py b/pointpats/process.py index 4fea614..a2c54d2 100644 --- a/pointpats/process.py +++ b/pointpats/process.py @@ -9,15 +9,16 @@ """ __author__ = "Serge Rey sjsrey@gmail.com" -__all__ = ['PointProcess', 'PoissonPointProcess', 'PoissonClusterPointProcess'] +__all__ = ["PointProcess", "PoissonPointProcess", "PoissonClusterPointProcess"] import numpy as np import libpysal as ps from numpy.random import poisson from .pointpattern import PointPattern as PP +import warnings -def runif_in_circle(n, radius=1.0, center=(0., 0.), burn=2, verbose=False): +def runif_in_circle(n, radius=1.0, center=(0.0, 0.0), burn=2, verbose=False): """ Generate n points within a circle of given radius. @@ -44,20 +45,20 @@ def runif_in_circle(n, radius=1.0, center=(0., 0.), burn=2, verbose=False): r2 = r * r it = 0 while c < n: - x = np.random.uniform(-r, r, (burn*n, 1)) - y = np.random.uniform(-r, r, (burn*n, 1)) - ids = np.where(x*x + y*y <= r2) + x = np.random.uniform(-r, r, (burn * n, 1)) + y = np.random.uniform(-r, r, (burn * n, 1)) + ids = np.where(x * x + y * y <= r2) candidates = np.hstack((x, y))[ids[0]] nc = candidates.shape[0] need = n - c if nc > need: # more than we need good[c:] = candidates[:need] else: # use them all and keep going - good[c:c+nc] = candidates + good[c : c + nc] = candidates c += nc it += 1 if verbose: - print('Iterations: {}'.format(it)) + print("Iterations: {}".format(it)) return good + np.asarray(center) @@ -110,6 +111,12 @@ def __init__(self, window, n, samples, asPP=False, **args): for sample in self.realizations: points = self.realizations[sample] self.realizations[sample] = PP(points, window=self.window) + warnings.warn( + "These point pattern simulators are deprecated! Please replace them" + " with equivalent functions in pointpats.random", + DeprecationWarning, + stacklevel=2, + ) def draw(self, parameter): """ @@ -129,7 +136,7 @@ def draw(self, parameter): """ c = 0 sample = [] - n = parameter['n'] + n = parameter["n"] while c < n: pnts = self.realize(n) pnts = [ps.cg.shapes.Point((x, y)) for x, y in pnts] @@ -254,10 +261,10 @@ def setup(self): if self.conditioning: lambdas = poisson(self.n, self.samples) for i, l in enumerate(lambdas): - self.parameters[i] = {'n': l} + self.parameters[i] = {"n": l} else: for i in range(self.samples): - self.parameters[i] = {'n': self.n} + self.parameters[i] = {"n": self.n} def realize(self, n): """ @@ -391,16 +398,24 @@ class PoissonClusterPointProcess(PointProcess): """ - def __init__(self, window, n, parents, radius, samples, keep=False, - asPP=False, conditioning=False): + def __init__( + self, + window, + n, + parents, + radius, + samples, + keep=False, + asPP=False, + conditioning=False, + ): self.conditioning = conditioning self.parents = parents - self.children = int(np.ceil(n * 1. / parents)) + self.children = int(np.ceil(n * 1.0 / parents)) self.radius = radius self.keep = keep - super(PoissonClusterPointProcess, self).__init__(window, n, samples, - asPP) + super(PoissonClusterPointProcess, self).__init__(window, n, samples, asPP) def setup(self): """ @@ -418,11 +433,11 @@ def setup(self): lambdas = poisson(self.parents, self.samples) for i, l in enumerate(lambdas): num = l * self.children - self.parameters[i] = {'n': num} + self.parameters[i] = {"n": num} self.num_parents[i] = l else: for i in range(self.samples): - self.parameters[i] = {'n': self.n} + self.parameters[i] = {"n": self.n} self.num_parents[i] = self.parents def realize(self, n): @@ -444,8 +459,8 @@ def realize(self, n): l, b, r, t = self.window.bbox d = self.radius # get parent points - pxs = np.random.uniform(l, r, (int(n/self.children), 1)) - pys = np.random.uniform(b, t, (int(n/self.children), 1)) + pxs = np.random.uniform(l, r, (int(n / self.children), 1)) + pys = np.random.uniform(b, t, (int(n / self.children), 1)) cents = np.hstack((pxs, pys)) # generate children points pnts = [runif_in_circle(self.children, d, center) for center in cents] From 5e313ac7b3cd8ad36f0e4a04b91d3634917734bd Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 17:42:53 +0100 Subject: [PATCH 43/67] add shapely as a testing dependency --- requirements_tests.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements_tests.txt b/requirements_tests.txt index fa8032a..5ac3042 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -3,3 +3,4 @@ nose-progressive nose-exclude coverage coveralls +shapely From 4e02e4c207e73875a19266fbb009225dddfa9570 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:01:49 +0100 Subject: [PATCH 44/67] fix missing imports --- pointpats/distance_statistics.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index 0f165ee..013f053 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -6,7 +6,10 @@ area as _area, k_neighbors as _k_neighbors, build_best_tree as _build_best_tree, + prepare_hull as _prepare_hull, + TREE_TYPES, ) +from .random import poisson from ._deprecated_distance_statistics import G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv From aef808a40f468cd88c31758294a24c516717391f Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:02:05 +0100 Subject: [PATCH 45/67] move imports into * using __all__ --- pointpats/distance_statistics.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index 013f053..ef5680a 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -12,7 +12,7 @@ from .random import poisson -from ._deprecated_distance_statistics import G, F, J, K, L, Genv, Fenv, Jenv, Kenv, Lenv +from ._deprecated_distance_statistics import * __all__ = [ "f", From fce2c8bb26b35d97e2bda326b27f229a2ad0c3de Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:02:17 +0100 Subject: [PATCH 46/67] fix stat_function break and hull computation --- pointpats/distance_statistics.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index ef5680a..d566a98 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -538,10 +538,10 @@ def _ripley_test( n_simulations=9999, **kwargs, ): - stat, result_container = _ripley_dispatch.get(calltype) + stat_function, result_container = _ripley_dispatch.get(calltype) core_kwargs = dict(support=support, metric=metric, edge_correction=edge_correction,) tree = _build_best_tree(coordinates, metric=metric) - + hull = _prepare_hull(coordinates, hull) if calltype in ("F", "J"): # these require simulations core_kwargs["hull"] = hull # amortize to avoid doing this every time From 7c1bc2f9ab4f48b5f4c511477f157764cab7fcb2 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:02:28 +0100 Subject: [PATCH 47/67] use hull since simulate_from is deprecated --- pointpats/distance_statistics.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pointpats/distance_statistics.py b/pointpats/distance_statistics.py index d566a98..185b8f4 100644 --- a/pointpats/distance_statistics.py +++ b/pointpats/distance_statistics.py @@ -561,12 +561,13 @@ def _ripley_test( tree, distances=distances, **core_kwargs ) core_kwargs["support"] = observed_support + n_observations = coordinates.shape[0] if keep_simulations: simulations = numpy.empty((len(observed_support), n_simulations)).T pvalues = numpy.ones_like(observed_support) for i_replication in range(n_simulations): - random_i = poisson(tree.data) + random_i = poisson(hull, size=n_observations) if calltype in ("F", "J"): random_tree = _build_best_tree(random_i, metric) empty_distances, _ = random_tree.query(empty_space_points, k=1) From a4006c5e6f9482e96918db43dd6033caf887cfc6 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:02:43 +0100 Subject: [PATCH 48/67] missing warnings in geometry --- pointpats/geometry.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/geometry.py b/pointpats/geometry.py index e0ead1d..34f7679 100644 --- a/pointpats/geometry.py +++ b/pointpats/geometry.py @@ -3,7 +3,7 @@ from functools import singledispatch from libpysal.cg import alpha_shape_auto from libpysal.cg.kdtree import Arc_KDTree - +import warnings # ------------------------------------------------------------# # Utilities and dispatching # From b3f0f5534ef13c397cc8b485ae18738ee84a607a Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:02:55 +0100 Subject: [PATCH 49/67] add fallback for non-area to treat the object like an array --- pointpats/geometry.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pointpats/geometry.py b/pointpats/geometry.py index 34f7679..2031120 100644 --- a/pointpats/geometry.py +++ b/pointpats/geometry.py @@ -32,7 +32,10 @@ def area(shape): Works for: shapely.geometry.Polygon """ - return shape.area + try: + return shape.area + except AttributeError: + return area(numpy.asarray(shape)) @area.register From 234dea68cd031586ae0055ce9f322ae0d58acb7b Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:03:20 +0100 Subject: [PATCH 50/67] blacken tests of deprecated functions and change imports --- pointpats/tests/test_distance_statistics.py | 268 ++++++++++++++++---- 1 file changed, 213 insertions(+), 55 deletions(-) diff --git a/pointpats/tests/test_distance_statistics.py b/pointpats/tests/test_distance_statistics.py index 4d88424..6c075f0 100644 --- a/pointpats/tests/test_distance_statistics.py +++ b/pointpats/tests/test_distance_statistics.py @@ -1,35 +1,77 @@ import unittest import numpy as np -from ..distance_statistics import * +from ..distance_statistics import G, F, J, K, L from ..pointpattern import PointPattern class TestDistanceStatistics(unittest.TestCase): def setUp(self): - self.points = [[66.22, 32.54], [22.52, 22.39], [31.01, 81.21], - [9.47, 31.02], [30.78, 60.10], [75.21, 58.93], - [79.26, 7.68], [8.23, 39.93], [98.73, 77.17], - [89.78, 42.53], [65.19, 92.08], [54.46, 8.48]] + self.points = [ + [66.22, 32.54], + [22.52, 22.39], + [31.01, 81.21], + [9.47, 31.02], + [30.78, 60.10], + [75.21, 58.93], + [79.26, 7.68], + [8.23, 39.93], + [98.73, 77.17], + [89.78, 42.53], + [65.19, 92.08], + [54.46, 8.48], + ] self.pp = PointPattern(self.points) def test_distance_statistics_G(self): g = G(self.pp, intervals=20) distance_domain_sequence = [ - 0.0, 1.73156208378, 3.46312416757, 5.19468625135, - 6.92624833514, 8.65781041892, 10.3893725027, 12.1209345865, - 13.8524966703, 15.5840587541, 17.3156208378, 19.0471829216, - 20.7787450054, 22.5103070892, 24.241869173, 25.9734312568, - 27.7049933406, 29.4365554243, 31.1681175081, 32.8996795919, - 34.6312416757, 36.3628037595 + 0.0, + 1.73156208378, + 3.46312416757, + 5.19468625135, + 6.92624833514, + 8.65781041892, + 10.3893725027, + 12.1209345865, + 13.8524966703, + 15.5840587541, + 17.3156208378, + 19.0471829216, + 20.7787450054, + 22.5103070892, + 24.241869173, + 25.9734312568, + 27.7049933406, + 29.4365554243, + 31.1681175081, + 32.8996795919, + 34.6312416757, + 36.3628037595, ] envelop = [ - 0.0, 0.0146894910196, 0.0574759094992, 0.124697772575, - 0.210831326089, 0.309238901911, 0.413008064625, 0.515735506438, - 0.612136108644, 0.698406273989, 0.772327023751, 0.83314205264, - 0.881278728773, 0.917991964321, 0.945004075083, 0.964194409454, - 0.977368288342, 0.986112304319, 0.991726501147, 0.995214862073, - 0.997313134422, 0.998535316975 + 0.0, + 0.0146894910196, + 0.0574759094992, + 0.124697772575, + 0.210831326089, + 0.309238901911, + 0.413008064625, + 0.515735506438, + 0.612136108644, + 0.698406273989, + 0.772327023751, + 0.83314205264, + 0.881278728773, + 0.917991964321, + 0.945004075083, + 0.964194409454, + 0.977368288342, + 0.986112304319, + 0.991726501147, + 0.995214862073, + 0.997313134422, + 0.998535316975, ] np.testing.assert_array_almost_equal(g.ev, envelop) np.testing.assert_array_almost_equal(g.d, distance_domain_sequence) @@ -37,20 +79,52 @@ def test_distance_statistics_G(self): def test_distance_statistics_F(self): f = F(self.pp, intervals=20) distance_domain_sequence = [ - 0.0, 1.73156208378, 3.46312416757, 5.19468625135, - 6.92624833514, 8.65781041892, 10.3893725027, 12.1209345865, - 13.8524966703, 15.5840587541, 17.3156208378, 19.0471829216, - 20.7787450054, 22.5103070892, 24.241869173, 25.9734312568, - 27.7049933406, 29.4365554243, 31.1681175081, 32.8996795919, - 34.6312416757, 36.3628037595 + 0.0, + 1.73156208378, + 3.46312416757, + 5.19468625135, + 6.92624833514, + 8.65781041892, + 10.3893725027, + 12.1209345865, + 13.8524966703, + 15.5840587541, + 17.3156208378, + 19.0471829216, + 20.7787450054, + 22.5103070892, + 24.241869173, + 25.9734312568, + 27.7049933406, + 29.4365554243, + 31.1681175081, + 32.8996795919, + 34.6312416757, + 36.3628037595, ] envelop = [ - 0.0, 0.0146894910196, 0.0574759094992, 0.124697772575, - 0.210831326089, 0.309238901911, 0.413008064625, 0.515735506438, - 0.612136108644, 0.698406273989, 0.772327023751, 0.83314205264, - 0.881278728773, 0.917991964321, 0.945004075083, 0.964194409454, - 0.977368288342, 0.986112304319, 0.991726501147, 0.995214862073, - 0.997313134422, 0.998535316975 + 0.0, + 0.0146894910196, + 0.0574759094992, + 0.124697772575, + 0.210831326089, + 0.309238901911, + 0.413008064625, + 0.515735506438, + 0.612136108644, + 0.698406273989, + 0.772327023751, + 0.83314205264, + 0.881278728773, + 0.917991964321, + 0.945004075083, + 0.964194409454, + 0.977368288342, + 0.986112304319, + 0.991726501147, + 0.995214862073, + 0.997313134422, + 0.998535316975, ] np.testing.assert_array_almost_equal(f.ev, envelop) np.testing.assert_array_almost_equal(f.d, distance_domain_sequence) @@ -58,10 +132,20 @@ def test_distance_statistics_F(self): def test_distance_statistics_J(self): j = J(self.pp, intervals=20) distance_domain_sequence = [ - 0.0, 1.73156208378, 3.46312416757, 5.19468625135, - 6.92624833514, 8.65781041892, 10.3893725027, 12.1209345865, - 13.8524966703, 15.5840587541, 17.3156208378, 19.0471829216, - 20.7787450054, 22.5103070892 + 0.0, + 1.73156208378, + 3.46312416757, + 5.19468625135, + 6.92624833514, + 8.65781041892, + 10.3893725027, + 12.1209345865, + 13.8524966703, + 15.5840587541, + 17.3156208378, + 19.0471829216, + 20.7787450054, + 22.5103070892, ] for val in j.ev: np.testing.assert_approx_equal(val, 1.0) @@ -70,35 +154,109 @@ def test_distance_statistics_J(self): def test_distance_statistics_K(self): k = K(self.pp, intervals=20) - distance_domain_sequence = [ 0. , 1.055, 2.11 , 3.165, 4.22 , - 5.275, 6.33 , 7.385, 8.44 , 9.495, - 10.55 , 11.605, 12.66 , 13.715, 14.77 , - 15.825, 16.88 , 17.935, 18.99 , 20.045, - 21.1 , 22.155] + distance_domain_sequence = [ + 0.0, + 1.055, + 2.11, + 3.165, + 4.22, + 5.275, + 6.33, + 7.385, + 8.44, + 9.495, + 10.55, + 11.605, + 12.66, + 13.715, + 14.77, + 15.825, + 16.88, + 17.935, + 18.99, + 20.045, + 21.1, + 22.155, + ] - envelope = [0. , 3.49667116, 13.98668465, 31.47004047, - 55.94673861, 87.41677908, 125.88016188, 171.336887, - 223.78695445, 283.23036422, 349.66711633, 423.09721075, - 503.52064751, 590.93742659, 685.347548 , 786.75101173, - 895.1478178 , 1010.53796618, 1132.9214569 , 1262.29828994, - 1398.6684653 , 1542.031983 ] + envelope = [ + 0.0, + 3.49667116, + 13.98668465, + 31.47004047, + 55.94673861, + 87.41677908, + 125.88016188, + 171.336887, + 223.78695445, + 283.23036422, + 349.66711633, + 423.09721075, + 503.52064751, + 590.93742659, + 685.347548, + 786.75101173, + 895.1478178, + 1010.53796618, + 1132.9214569, + 1262.29828994, + 1398.6684653, + 1542.031983, + ] np.testing.assert_array_almost_equal(k.ev, envelope) np.testing.assert_array_almost_equal(k.d, distance_domain_sequence) def test_distance_statistics_L(self): l = L(self.pp, intervals=20) - distance_domain_sequence = [ 0. , 1.055, 2.11 , 3.165, 4.22 , - 5.275, 6.33 , 7.385, 8.44 , 9.495, - 10.55 , 11.605, 12.66 , 13.715, 14.77 , - 15.825, 16.88 , 17.935, 18.99 , 20.045, - 21.1 , 22.155] - l_stats = [0. , -1.055 , -2.11 , -3.165 , - -4.22 , -5.275 , -6.33 , -7.385 , - -8.44 , -3.42556019, -4.48056019, -5.53556019, - -6.59056019, -7.64556019, -8.70056019, -7.24151591, - -8.29651591, -9.35151591, -10.40651591, -11.46151591, - -12.51651591, -10.01612038] + distance_domain_sequence = [ + 0.0, + 1.055, + 2.11, + 3.165, + 4.22, + 5.275, + 6.33, + 7.385, + 8.44, + 9.495, + 10.55, + 11.605, + 12.66, + 13.715, + 14.77, + 15.825, + 16.88, + 17.935, + 18.99, + 20.045, + 21.1, + 22.155, + ] + l_stats = [ + 0.0, + -1.055, + -2.11, + -3.165, + -4.22, + -5.275, + -6.33, + -7.385, + -8.44, + -3.42556019, + -4.48056019, + -5.53556019, + -6.59056019, + -7.64556019, + -8.70056019, + -7.24151591, + -8.29651591, + -9.35151591, + -10.40651591, + -11.46151591, + -12.51651591, + -10.01612038, + ] np.testing.assert_array_almost_equal(l.d, distance_domain_sequence) np.testing.assert_array_almost_equal(l.l, l_stats) From c840b7fa2b182154728dcdc48ab539fee81ea332 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 18:04:03 +0100 Subject: [PATCH 51/67] change tests to accommodate refactor --- pointpats/tests/test_ripley.py | 105 ++++++++++++++++----------------- 1 file changed, 50 insertions(+), 55 deletions(-) diff --git a/pointpats/tests/test_ripley.py b/pointpats/tests/test_ripley.py index 4526291..d195ea8 100644 --- a/pointpats/tests/test_ripley.py +++ b/pointpats/tests/test_ripley.py @@ -1,8 +1,7 @@ import numpy from scipy import spatial -from pointpats import ripley +from pointpats import distance_statistics as ripley, geometry, random from libpysal.cg import alpha_shape_auto -from shapely import geometry import pygeos import warnings import pytest @@ -38,8 +37,8 @@ D_self = spatial.distance.squareform(d_self) try: numpy.random.seed(2478879) - random = ripley.simulate(bbox, size=500) - D_other = spatial.distance.cdist(points, random) + random_pattern = random.poisson(bbox, size=500) + D_other = spatial.distance.cdist(points, random_pattern) except: # will cause failures in all ripley tests later from NameErrors about D_other # If D_other is missing, then test_simulate should also fail. @@ -48,30 +47,30 @@ def test_primitives(): area_bbox = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) - assert area_bbox == ripley._area(bbox) + assert area_bbox == geometry.area(bbox) area_chull = chull.volume - assert area_chull == ripley._area(chull) + assert area_chull == geometry.area(chull) area_pgon = ripley._area(ashape) assert area_pgon == ashape.area - assert area_pgon == ripley._area(pygeos_ashape) + assert area_pgon == geometry.area(pygeos_ashape) point_in = list(ashape.centroid.coords)[0] point_out = (100, 100) - assert ripley._contains(chull, *point_in) - assert ripley._contains(ashape, *point_in) - assert ripley._contains(pygeos_ashape, *point_in) - assert ripley._contains(bbox, *point_in) + assert geometry.contains(chull, *point_in) + assert geometry.contains(ashape, *point_in) + assert geometry.contains(pygeos_ashape, *point_in) + assert geometry.contains(bbox, *point_in) - assert not (ripley._contains(chull, *point_out)) - assert not (ripley._contains(ashape, *point_out)) - assert not (ripley._contains(pygeos_ashape, *point_out)) - assert not (ripley._contains(bbox, *point_out)) + assert not (geometry.contains(chull, *point_out)) + assert not (geometry.contains(ashape, *point_out)) + assert not (geometry.contains(pygeos_ashape, *point_out)) + assert not (geometry.contains(bbox, *point_out)) - numpy.testing.assert_array_equal(bbox, ripley._bbox(bbox)) - numpy.testing.assert_array_equal(bbox, ripley._bbox(ashape)) - numpy.testing.assert_array_equal(bbox, ripley._bbox(pygeos_ashape)) - numpy.testing.assert_array_equal(bbox, ripley._bbox(chull)) - numpy.testing.assert_array_equal(bbox, ripley._bbox(points)) + numpy.testing.assert_array_equal(bbox, geometry.bbox(bbox)) + numpy.testing.assert_array_equal(bbox, geometry.bbox(ashape)) + numpy.testing.assert_array_equal(bbox, geometry.bbox(pygeos_ashape)) + numpy.testing.assert_array_equal(bbox, geometry.bbox(chull)) + numpy.testing.assert_array_equal(bbox, geometry.bbox(points)) def test_tree_functions(): @@ -192,25 +191,23 @@ def test_prepare(): def test_simulate(): - assert ripley.simulate(ashape).shape == (100, 2) - assert ripley.simulate(chull).shape == (100, 2) - assert ripley.simulate(bbox).shape == (100, 2) + assert random.poisson(ashape).shape == (100, 2) + assert random.poisson(chull).shape == (100, 2) + assert random.poisson(bbox).shape == (100, 2) - assert ripley.simulate(ashape, intensity=1e-2).shape == (50, 2) - assert ripley.simulate(chull, intensity=1e-2).shape == (52, 2) - assert ripley.simulate(bbox, intensity=1e-2).shape == (76, 2) + assert random.poisson(ashape, intensity=1e-2).shape == (50, 2) + assert random.poisson(chull, intensity=1e-2).shape == (52, 2) + assert random.poisson(bbox, intensity=1e-2).shape == (76, 2) - assert ripley.simulate(ashape, size=90).shape == (90, 2) - assert ripley.simulate(chull, intensity=1e-2).shape == (52, 2) - assert ripley.simulate(bbox, intensity=1e-2, size=3).shape == (3, 76, 2) - assert ripley.simulate(bbox, intensity=None, size=(10, 4)).shape == (4, 10, 2) + assert random.poisson(ashape, size=90).shape == (90, 2) + assert random.poisson(chull, intensity=1e-2).shape == (52, 2) + assert random.poisson(bbox, intensity=1e-2, size=3).shape == (3, 76, 2) + assert random.poisson(bbox, intensity=None, size=(10, 4)).shape == (4, 10, 2) - assert ripley.simulate_from(points, hull=None).shape == (12, 2) - assert ripley.simulate_from(points, hull=bbox).shape == (12, 2) - assert ripley.simulate_from(points, hull=ashape).shape == (12, 2) - assert ripley.simulate_from(points, hull=chull).shape == (12, 2) - - assert ripley.simulate_from(points, hull=chull, size=3).shape == (3, 12, 2) + # still need to check the other simulators + # normal + # cluster poisson + # cluster normal def test_f(): @@ -222,25 +219,23 @@ def test_f(): n_obs_at_dist, histogram_support = numpy.histogram(nn_other, bins=support) manual_f = numpy.asarray([0, *numpy.cumsum(n_obs_at_dist) / n_obs_at_dist.sum()]) numpy.random.seed(2478879) - f_test = ripley.f_test( - points, support=support, distances=D_other, n_replications=99 - ) + f_test = ripley.f_test(points, support=support, distances=D_other, n_simulations=99) numpy.testing.assert_allclose(support, f_test.support) numpy.testing.assert_allclose(manual_f, f_test.statistic) numpy.testing.assert_allclose( f_test.pvalue < 0.05, [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] ) - assert f_test.replications is None + assert f_test.simulations is None f_test = ripley.f_test( points, support=support, distances=D_other, - n_replications=99, - keep_replications=True, + n_simulations=99, + keep_simulations=True, ) - assert f_test.replications.shape == (99, 15) + assert f_test.simulations.shape == (99, 15) def test_g(): @@ -251,19 +246,19 @@ def test_g(): n_obs_at_dist, histogram_support = numpy.histogram(nn_self, bins=support) numpy.random.seed(2478879) manual_g = numpy.asarray([0, *numpy.cumsum(n_obs_at_dist) / n_obs_at_dist.sum()]) - g_test = ripley.g_test(points, support=support, n_replications=99) + g_test = ripley.g_test(points, support=support, n_simulations=99) numpy.testing.assert_allclose(support, g_test.support) numpy.testing.assert_allclose(manual_g, g_test.statistic) numpy.testing.assert_allclose( g_test.pvalue < 0.05, [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] ) - assert g_test.replications is None + assert g_test.simulations is None g_test = ripley.g_test( - points, support=support, n_replications=99, keep_replications=True + points, support=support, n_simulations=99, keep_simulations=True ) - assert g_test.replications.shape == (99, 15) + assert g_test.simulations.shape == (99, 15) def test_j(): @@ -271,16 +266,16 @@ def test_j(): # Check j function works, matches manual, is truncated correctly numpy.random.seed(2478879) - j_test = ripley.j_test(points, support=support, n_replications=99) + j_test = ripley.j_test(points, support=support, n_simulations=99) numpy.random.seed(2478879) j_test_fullno = ripley.j_test( - points, support=support, n_replications=0, truncate=False + points, support=support, n_simulations=0, truncate=False ) numpy.testing.assert_array_equal(j_test.support[:4], support[:4]) numpy.testing.assert_array_equal(j_test_fullno.support, support) numpy.random.seed(2478879) - _, f_tmp = ripley.f_function(points, support=support) - _, g_tmp = ripley.g_function(points, support=support) + _, f_tmp = ripley.f(points, support=support) + _, g_tmp = ripley.g(points, support=support) with warnings.catch_warnings(): warnings.simplefilter("ignore") manual_j = (1 - g_tmp) / (1 - f_tmp) @@ -309,13 +304,13 @@ def test_k(): def test_l(): # -------------------------------------------------------------------------# # Check L Function works, can be linearized, and has the right value - _, k = ripley.k_function(points, support=support) - l_test = ripley.l_test(points, support=support, n_replications=0) + _, k = ripley.k(points, support=support) + l_test = ripley.l_test(points, support=support, n_simulations=0) l_test_lin = ripley.l_test( - points, support=support, n_replications=0, linearized=True + points, support=support, n_simulations=0, linearized=True ) numpy.testing.assert_allclose(l_test.statistic, numpy.sqrt(k / numpy.pi)) numpy.testing.assert_allclose( - l_test_lin.statistic, support - numpy.sqrt(k / numpy.pi) + l_test_lin.statistic, numpy.sqrt(k / numpy.pi) - l_test.support ) From 69694f6eb08ed46f910f056f56892458d7e14b4b Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 21:26:10 +0100 Subject: [PATCH 52/67] add pygeos to testing requirements --- requirements_tests.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements_tests.txt b/requirements_tests.txt index 5ac3042..c8d8586 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -4,3 +4,4 @@ nose-exclude coverage coveralls shapely +pygeos From 18b99fd3a7f5005a3884c3124d38f4812c3f24f7 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 21:30:43 +0100 Subject: [PATCH 53/67] add pytest to testing requirements --- requirements_tests.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements_tests.txt b/requirements_tests.txt index c8d8586..6ac1c0f 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -5,3 +5,4 @@ coverage coveralls shapely pygeos +pytest From 766c437f959d8fb03dbf36b1da2852aee3c66280 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 21:41:31 +0100 Subject: [PATCH 54/67] move spatial testing requirements to travis because of pypi issues --- .travis.yml | 1 + requirements_tests.txt | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7b6b30b..df4983a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,6 +33,7 @@ install: - conda install --yes pip - pip install -r requirements.txt - pip install -r requirements_tests.txt + - conda install --yes -c conda-forge pygeos shapely # configure dual tests (for dependency libpysal) - if "$PYSAL_PYPI"; then echo 'testing pypi libpysal' && pip install libpysal; diff --git a/requirements_tests.txt b/requirements_tests.txt index 6ac1c0f..e7dd3b8 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -3,6 +3,6 @@ nose-progressive nose-exclude coverage coveralls -shapely -pygeos +# shapely these need to be gotten from conda because they're incompatible from pypi +# pygeos pytest From 090b06bc346a0dd42ad7cf7c6f2930571367d33f Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 21:49:43 +0100 Subject: [PATCH 55/67] mised one test migrating to geometry --- pointpats/tests/test_ripley.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pointpats/tests/test_ripley.py b/pointpats/tests/test_ripley.py index d195ea8..1da3b98 100644 --- a/pointpats/tests/test_ripley.py +++ b/pointpats/tests/test_ripley.py @@ -50,7 +50,7 @@ def test_primitives(): assert area_bbox == geometry.area(bbox) area_chull = chull.volume assert area_chull == geometry.area(chull) - area_pgon = ripley._area(ashape) + area_pgon = geometry.area(ashape) assert area_pgon == ashape.area assert area_pgon == geometry.area(pygeos_ashape) point_in = list(ashape.centroid.coords)[0] From be997f1ef7893d29dc239f5f93a538b35b0697cc Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 21:54:51 +0100 Subject: [PATCH 56/67] add scikit to the testing requirements --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index df4983a..5cf0c18 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,7 +33,7 @@ install: - conda install --yes pip - pip install -r requirements.txt - pip install -r requirements_tests.txt - - conda install --yes -c conda-forge pygeos shapely + - conda install --yes -c conda-forge pygeos shapely scikit-learn # configure dual tests (for dependency libpysal) - if "$PYSAL_PYPI"; then echo 'testing pypi libpysal' && pip install libpysal; From 7cfe458906fe143d35f511bd6d0828ccf2683f56 Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 22:01:32 +0100 Subject: [PATCH 57/67] add geopandas to testing dependcies --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 5cf0c18..9d61254 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,7 +33,7 @@ install: - conda install --yes pip - pip install -r requirements.txt - pip install -r requirements_tests.txt - - conda install --yes -c conda-forge pygeos shapely scikit-learn + - conda install --yes -c conda-forge pygeos shapely scikit-learn geopandas # configure dual tests (for dependency libpysal) - if "$PYSAL_PYPI"; then echo 'testing pypi libpysal' && pip install libpysal; From f8a203627dce57c739c7a072311f693e36d7cd2e Mon Sep 17 00:00:00 2001 From: ljwolf Date: Thu, 11 Jun 2020 22:07:17 +0100 Subject: [PATCH 58/67] try having sklearn in the pip install --- .travis.yml | 2 +- requirements_tests.txt | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 9d61254..0637747 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,7 +33,7 @@ install: - conda install --yes pip - pip install -r requirements.txt - pip install -r requirements_tests.txt - - conda install --yes -c conda-forge pygeos shapely scikit-learn geopandas + - conda install --yes -c conda-forge pygeos shapely geopandas # configure dual tests (for dependency libpysal) - if "$PYSAL_PYPI"; then echo 'testing pypi libpysal' && pip install libpysal; diff --git a/requirements_tests.txt b/requirements_tests.txt index e7dd3b8..4ec6ce0 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -3,6 +3,8 @@ nose-progressive nose-exclude coverage coveralls +scikit-learn # shapely these need to be gotten from conda because they're incompatible from pypi # pygeos +# geopandas pytest From b7b9193032aceb4ab5f15dd4466087eca8b107bf Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 14:39:27 -0700 Subject: [PATCH 59/67] TEST: move to pytest off of nosetest --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 0637747..422756c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -46,7 +46,8 @@ install: script: - python setup.py sdist >/dev/null - python setup.py install - - nosetests --verbose --with-coverage --cover-package=pointpats; + # - nosetests --verbose --with-coverage --cover-package=pointpats; + - pytest pointpats --cov pointpats -v --cov-report term-missing notifications: email: From 38a1c544ce175ff29657c285279f54fc989d68d8 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 14:46:11 -0700 Subject: [PATCH 60/67] TEST: move from nosetests to pytest --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 422756c..d65a22f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -47,7 +47,7 @@ script: - python setup.py sdist >/dev/null - python setup.py install # - nosetests --verbose --with-coverage --cover-package=pointpats; - - pytest pointpats --cov pointpats -v --cov-report term-missing + - pytest pointpats notifications: email: From 7fab7e2420f27a6317c7fe536100a1ae30ba7947 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 14:58:16 -0700 Subject: [PATCH 61/67] TEST: debugging travis max recursion issue --- pointpats/tests/test_ripley.py | 190 ++++++++++++++++----------------- 1 file changed, 95 insertions(+), 95 deletions(-) diff --git a/pointpats/tests/test_ripley.py b/pointpats/tests/test_ripley.py index 1da3b98..77a942b 100644 --- a/pointpats/tests/test_ripley.py +++ b/pointpats/tests/test_ripley.py @@ -56,15 +56,15 @@ def test_primitives(): point_in = list(ashape.centroid.coords)[0] point_out = (100, 100) - assert geometry.contains(chull, *point_in) - assert geometry.contains(ashape, *point_in) - assert geometry.contains(pygeos_ashape, *point_in) - assert geometry.contains(bbox, *point_in) + #assert geometry.contains(chull, *point_in) + #assert geometry.contains(ashape, *point_in) + #assert geometry.contains(pygeos_ashape, *point_in) + #assert geometry.contains(bbox, *point_in) - assert not (geometry.contains(chull, *point_out)) - assert not (geometry.contains(ashape, *point_out)) - assert not (geometry.contains(pygeos_ashape, *point_out)) - assert not (geometry.contains(bbox, *point_out)) + #assert not (geometry.contains(chull, *point_out)) + #assert not (geometry.contains(ashape, *point_out)) + #assert not (geometry.contains(pygeos_ashape, *point_out)) + #assert not (geometry.contains(bbox, *point_out)) numpy.testing.assert_array_equal(bbox, geometry.bbox(bbox)) numpy.testing.assert_array_equal(bbox, geometry.bbox(ashape)) @@ -100,93 +100,93 @@ def test_prepare(): tmp_bbox = ripley._prepare_hull(points, "bbox") numpy.testing.assert_array_equal(bbox, tmp_bbox) - tmp_bbox = ripley._prepare_hull(points, None) - numpy.testing.assert_array_equal(bbox, tmp_bbox) - - tmp_bbox = ripley._prepare_hull(points, bbox) - assert tmp_bbox is bbox # pass-through with no modification - - tmp_ashape = ripley._prepare_hull(points, "alpha") - assert tmp_ashape.equals(ashape) - - tmp_ashape = ripley._prepare_hull(points, "α") - assert tmp_ashape.equals(ashape) - - tmp_ashape = ripley._prepare_hull(points, ashape) - assert tmp_ashape is ashape # pass-through with no modification - - tmp_ashape = ripley._prepare_hull(points, pygeos_ashape) - assert pygeos.equals(tmp_ashape, pygeos_ashape) - - tmp_chull = ripley._prepare_hull(points, chull) - assert tmp_chull is chull # pass-through with no modification - - tmp_chull = ripley._prepare_hull(points, "convex") - numpy.testing.assert_allclose(tmp_chull.equations, chull.equations) - - # -------------------------------------------------------------------------- - # Now, check the prepare generally - # check edge correction raise - - try: - ripley._prepare(points, None, None, "euclidean", ashape, "ripley") - raise AssertionError() - except NotImplementedError: - pass - except AssertionError: - raise AssertionError("Did not raise an error when edge correction is set") - - # check tree gets converted into data with no tree - out = ripley._prepare(tree, None, None, "euclidean", ashape, None) - numpy.testing.assert_array_equal(points, out[0]) - - # check three distance metrics - out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[3] - assert out == "euclidean" - out = ripley._prepare(tree, None, None, "haversine", ashape, None)[3] - assert out == "haversine" - test_func = lambda u, v: numpy.var(u - v) - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - out = ripley._prepare(tree, None, None, test_func, ashape, None)[3] - assert out is test_func - - # check precomputed failure - try: - out = ripley._prepare(tree, None, None, "precomputed", ashape, None) - raise AssertionError() - except ValueError: - pass - except AssertionError: - raise AssertionError( - 'Did not raise when metric="precomputed" but' " no distances provided" - ) - - # check support setting will: - # give 20 breaks from 0 to max dist if none - out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[1] - assert len(out) == 20 - assert out.min() == 0 - numpy.testing.assert_allclose(out.max(), 34.631242) - numpy.testing.assert_allclose(out.min(), 0) - out = ripley._prepare(tree, 30, None, "euclidean", ashape, None)[1] - assert len(out) == 30 - numpy.testing.assert_allclose(out.max(), 34.631242) - numpy.testing.assert_allclose(out.min(), 0) - # give tuple correctly for 1, 2, and 3-length tuples - out = ripley._prepare(tree, (4,), None, "euclidean", ashape, None)[1] - assert out.max() == 4 - out = ripley._prepare(tree, (2, 10), None, "euclidean", ashape, None)[1] - assert out.max() == 10 - assert out.min() == 2 - out = ripley._prepare(tree, (2, 10, 5), None, "euclidean", ashape, None)[1] - assert out.max() == 10 - assert out.min() == 2 - assert len(out) == 5 - # passthrough support - out = ripley._prepare(tree, numpy.arange(40), None, "euclidean", ashape, None)[1] - assert len(out) == 40 - assert (out == numpy.arange(40)).all() + #tmp_bbox = ripley._prepare_hull(points, None) + #numpy.testing.assert_array_equal(bbox, tmp_bbox) + + #tmp_bbox = ripley._prepare_hull(points, bbox) + #assert tmp_bbox is bbox # pass-through with no modification + + #tmp_ashape = ripley._prepare_hull(points, "alpha") + #assert tmp_ashape.equals(ashape) + + #tmp_ashape = ripley._prepare_hull(points, "α") + #assert tmp_ashape.equals(ashape) + + #tmp_ashape = ripley._prepare_hull(points, ashape) + #assert tmp_ashape is ashape # pass-through with no modification + + #tmp_ashape = ripley._prepare_hull(points, pygeos_ashape) + #assert pygeos.equals(tmp_ashape, pygeos_ashape) + + #tmp_chull = ripley._prepare_hull(points, chull) + #assert tmp_chull is chull # pass-through with no modification + + #tmp_chull = ripley._prepare_hull(points, "convex") + #numpy.testing.assert_allclose(tmp_chull.equations, chull.equations) + + ## -------------------------------------------------------------------------- + ## Now, check the prepare generally + ## check edge correction raise + + #try: + # ripley._prepare(points, None, None, "euclidean", ashape, "ripley") + # raise AssertionError() + #except NotImplementedError: + # pass + #except AssertionError: + # raise AssertionError("Did not raise an error when edge correction is set") + + ## check tree gets converted into data with no tree + #out = ripley._prepare(tree, None, None, "euclidean", ashape, None) + #numpy.testing.assert_array_equal(points, out[0]) + + ## check three distance metrics + #out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[3] + #assert out == "euclidean" + #out = ripley._prepare(tree, None, None, "haversine", ashape, None)[3] + #assert out == "haversine" + #test_func = lambda u, v: numpy.var(u - v) + #with warnings.catch_warnings(): + # warnings.simplefilter("ignore") + # out = ripley._prepare(tree, None, None, test_func, ashape, None)[3] + # assert out is test_func + + ## check precomputed failure + #try: + # out = ripley._prepare(tree, None, None, "precomputed", ashape, None) + # raise AssertionError() + #except ValueError: + # pass + #except AssertionError: + # raise AssertionError( + # 'Did not raise when metric="precomputed" but' " no distances provided" + # ) + + ## check support setting will: + ## give 20 breaks from 0 to max dist if none + #out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[1] + #assert len(out) == 20 + #assert out.min() == 0 + #numpy.testing.assert_allclose(out.max(), 34.631242) + #numpy.testing.assert_allclose(out.min(), 0) + #out = ripley._prepare(tree, 30, None, "euclidean", ashape, None)[1] + #assert len(out) == 30 + #numpy.testing.assert_allclose(out.max(), 34.631242) + #numpy.testing.assert_allclose(out.min(), 0) + ## give tuple correctly for 1, 2, and 3-length tuples + #out = ripley._prepare(tree, (4,), None, "euclidean", ashape, None)[1] + #assert out.max() == 4 + #out = ripley._prepare(tree, (2, 10), None, "euclidean", ashape, None)[1] + #assert out.max() == 10 + #assert out.min() == 2 + #out = ripley._prepare(tree, (2, 10, 5), None, "euclidean", ashape, None)[1] + #assert out.max() == 10 + #assert out.min() == 2 + #assert len(out) == 5 + ## passthrough support + #out = ripley._prepare(tree, numpy.arange(40), None, "euclidean", ashape, None)[1] + #assert len(out) == 40 + #assert (out == numpy.arange(40)).all() def test_simulate(): From 0557a1b0f4f80022d511ce38a9643800152cd62f Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 15:23:04 -0700 Subject: [PATCH 62/67] TESTS: bumping miniconda --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index d65a22f..95f0801 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,7 +20,7 @@ matrix: env: PYSAL_PYPI=false MPLBACKEND='pdf' before_install: - - wget https://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh + - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh - chmod +x miniconda.sh - ./miniconda.sh -b -p ./miniconda - export PATH=`pwd`/miniconda/bin:$PATH From f4aa4ecf94850685d5312d4b62aba9a2461a206e Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 15:29:36 -0700 Subject: [PATCH 63/67] TEST: fixing conditional testing logic in Jacquez --- pointpats/tests/test_ripley.py | 190 ++++++++++++++++----------------- 1 file changed, 95 insertions(+), 95 deletions(-) diff --git a/pointpats/tests/test_ripley.py b/pointpats/tests/test_ripley.py index 77a942b..1da3b98 100644 --- a/pointpats/tests/test_ripley.py +++ b/pointpats/tests/test_ripley.py @@ -56,15 +56,15 @@ def test_primitives(): point_in = list(ashape.centroid.coords)[0] point_out = (100, 100) - #assert geometry.contains(chull, *point_in) - #assert geometry.contains(ashape, *point_in) - #assert geometry.contains(pygeos_ashape, *point_in) - #assert geometry.contains(bbox, *point_in) + assert geometry.contains(chull, *point_in) + assert geometry.contains(ashape, *point_in) + assert geometry.contains(pygeos_ashape, *point_in) + assert geometry.contains(bbox, *point_in) - #assert not (geometry.contains(chull, *point_out)) - #assert not (geometry.contains(ashape, *point_out)) - #assert not (geometry.contains(pygeos_ashape, *point_out)) - #assert not (geometry.contains(bbox, *point_out)) + assert not (geometry.contains(chull, *point_out)) + assert not (geometry.contains(ashape, *point_out)) + assert not (geometry.contains(pygeos_ashape, *point_out)) + assert not (geometry.contains(bbox, *point_out)) numpy.testing.assert_array_equal(bbox, geometry.bbox(bbox)) numpy.testing.assert_array_equal(bbox, geometry.bbox(ashape)) @@ -100,93 +100,93 @@ def test_prepare(): tmp_bbox = ripley._prepare_hull(points, "bbox") numpy.testing.assert_array_equal(bbox, tmp_bbox) - #tmp_bbox = ripley._prepare_hull(points, None) - #numpy.testing.assert_array_equal(bbox, tmp_bbox) - - #tmp_bbox = ripley._prepare_hull(points, bbox) - #assert tmp_bbox is bbox # pass-through with no modification - - #tmp_ashape = ripley._prepare_hull(points, "alpha") - #assert tmp_ashape.equals(ashape) - - #tmp_ashape = ripley._prepare_hull(points, "α") - #assert tmp_ashape.equals(ashape) - - #tmp_ashape = ripley._prepare_hull(points, ashape) - #assert tmp_ashape is ashape # pass-through with no modification - - #tmp_ashape = ripley._prepare_hull(points, pygeos_ashape) - #assert pygeos.equals(tmp_ashape, pygeos_ashape) - - #tmp_chull = ripley._prepare_hull(points, chull) - #assert tmp_chull is chull # pass-through with no modification - - #tmp_chull = ripley._prepare_hull(points, "convex") - #numpy.testing.assert_allclose(tmp_chull.equations, chull.equations) - - ## -------------------------------------------------------------------------- - ## Now, check the prepare generally - ## check edge correction raise - - #try: - # ripley._prepare(points, None, None, "euclidean", ashape, "ripley") - # raise AssertionError() - #except NotImplementedError: - # pass - #except AssertionError: - # raise AssertionError("Did not raise an error when edge correction is set") - - ## check tree gets converted into data with no tree - #out = ripley._prepare(tree, None, None, "euclidean", ashape, None) - #numpy.testing.assert_array_equal(points, out[0]) - - ## check three distance metrics - #out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[3] - #assert out == "euclidean" - #out = ripley._prepare(tree, None, None, "haversine", ashape, None)[3] - #assert out == "haversine" - #test_func = lambda u, v: numpy.var(u - v) - #with warnings.catch_warnings(): - # warnings.simplefilter("ignore") - # out = ripley._prepare(tree, None, None, test_func, ashape, None)[3] - # assert out is test_func - - ## check precomputed failure - #try: - # out = ripley._prepare(tree, None, None, "precomputed", ashape, None) - # raise AssertionError() - #except ValueError: - # pass - #except AssertionError: - # raise AssertionError( - # 'Did not raise when metric="precomputed" but' " no distances provided" - # ) - - ## check support setting will: - ## give 20 breaks from 0 to max dist if none - #out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[1] - #assert len(out) == 20 - #assert out.min() == 0 - #numpy.testing.assert_allclose(out.max(), 34.631242) - #numpy.testing.assert_allclose(out.min(), 0) - #out = ripley._prepare(tree, 30, None, "euclidean", ashape, None)[1] - #assert len(out) == 30 - #numpy.testing.assert_allclose(out.max(), 34.631242) - #numpy.testing.assert_allclose(out.min(), 0) - ## give tuple correctly for 1, 2, and 3-length tuples - #out = ripley._prepare(tree, (4,), None, "euclidean", ashape, None)[1] - #assert out.max() == 4 - #out = ripley._prepare(tree, (2, 10), None, "euclidean", ashape, None)[1] - #assert out.max() == 10 - #assert out.min() == 2 - #out = ripley._prepare(tree, (2, 10, 5), None, "euclidean", ashape, None)[1] - #assert out.max() == 10 - #assert out.min() == 2 - #assert len(out) == 5 - ## passthrough support - #out = ripley._prepare(tree, numpy.arange(40), None, "euclidean", ashape, None)[1] - #assert len(out) == 40 - #assert (out == numpy.arange(40)).all() + tmp_bbox = ripley._prepare_hull(points, None) + numpy.testing.assert_array_equal(bbox, tmp_bbox) + + tmp_bbox = ripley._prepare_hull(points, bbox) + assert tmp_bbox is bbox # pass-through with no modification + + tmp_ashape = ripley._prepare_hull(points, "alpha") + assert tmp_ashape.equals(ashape) + + tmp_ashape = ripley._prepare_hull(points, "α") + assert tmp_ashape.equals(ashape) + + tmp_ashape = ripley._prepare_hull(points, ashape) + assert tmp_ashape is ashape # pass-through with no modification + + tmp_ashape = ripley._prepare_hull(points, pygeos_ashape) + assert pygeos.equals(tmp_ashape, pygeos_ashape) + + tmp_chull = ripley._prepare_hull(points, chull) + assert tmp_chull is chull # pass-through with no modification + + tmp_chull = ripley._prepare_hull(points, "convex") + numpy.testing.assert_allclose(tmp_chull.equations, chull.equations) + + # -------------------------------------------------------------------------- + # Now, check the prepare generally + # check edge correction raise + + try: + ripley._prepare(points, None, None, "euclidean", ashape, "ripley") + raise AssertionError() + except NotImplementedError: + pass + except AssertionError: + raise AssertionError("Did not raise an error when edge correction is set") + + # check tree gets converted into data with no tree + out = ripley._prepare(tree, None, None, "euclidean", ashape, None) + numpy.testing.assert_array_equal(points, out[0]) + + # check three distance metrics + out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[3] + assert out == "euclidean" + out = ripley._prepare(tree, None, None, "haversine", ashape, None)[3] + assert out == "haversine" + test_func = lambda u, v: numpy.var(u - v) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + out = ripley._prepare(tree, None, None, test_func, ashape, None)[3] + assert out is test_func + + # check precomputed failure + try: + out = ripley._prepare(tree, None, None, "precomputed", ashape, None) + raise AssertionError() + except ValueError: + pass + except AssertionError: + raise AssertionError( + 'Did not raise when metric="precomputed" but' " no distances provided" + ) + + # check support setting will: + # give 20 breaks from 0 to max dist if none + out = ripley._prepare(tree, None, None, "euclidean", ashape, None)[1] + assert len(out) == 20 + assert out.min() == 0 + numpy.testing.assert_allclose(out.max(), 34.631242) + numpy.testing.assert_allclose(out.min(), 0) + out = ripley._prepare(tree, 30, None, "euclidean", ashape, None)[1] + assert len(out) == 30 + numpy.testing.assert_allclose(out.max(), 34.631242) + numpy.testing.assert_allclose(out.min(), 0) + # give tuple correctly for 1, 2, and 3-length tuples + out = ripley._prepare(tree, (4,), None, "euclidean", ashape, None)[1] + assert out.max() == 4 + out = ripley._prepare(tree, (2, 10), None, "euclidean", ashape, None)[1] + assert out.max() == 10 + assert out.min() == 2 + out = ripley._prepare(tree, (2, 10, 5), None, "euclidean", ashape, None)[1] + assert out.max() == 10 + assert out.min() == 2 + assert len(out) == 5 + # passthrough support + out = ripley._prepare(tree, numpy.arange(40), None, "euclidean", ashape, None)[1] + assert len(out) == 40 + assert (out == numpy.arange(40)).all() def test_simulate(): From 0dcf9c52a5839d25918e79f4268f6c7e9611b259 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 15:30:17 -0700 Subject: [PATCH 64/67] TEST: travis debugging --- pointpats/tests/test_spacetime.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/pointpats/tests/test_spacetime.py b/pointpats/tests/test_spacetime.py index 9156b61..9193462 100644 --- a/pointpats/tests/test_spacetime.py +++ b/pointpats/tests/test_spacetime.py @@ -48,11 +48,7 @@ def setUp(self): def test_jacquez(self): result = jacquez(self.events.space, self.events.t, k=3, permutations=1) - if scp_version > 11: - self.assertEquals(result['stat'], 12) - else: - self.assertEquals(result['stat'], 13) - + self.assertEquals(result['stat'], 12) class ModifiedKnox_Tester(unittest.TestCase): From 53b4227448f8a2acb2db3fe0b1055616eeb9f0c1 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 15:35:18 -0700 Subject: [PATCH 65/67] TEST: add 3.8 testing --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 95f0801..4fa43db 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,6 +7,7 @@ branches: python: - 3.6 - 3.7 + - 3.8 env: - PYSAL_PYPI=true MPLBACKEND='pdf' From 89ee205c8d663cece56f75b10559132525554768 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 28 Jun 2020 15:41:31 -0700 Subject: [PATCH 66/67] TEST: allow 3.6 failures due to recursion limits on pytest --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 4fa43db..d66ec5d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,8 +17,8 @@ matrix: allow_failures: #allow travis tests to fail if using the github version of libpysal - python: 3.6 env: PYSAL_PYPI=false MPLBACKEND='pdf' - - python: 3.7 - env: PYSAL_PYPI=false MPLBACKEND='pdf' + - python: 3.6 + env: PYSAL_PYPI=true MPLBACKEND='pdf' before_install: - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh From 1928d58f1314d203eece6e515a974f3b5f51fafc Mon Sep 17 00:00:00 2001 From: ljwolf Date: Sat, 4 Jul 2020 13:29:48 +0100 Subject: [PATCH 67/67] update docstring for plain bbox --- pointpats/geometry.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pointpats/geometry.py b/pointpats/geometry.py index 2031120..a21de4b 100644 --- a/pointpats/geometry.py +++ b/pointpats/geometry.py @@ -62,9 +62,10 @@ def _(shape: numpy.ndarray): @singledispatch def bbox(shape): """ - If a shape has bounds, use those. + If a shape can be cast to an array, use that. Works for: - shapely.geometry.Polygon + lists of tuples + scikit memory arrays """ return bbox(numpy.asarray(shape))