graphical-sampling 0.1.0__py3-none-any.whl

graphical_sampling/sampling/population.py

@@ -0,0 +1,234 @@
+from itertools import pairwise
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+import matplotlib.pyplot as plt
+from matplotlib.patches import Polygon
+from scipy.spatial import ConvexHull
+
+from ..clustering import DublyBalancedKMeans
+
+
+@dataclass
+class Zone:
+    units: NDArray
+
+
+@dataclass
+class Cluster:
+    units: NDArray
+    zones: list[Zone]
+
+
+class Population:
+    def __init__(
+        self,
+        coordinate: NDArray,
+        inclusion_probability: NDArray,
+        *,
+        n_clusters: int,
+        n_zones: tuple[int, int],
+        tolerance: int,
+    ) -> None:
+        self.coords = coordinate
+        self.probs = inclusion_probability
+        self.n_clusters = n_clusters
+        self.n_zones = n_zones
+        self.tolerance = tolerance
+
+        self.clusters = self._generate_clusters()
+
+    def _generate_clusters(self) -> list[Cluster]:
+        # kmeans = SoftBalancedKMeans(self.n_clusters, tolerance=self.tolerance)
+        # kmeans.fit(self.coords, self.probs)
+
+        # agg = AggregateBalancedKMeans(k=self.n_clusters, tolerance=self.tolerance)
+        # agg.fit(self.coords, self.probs.reshape(-1, 1), np.array([1]))
+
+        dbk = DublyBalancedKMeans(k=self.n_clusters)
+        dbk.fit(self.coords, self.probs)
+
+        return [
+            Cluster(units=units, zones=self._generate_zones(units))
+            # for units in agg.get_clusters()
+            for units in dbk.clusters
+        ]
+
+    def _generate_zones(self, units) -> list[Zone]:
+        vertical_zones = self._sweep(
+            units[np.argsort(units[:, 1])], 1 / self.n_zones[0]
+        )
+        zones = []
+        for zone in vertical_zones:
+            units_of_basic_zones = self._sweep(
+                zone[np.argsort(zone[:, 2])], 1 / (np.prod(self.n_zones))
+            )
+            for units in units_of_basic_zones:
+                units[:, 3] = self._numerical_stabilizer(units[:, 3])
+                zones.append(Zone(units=units))
+        return zones
+
+    def _sweep(
+        self, units: NDArray, threshold: float
+    ) -> tuple[list[NDArray], list[int]]:
+        boarder_units_remainings, zones_indices = self._generate_boarders_and_indices(
+            units, threshold
+        )
+        swept_zones = []
+        for indices in pairwise(zones_indices):
+            zone, boarder_units_remainings = self._sweep_zone(
+                units, boarder_units_remainings, indices, threshold
+            )
+            swept_zones.append(zone)
+        return swept_zones
+
+    def _generate_boarders_and_indices(self, units: NDArray, threshold: float):
+        thresholds = np.arange(
+            threshold, np.sum(units[:, 3]) - threshold / 2, threshold
+        )
+        indices = np.concatenate(
+            (
+                [0],
+                np.searchsorted(units[:, 3].cumsum(), thresholds, side="right"),
+                [units.shape[0] - 1],
+            )
+        )
+        boarder_units = {index: units[index][3] for index in np.unique(indices)}
+        return boarder_units, indices
+
+    def _sweep_zone(
+        self,
+        units: NDArray,
+        boarder_units_remainings: NDArray,
+        indices: tuple[NDArray, NDArray],
+        threshold: float,
+    ) -> NDArray:
+        zone, start_remainder = self._sweep_boarder_unit(
+            np.array([]).reshape(0, 4),
+            units[indices[0]],
+            boarder_units_remainings[indices[0]],
+            threshold,
+        )
+        boarder_units_remainings[indices[0]] = start_remainder
+
+        zone = np.concatenate([zone, units[indices[0] + 1 : indices[1]]])
+
+        zone, stop_remainder = self._sweep_boarder_unit(
+            zone,
+            units[indices[1]],
+            boarder_units_remainings[indices[1]],
+            threshold - np.sum(zone[:, 3]),
+        )
+        boarder_units_remainings[indices[1]] = stop_remainder
+
+        return zone, boarder_units_remainings
+
+    def _sweep_boarder_unit(
+        self, zone: NDArray, unit: NDArray, probability: float, threshold: float
+    ) -> tuple[NDArray, float]:
+        if probability < 10**-self.tolerance:
+            return zone, 0
+        if threshold < 10**-self.tolerance:
+            return zone, probability
+        if probability < threshold - 10**-self.tolerance:
+            return np.concatenate(
+                [zone, np.append(unit[:3], probability).reshape(1, -1)]
+            ), 0
+        elif probability > threshold + 10**-self.tolerance:
+            return np.concatenate(
+                [zone, np.append(unit[:3], threshold).reshape(1, -1)]
+            ), probability - threshold
+        return np.concatenate([zone, np.append(unit[:3], threshold).reshape(1, -1)]), 0
+
+    def _numerical_stabilizer(self, probs: NDArray) -> NDArray:
+        probs_stabled = np.round(probs, self.tolerance)
+        probs_stabled *= 1 / (np.sum(probs_stabled) * np.prod(self.n_zones))
+        return probs_stabled
+
+    def plot(self, ax=None, figsize: tuple[int, int] = (8, 6)) -> None:
+        if ax is None:
+            fig, ax = plt.subplots(figsize=figsize)
+
+        def plot_convex_hull(
+            points, ax, color, alpha=0.3, edge_color="black", line_width=1.0
+        ):
+            if len(points) < 3:
+                return ax, None
+            hull = ConvexHull(points)
+            polygon = Polygon(
+                points[hull.vertices],
+                closed=True,
+                facecolor=color,
+                alpha=alpha,
+                edgecolor=edge_color,
+                lw=line_width,
+            )
+            ax.add_patch(polygon)
+            return ax, hull
+
+        for cluster_idx, cluster in enumerate(self.clusters):
+            cluster_points = cluster.units[:, 1:3]
+            cluster_color = plt.cm.tab10(cluster_idx % 10)
+            ax, _ = plot_convex_hull(cluster_points, ax, color=cluster_color, alpha=0.2)
+            ax.scatter(
+                cluster_points[:, 0],
+                cluster_points[:, 1],
+                color=cluster_color,
+                label=f"Cluster {cluster_idx+1}",
+                alpha=0.8,
+            )
+
+            for zone_idx, zone in enumerate(cluster.zones):
+                zone_points = zone.units[:, 1:3]
+                zone_color = cluster_color
+                ax, hull = plot_convex_hull(
+                    zone_points,
+                    ax,
+                    color=zone_color,
+                    alpha=0.4,
+                    edge_color="gray",
+                    line_width=0.8,
+                )
+
+                hull_center = np.mean(
+                    zone_points if hull is None else zone_points[hull.vertices], axis=0
+                )
+                ax.text(
+                    hull_center[0],
+                    hull_center[1],
+                    f"{zone_idx+1}",
+                    color="black",
+                    fontsize=16,
+                    alpha=0.3,
+                    ha="center",
+                    va="center",
+                    weight="bold",
+                )
+        return ax
+
+    def plot_with_samples(self, samples: NDArray, max_cols: int = 4) -> None:
+        n_samples = len(samples)
+        n_cols = min(max_cols, n_samples)
+        n_rows = (n_samples + n_cols - 1) // n_cols
+        figsize = (5 * n_cols, 5 * n_rows)
+
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+        axes = axes.flatten() if n_samples > 1 else [axes]
+
+        for sample_idx, sample in enumerate(samples):
+            ax = axes[sample_idx]
+            ax = self.plot(ax)
+            ax.scatter(
+                self.coords[sample][:, 0],
+                self.coords[sample][:, 1],
+                color="black",
+                marker="X",
+                alpha=0.8,
+                s=200,
+                label=f"Sample {sample_idx+1}",
+            )
+            ax.set_title(f"Sample {sample_idx+1}")
+
+        for ax in axes[n_samples:]:
+            fig.delaxes(ax)

graphical_sampling/sampling/random_sampling.py

@@ -0,0 +1,21 @@
+import numpy as np
+from numpy.typing import NDArray
+
+
+class RandomSampling:
+    def __init__(
+        self,
+        coordinate: NDArray,
+        inclusion_probability: NDArray,
+        n: int,
+    ) -> None:
+        self.coords = coordinate
+        self.probs = inclusion_probability
+        self.n = n
+        self.rng = np.random.default_rng()
+
+    def sample(self, n_samples: int):
+        return np.array(
+            [self.rng.integers(0, self.probs.shape[0], size=self.n) for _ in range(n_samples)],
+            dtype=int
+        )

graphical_sampling/search/__init__.py

@@ -0,0 +1,4 @@
+from .astar import AStar
+
+
+__all__ = ["AStar"]

graphical_sampling/search/astar.py

@@ -0,0 +1,119 @@
+from dataclasses import dataclass
+from typing import Generator, Any
+
+import numpy as np
+
+from ..criteria.criteria import Criteria
+from ..design import Design
+from ..red_black_tree import RedBlackTree
+
+
+@dataclass(frozen=True, order=False, eq=False)
+class Node:
+    criteria_value: float
+    design: Design
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, Node):
+            return NotImplemented
+        return self.criteria_value < other.criteria_value
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Node):
+            return NotImplemented
+        return self.criteria_value == other.criteria_value
+
+    def __le__(self, other: Any) -> bool:
+        return self < other or self == other
+
+    def __ge__(self, other: Any) -> bool:
+        return not self < other
+
+    def __gt__(self, other: Any) -> bool:
+        return other < self
+
+
+class AStar:
+    def __init__(
+        self,
+        initial_design: Design,
+        criteria: Criteria,
+        *,
+        switch_coefficient: float = 0.5,
+        random_pull: bool = False,
+        threshold: float = 1e-2,
+        rng: np.random.Generator = np.random.default_rng(),
+    ) -> None:
+        self.initial_design = initial_design
+        self.criteria = criteria
+        self.switch_coefficient = switch_coefficient
+        self.random_pull = random_pull
+        self.threshold = threshold
+        self.rng = rng
+
+        self.initial_criteria_value = self.criteria(self.initial_design)
+        self.best_design = self.initial_design
+        self.best_criteria_value = self.initial_criteria_value
+
+    def iterate_design(self, design: Design, num_changes: int) -> Design:
+        new_design = design.copy()
+        for _ in range(num_changes):
+            new_design.iterate(
+                random_pull=self.random_pull,
+                switch_coefficient=self.switch_coefficient,
+            )
+        return new_design
+
+    def neighbors(
+        self,
+        design: Design,
+        num_new_nodes: int,
+        num_changes: int,
+    ) -> Generator[Design, None, None]:
+        for _ in range(num_new_nodes):
+            yield self.iterate_design(design, num_changes)
+
+    def run(
+        self,
+        max_iterations: int,
+        num_new_nodes: int,
+        max_open_set_size: int,
+        num_changes: int,
+    ):
+        closed_set = set()
+        open_set = RedBlackTree[Node]()
+        open_set.insert(Node(self.initial_criteria_value, self.initial_design))
+
+        for it in range(max_iterations):
+            if not open_set:
+                break
+            mn = open_set.get_min()
+            if not mn:
+                break
+            current_design = mn.design
+            if current_design in closed_set:
+                continue
+            closed_set.add(current_design)
+            for new_design in self.neighbors(
+                current_design, num_new_nodes, num_changes
+            ):
+                new_criteria_value = self.criteria(new_design)
+
+                if new_design in closed_set:
+                    continue
+                if len(open_set) < max_open_set_size:
+                    open_set.insert(Node(new_criteria_value, new_design))
+                else:
+                    mx = open_set.get_max()
+                    if mx is None or mx.criteria_value > new_criteria_value:
+                        if mx is not None:
+                            open_set.remove(mx)
+                        open_set.insert(Node(new_criteria_value, new_design))
+
+                if new_criteria_value < self.best_criteria_value:
+                    self.best_design = new_design
+                    self.best_criteria_value = new_criteria_value
+
+                    if self.best_criteria_value < self.threshold:
+                        return it
+        return max_iterations

graphical_sampling/structs.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+import heapq
+from dataclasses import dataclass
+from typing import Iterator, Generic, Collection, Optional, Any
+from typing import TypeVar
+
+import numpy as np
+
+from .type import ComparableNegatable
+
+T = TypeVar("T", bound=ComparableNegatable)
+
+
+class MaxHeap(Generic[T]):
+    def __init__(
+        self,
+        initial_heap: Optional[Collection[T]] = None,
+        rng: np.random.Generator = np.random.default_rng(),
+    ):
+        self.heap: list[T] = []
+        if initial_heap is not None:
+            self.heap = [-item for item in initial_heap]
+            heapq.heapify(self.heap)
+        self.rng = rng
+
+    def push(self, item: T):
+        heapq.heappush(self.heap, -item)
+
+    def pop(self) -> T:
+        return -heapq.heappop(self.heap)
+
+    def peek(self) -> T:
+        return -self.heap[0]
+
+    def randompop(self) -> T:
+        idx = self.rng.integers(len(self.heap))
+        val = -self.heap[idx]
+        self.heap[idx] = self.heap[-1]
+        self.heap.pop()
+        if idx < len(self.heap):
+            heapq._siftup(self.heap, idx)  # type: ignore
+            heapq._siftdown(self.heap, 0, idx)  # type: ignore
+        return val
+
+    def copy(self) -> MaxHeap[T]:
+        new_heap = MaxHeap[T]()
+        new_heap.heap = self.heap[:]
+        new_heap.rng = self.rng
+        return new_heap
+
+    def __len__(self) -> int:
+        return len(self.heap)
+
+    def __bool__(self) -> bool:
+        return bool(self.heap)
+
+    def __iter__(self) -> Iterator[T]:
+        return map(lambda x: -x, self.heap)
+
+    def __str__(self):
+        return str(list(map(lambda x: -x, self.heap)))
+
+    def __hash__(self) -> int:
+        return hash(tuple(self.heap))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, MaxHeap):
+            return NotImplemented
+        return self.heap == other.heap
+
+
+@dataclass(order=False)
+class Sample:
+    probability: float
+    ids: frozenset[int]
+
+    def almost_zero(self) -> bool:
+        return self.probability < 1e-9
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Sample):
+            return NotImplemented
+        return self.probability == other.probability and self.ids == other.ids
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, Sample):
+            return NotImplemented
+        return self.probability < other.probability
+
+    def __neg__(self) -> Sample:
+        return Sample(-self.probability, self.ids)
+
+    def __hash__(self):
+        return hash(self.ids)

graphical_sampling/type.py

@@ -0,0 +1,17 @@
+from abc import abstractmethod
+from typing import Protocol, Any
+
+
+class Comparable(Protocol):
+    @abstractmethod
+    def __eq__(self, other: Any) -> bool: ...
+
+    @abstractmethod
+    def __lt__(self, other: Any) -> bool: ...
+
+
+class Negatable(Protocol):
+    def __neg__(self) -> "Negatable": ...
+
+
+class ComparableNegatable(Comparable, Negatable, Protocol): ...

graphical_sampling-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: graphical-sampling
+Version: 0.1.0
+Summary: Python package for Graphical Sampling Method
+Author-email: Bardia Panahbehagh <bardia.panah@gmail.com>, Mehdi Mohebbi <mehdi.mohebbi23@gmail.com>, AmirMohammad HosseiniNasab <awmirhn@gmail.com>, Mehdi Hosseini Moghadam <m.h.moghadam1996@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: k-means-constrained>=0.7.5
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: package-sampling>=0.3.0
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+
+# Graphical Sampling Method - Python Package
+
+The Graphical Sampling Method, introduced by Panahbehagh (2025), presents an innovative approach to finite population sampling based on a unique graphical framework. This method allows researchers to visually depict first-order inclusion probabilities (FIP) as bars on a two-dimensional graph. By adjusting the positions of these bars, users can explore a wide range of sampling designs while controlling second-order inclusion probabilities (SIP).
+
+This package, `graphical_sampling`, provides tools for implementing the Graphical Sampling Method and is available on PyPI.
+
+---
+
+## Features
+- Create various unequal probability sampling designs with a fixed FIP.
+- Control and explore second-order inclusion probabilities (SIP) through visual manipulation.
+- Incorporate search algorithms, such as A* and Genetic Algorithm, to optimize sampling designs for specific needs (e.g., well-spread or optimal sampling).
+
+## Installation
+
+Install the package via pip:
+```bash
+pip install graphical_sampling
+```
+
+## How to Use
+
+The package includes core classes and methods to facilitate sampling design creation and optimization. Below is a basic example demonstrating the API.
+
+### Example Usage
+
+```python
+import graphical_sampling as gs
+import numpy as np
+
+# Set up random generator and sample data
+rng = np.random.default_rng()
+N = 50  # Population size
+x = rng.random(size=N)  # Auxiliary variable
+n = 5  # Sample size
+
+# Generate initial inclusion probabilities
+inclusion = rng.random(N)
+inclusion *= n / inclusion.sum()
+
+# Define initial sampling design and evaluation criteria
+initial_design = gs.Design(inclusion)
+nht = gs.criteria.VarNHT(x, inclusion)
+astar = gs.search.AStar(initial_design, nht, switch_coefficient=1)
+
+# Display initial criteria and design
+print("Initial criteria value:", astar.initial_criteria_value)
+astar.initial_design.show()
+
+# Run the A* search algorithm to optimize the design
+astar.run(max_iterations=2000, num_new_nodes=10, max_open_set_size=10000, num_changes=1)
+
+# Display results after optimization
+print("Best criteria value:", astar.best_criteria_value)
+astar.best_design.show()
+```
+
+
+## Maintainers
+
+- Bardia Panahbehagh - [bardia.panah@gmail.com](mailto:bardia.panah@gmail.com)
+- Mehdi Mohebbi - [mehdi.mohebbi23@gmail.com](mailto:mehdi.mohebbi23@gmail.com)
+- AmirMohammad HosseiniNasab - [awmirhn@gmail.com](mailto:awmirhn@gmail.com)
+- Mehdi Hosseini Moghadam - [m.h.moghadam1996@gmail.com](mailto:m.h.moghadam1996@gmail.com)
+
+---
+
+For more details, consult the official paper: Panahbehagh, B. (2025). Graphical Sampling Method.

graphical_sampling-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+graphical_sampling/__init__.py,sha256=bb5HqAY4pgCI8x__PSHsHnadxOTmxkJUzim6clFZLAU,340
+graphical_sampling/design.py,sha256=BtuCSp6tpXB54T_WppN-1JiCUj59cgghHUagj1EfyG8,4083
+graphical_sampling/red_black_tree.py,sha256=IPrlUfSLhXL0VXuPraCboskD7u7vizKX-wDVF5gWlDs,16633
+graphical_sampling/structs.py,sha256=ZDRG-DmH_DDeLzW10dP_nC5AkLc3dAQ3hGFPwedZXYQ,2533
+graphical_sampling/type.py,sha256=TECZp9fU_ydavkKOE-Lds4sx5f2C6WgcWfZ5WKZz8Xo,364
+graphical_sampling/clustering/__init__.py,sha256=K8F84-uCEZYt1iui9vTrUkiKhDYO9dPRN2vwSVcPcMA,588
+graphical_sampling/clustering/aggregate.py,sha256=uVd8Mmp8qFt2C9t9IUk6sYDGihK51T_8onmeQ_XvswM,8037
+graphical_sampling/clustering/dubly_balanced_clustering.py,sha256=2LbNzpZnqoehC1Ou6dEfl8J_75hEj8Y0e6tKYKfZjlI,7791
+graphical_sampling/clustering/one_boundary.py,sha256=pA9nuF8QW-GsJ1UW0Nuuof9iudP9KeH1AZasi8Gp9Y0,9532
+graphical_sampling/clustering/soft_balanced_kmeans.py,sha256=LAEEZ6iFxmQukgS3KalFwKwE_lMVcC58rBahuh1gl-M,6143
+graphical_sampling/criteria/__init__.py,sha256=ruthywH9WgPKcHuPrPDztPzofv8KrriLyrdZsdGgUHg,51
+graphical_sampling/criteria/criteria.py,sha256=ImL0fvutHVhUsMbk7N8RTF1V8VV0o-WGzv5AABWACmw,298
+graphical_sampling/criteria/var_nht.py,sha256=8L15HBfo_Zz1VgF5LQTqpeq-sIAULSAs9We-awL_u6g,700
+graphical_sampling/measure/__init__.py,sha256=2E0yd8sxUso8_fYB7SC4DO0dpfMw7Fz531lSeQbdLHQ,53
+graphical_sampling/measure/density.py,sha256=mGSrdhJWsLZ1VYof7ISQ6E6v5IA_PEAfzXeHuy9eJp0,3882
+graphical_sampling/random/__init__.py,sha256=K8MGYYz9svNRV_gwqXungGFd4f6gA6I1NKxMnJSyRAQ,47
+graphical_sampling/random/generator.py,sha256=ZrWizUpJiqaiK4FXiA-TZcWceDhjC95I_owtPwtF2mQ,10926
+graphical_sampling/sampling/__init__.py,sha256=nTweLFsRqf5klvbowJiVDn0gVax80i69KMUmgP6tkHI,208
+graphical_sampling/sampling/kmeans_spatial_sampling.py,sha256=b6InONfN6tphlyt37RiQok4K4E2otymVXT1_PZYN0hs,2062
+graphical_sampling/sampling/population.py,sha256=-wmXYJr6Ren6r7LAe4fB4ogxL_lp-KHVaxVkXHUrT7k,7885
+graphical_sampling/sampling/random_sampling.py,sha256=JARWmciRuVObVM0WQqj-uAr2D2Lj0IMjgr0Ti0yaQro,538
+graphical_sampling/search/__init__.py,sha256=Ag3JJcApUbE_Lct9qExrTYvHmxjlpq2x_yEXtwRwI2s,47
+graphical_sampling/search/astar.py,sha256=wvMRGjjMkBC8kqyJ2wgc5OJh3snjPs0-SBSHmUdgkyM,3815
+graphical_sampling-0.1.0.dist-info/METADATA,sha256=Ec2nHamNHbsIvgLgCr7AI2AuFIQID4HZmAKW5P-KHH0,3220
+graphical_sampling-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+graphical_sampling-0.1.0.dist-info/licenses/LICENSE,sha256=1xF-ubUdk0b37lCULLgZ_WltcT3__rvChYoNxtwMGJE,1070
+graphical_sampling-0.1.0.dist-info/RECORD,,

graphical_sampling-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

graphical_sampling-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mehdi Mohebbi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.