%global _empty_manifest_terminate_build 0 Name: python-haversine Version: 2.8.0 Release: 1 Summary: Calculate the distance between 2 points on Earth. License: MIT URL: https://github.com/mapado/haversine Source0: https://mirrors.nju.edu.cn/pypi/web/packages/b9/6b/0a774af6a2eea772aa99e5fbc7af7711eba02ff0dee3e71838c1b5926ef5/haversine-2.8.0.tar.gz BuildArch: noarch %description # Haversine Calculate the distance (in various units) between two points on Earth using their latitude and longitude. ## Installation ```sh pip install haversine ``` ## Usage ### Calculate the distance between Lyon and Paris ```python from haversine import haversine, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) haversine(lyon, paris) >> 392.2172595594006 # in kilometers haversine(lyon, paris, unit=Unit.MILES) >> 243.71250609539814 # in miles # you can also use the string abbreviation for units: haversine(lyon, paris, unit='mi') >> 243.71250609539814 # in miles haversine(lyon, paris, unit=Unit.NAUTICAL_MILES) >> 211.78037755311516 # in nautical miles ``` The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon). If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter. The `haversine.Unit` enum contains all supported units: ```python import haversine print(tuple(haversine.Unit)) ``` outputs ```text (, , , , , , , ) ``` #### Note for radians and degrees The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere. Notes: - on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians) - When using "degree", this angle is just converted from radians to degrees ### Inverse Haversine Formula Calculates a point from a given vector (distance and direction) and start point. Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions. But also allows for explicit angles expressed in Radians. ## Example: Finding arbitary point from Paris ```python from haversine import inverse_haversine, Direction from math import pi paris = (48.8567, 2.3508) # (lat, lon) # Finding 32 km west of Paris inverse_haversine(paris, 32, Direction.WEST) # returns tuple (48.85587279023947, 1.9134085092836945) # Finding 32 km southwest of Paris inverse_haversine(paris, 32, pi * 1.25) # returns tuple (48.65279552300661, 2.0427666779658806) # Finding 50 miles north of Paris inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES) # returns tuple (49.58035791599536, 2.3508) # Finding 10 nautical miles south of Paris inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES) # returns tuple (48.690145868497645, 2.3508) ``` ### Performance optimisation for distances between all points in two vectors You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors. For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/). You can then do this: ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS) >> array([ 392.21725956, 6163.43638211]) ``` It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors. ### Combine matrix You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True. ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) london = (51.509865, -0.118092) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True) >> array([[ 392.21725956, 343.37455271], [6163.43638211, 5586.48447423]]) ``` The output array from the example above returns the following table: | | Paris | New York | | ------ | :---------------: | :------------------: | | Lyon | Lyon <\-> Paris | Lyon <\-> New York | | London | London <\-> Paris | London <\-> New York | By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_. ## Contributing Clone the project. Install [pipenv](https://github.com/pypa/pipenv). Run `pipenv install --dev` Launch test with `pipenv run pytest` %package -n python3-haversine Summary: Calculate the distance between 2 points on Earth. Provides: python-haversine BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-haversine # Haversine Calculate the distance (in various units) between two points on Earth using their latitude and longitude. ## Installation ```sh pip install haversine ``` ## Usage ### Calculate the distance between Lyon and Paris ```python from haversine import haversine, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) haversine(lyon, paris) >> 392.2172595594006 # in kilometers haversine(lyon, paris, unit=Unit.MILES) >> 243.71250609539814 # in miles # you can also use the string abbreviation for units: haversine(lyon, paris, unit='mi') >> 243.71250609539814 # in miles haversine(lyon, paris, unit=Unit.NAUTICAL_MILES) >> 211.78037755311516 # in nautical miles ``` The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon). If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter. The `haversine.Unit` enum contains all supported units: ```python import haversine print(tuple(haversine.Unit)) ``` outputs ```text (, , , , , , , ) ``` #### Note for radians and degrees The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere. Notes: - on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians) - When using "degree", this angle is just converted from radians to degrees ### Inverse Haversine Formula Calculates a point from a given vector (distance and direction) and start point. Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions. But also allows for explicit angles expressed in Radians. ## Example: Finding arbitary point from Paris ```python from haversine import inverse_haversine, Direction from math import pi paris = (48.8567, 2.3508) # (lat, lon) # Finding 32 km west of Paris inverse_haversine(paris, 32, Direction.WEST) # returns tuple (48.85587279023947, 1.9134085092836945) # Finding 32 km southwest of Paris inverse_haversine(paris, 32, pi * 1.25) # returns tuple (48.65279552300661, 2.0427666779658806) # Finding 50 miles north of Paris inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES) # returns tuple (49.58035791599536, 2.3508) # Finding 10 nautical miles south of Paris inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES) # returns tuple (48.690145868497645, 2.3508) ``` ### Performance optimisation for distances between all points in two vectors You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors. For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/). You can then do this: ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS) >> array([ 392.21725956, 6163.43638211]) ``` It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors. ### Combine matrix You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True. ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) london = (51.509865, -0.118092) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True) >> array([[ 392.21725956, 343.37455271], [6163.43638211, 5586.48447423]]) ``` The output array from the example above returns the following table: | | Paris | New York | | ------ | :---------------: | :------------------: | | Lyon | Lyon <\-> Paris | Lyon <\-> New York | | London | London <\-> Paris | London <\-> New York | By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_. ## Contributing Clone the project. Install [pipenv](https://github.com/pypa/pipenv). Run `pipenv install --dev` Launch test with `pipenv run pytest` %package help Summary: Development documents and examples for haversine Provides: python3-haversine-doc %description help # Haversine Calculate the distance (in various units) between two points on Earth using their latitude and longitude. ## Installation ```sh pip install haversine ``` ## Usage ### Calculate the distance between Lyon and Paris ```python from haversine import haversine, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) haversine(lyon, paris) >> 392.2172595594006 # in kilometers haversine(lyon, paris, unit=Unit.MILES) >> 243.71250609539814 # in miles # you can also use the string abbreviation for units: haversine(lyon, paris, unit='mi') >> 243.71250609539814 # in miles haversine(lyon, paris, unit=Unit.NAUTICAL_MILES) >> 211.78037755311516 # in nautical miles ``` The lat/lon values need to be provided in degrees of the ranges [-90,90] (lat) and [-180,180] (lon). If values are outside their ranges, an error will be raised. This can be avoided by automatic normalization via the `normalize` parameter. The `haversine.Unit` enum contains all supported units: ```python import haversine print(tuple(haversine.Unit)) ``` outputs ```text (, , , , , , , ) ``` #### Note for radians and degrees The radian and degrees returns the [great circle distance](https://en.wikipedia.org/wiki/Great-circle_distance) between two points on a sphere. Notes: - on a unit-sphere the angular distance in radians equals the distance between the two points on the sphere (definition of radians) - When using "degree", this angle is just converted from radians to degrees ### Inverse Haversine Formula Calculates a point from a given vector (distance and direction) and start point. Currently explicitly supports both cardinal (north, east, south, west) and intercardinal (northeast, southeast, southwest, northwest) directions. But also allows for explicit angles expressed in Radians. ## Example: Finding arbitary point from Paris ```python from haversine import inverse_haversine, Direction from math import pi paris = (48.8567, 2.3508) # (lat, lon) # Finding 32 km west of Paris inverse_haversine(paris, 32, Direction.WEST) # returns tuple (48.85587279023947, 1.9134085092836945) # Finding 32 km southwest of Paris inverse_haversine(paris, 32, pi * 1.25) # returns tuple (48.65279552300661, 2.0427666779658806) # Finding 50 miles north of Paris inverse_haversine(paris, 50, Direction.NORTH, unit=Unit.MILES) # returns tuple (49.58035791599536, 2.3508) # Finding 10 nautical miles south of Paris inverse_haversine(paris, 10, Direction.SOUTH, unit=Unit.NAUTICAL_MILES) # returns tuple (48.690145868497645, 2.3508) ``` ### Performance optimisation for distances between all points in two vectors You will need to install [numpy](https://pypi.org/project/numpy/) in order to gain performance with vectors. For optimal performance, you can turn off coordinate checking by adding `check=False` and install the optional packages [numba](https://pypi.org/project/numba/) and [icc_rt](https://pypi.org/project/icc_rt/). You can then do this: ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS) >> array([ 392.21725956, 6163.43638211]) ``` It is generally slower to use `haversine_vector` to get distance between two points, but can be really fast to compare distances between two vectors. ### Combine matrix You can generate a matrix of all combinations between coordinates in different vectors by setting `comb` parameter as True. ```python from haversine import haversine_vector, Unit lyon = (45.7597, 4.8422) # (lat, lon) london = (51.509865, -0.118092) paris = (48.8567, 2.3508) new_york = (40.7033962, -74.2351462) haversine_vector([lyon, london], [paris, new_york], Unit.KILOMETERS, comb=True) >> array([[ 392.21725956, 343.37455271], [6163.43638211, 5586.48447423]]) ``` The output array from the example above returns the following table: | | Paris | New York | | ------ | :---------------: | :------------------: | | Lyon | Lyon <\-> Paris | Lyon <\-> New York | | London | London <\-> Paris | London <\-> New York | By definition, if you have a vector _a_ with _n_ elements, and a vector _b_ with _m_ elements. The result matrix _M_ would be $n x m$ and a element M\[i,j\] from the matrix would be the distance between the ith coordinate from vector _a_ and jth coordinate with vector _b_. ## Contributing Clone the project. Install [pipenv](https://github.com/pypa/pipenv). Run `pipenv install --dev` Launch test with `pipenv run pytest` %prep %autosetup -n haversine-2.8.0 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-haversine -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Fri Apr 21 2023 Python_Bot - 2.8.0-1 - Package Spec generated