Apskaičiuokite atstumą tarp dviejų platumos ilgumos? (Formula Haversina)

Kaip apskaičiuoti atstumą tarp dviejų taškų, pateiktų pagal platumą ir ilgumą?

Norėdami paaiškinti, norėčiau, kad atstumas būtų kilometrais; taškai naudoja WGS84 sistemą, ir norėčiau suprasti, koks yra santykinis tikslumas.

761
26 авг. nustatė Robin Minto 26 rug. 2008-08-26 15:50 '08, 15:50, 2008-08-26 15:50
@ 37 atsakymai
  • 1
  • 2

Ši nuoroda jums gali būti naudinga, nes ji išsamiai apibūdina Haverseen formulės naudojimą atstumui apskaičiuoti.

Ištraukos:

Šis scenarijus [„Javascript“) apskaičiuoja didelius atstumus tarp dviejų taškų - tai yra trumpiausias atstumas virš žemės - naudojant „Haversein“ formulę.

948
26 авг. atsakymas, pateiktas 26 d. 2008-08-26 15:55 '08 at 15:55 2008-08-26 15:55

Turėjau apskaičiuoti daugybę atstumų tarp mano projekto taškų, todėl aš eidavau į priekį ir bandžiau optimizuoti čia rastą kodą. Vidutiniškai skirtingose ​​naršyklėse mano naujasis diegimas yra 2 kartus greitesnis už labiausiai rekomenduojamą atsakymą.

čia . 

Neseniai turėjau daryti tą patį ir „python“, todėl čia yra „ python“ įgyvendinimas:

Haversine “ wiki. 

283
07 февр. atsakymą pateikė Salvador Dali 07 Feb. 2014-02-07 11:52 '14 at 11:52 AM 2014-02-07 11:52

Čia pateikiamas C # įgyvendinimas:

59
19 окт. atsakymas, kurį pateikė jaircazarin-old-account Oct 19 2008-10-19 04:30 '08, 4:30, 2008-10-19 04:30

Čia pateikiamas „Haversin“ formulės „Java“ įgyvendinimas.

52
26 сент. Atsakymas duotas whostolebenfrog 26 Sep. 2012-09-26 14:00 '12 14:00 val. 2012-09-26 14:00

Labai ačiū už visa tai. „IPhone“ programoje „Objective-C“ naudoju šį kodą:

 -(double)kilometresBetweenPlace1:(CLLocationCoordinate2D) place1 andPlace2:(CLLocationCoordinate2D) place2 { MKMapPoint start, finish; start = MKMapPointForCoordinate(place1); finish = MKMapPointForCoordinate(place2); return MKMetersBetweenMapPoints(start, finish) / 1000; } 
40
07 дек. Atsakymas, kurį pateikė Stephen Watson 07 Dec 2010-12-07 16:56 '10, 16:56, 2010-12-07 16:56

Tai paprasta PHP funkcija, kuri suteiks labai protingą apytikslį (+/- 1% klaida).

Vikipedijos geografinis atstumas 

35
24 июня '12 в 17:11 2012-06-24 17:11 atsakymą tony gil pateikė birželio 24 d. 12 d. 17:11 2012-06-24 17:11

Aš skelbiu čia savo darbo pavyzdį.

Išvardinkite visus lentelės taškus, kurių atstumas tarp priskirto taško (naudojame atsitiktinį tašką - lat: 45.20327, ilgas: 23.7806) yra mažesnis nei 50 km, platumos ir ilgumos, MySQL (lentelės laukai yra kodų koordinatės ir stulpelių koordinatės)

Sąrašas visų, turinčių DISTANCE <50 kilometrų (Žemės spindulys yra 6371 km):

27
13 марта '12 в 2:37 2012-03-13 02:37 atsakymas pateikiamas conualfy kovo 13, 12, 2:37 2012-03-13 02:37

Kitais atsakymais trūksta įgyvendinimo .

Skaičiuojant atstumą tarp dviejų taškų yra gana paprasta, kai geosphere paketo distm yra:

 distm(p1, p2, fun = distHaversine) 

kur:

 p1 = longitude/latitude for point(s) p2 = longitude/latitude for point(s) # type of distance calculation fun = distCosine / distHaversine / distVincentySphere / distVincentyEllipsoid 

Kadangi žemė nėra visiškai sferinė, „ Vincenty“ elipsoidų formulė tikriausiai yra geriausias būdas apskaičiuoti atstumus. Taigi naudodami geosphere paketą:

 distm(p1, p2, fun = distVincentyEllipsoid) 

Žinoma, jums nereikia naudoti geosphere paketo, taip pat galite apskaičiuoti atstumą R bazėje naudodami šią funkciją:

 hav.dist <- function(long1, lat1, long2, lat2) { R <- 6371 diff.long <- (long2 - long1) diff.lat <- (lat2 - lat1) a <- sin(diff.lat/2)^2 + cos(lat1) * cos(lat2) * sin(diff.long/2)^2 b <- 2 * asin(pmin(1, sqrt(a))) d = R * b return(d) } 
22
16 апр. Atsakyti Jaap balandžio 16 d 2014-04-16 00:59 '14 prie 0:59 2014-04-16 00:59

„Haversin“ tikrai yra gera formulė, tikriausiai daugeliu atvejų, kiti atsakymai jau yra įtraukti, todėl aš nesiruošiu užimti vietos. Tačiau svarbu pažymėti, kad nesvarbu, kokia formulė naudojama (taip, ne tik viena). Dėl didelio galimo tikslumo diapazono ir reikalingo skaičiavimo laiko. Pasirinkus formulę reikia šiek tiek daugiau minties nei paprastas paprastas atsakymas.

Tai yra žinutė iš NASA asmens, geriausias, kurį aptinku aptarinėdamas galimybes

http://www.cs.nyu.edu/visual/home/proj/tiger/gisfaq.html

Pavyzdžiui, jei paprasčiausiai rūšiuojate linijas pagal atstumą 100 km spinduliu. Plokščios žemės formulė bus daug greičiau nei Haversinas.

 HalfPi = 1.5707963; R = 3956;  a = HalfPi - latoriginrad; b = HalfPi - latdestrad; u = a * a + b * b; v = - 2 * a * b * cos(longdestrad - longoriginrad); c = sqrt(abs(u + v)); return R * c; 

Atkreipkite dėmesį, kad yra tik viena kosina ir viena kvadratinė šaknis. Vs 9 iš jų pagal Haversino formulę.

8
04 нояб. Atsakymas pateikiamas Arturo Hernandez 04 lapkričio. 2013-11-04 19:20 '13, 19:20, 2013-11-04 19:20

Jūs galite naudoti surinkimą CLLocationDistance, kad apskaičiuotumėte:

 CLLocation *location1 = [[CLLocation alloc] initWithLatitude:latitude1 longitude:longitude1]; CLLocation *location2 = [[CLLocation alloc] initWithLatitude:latitude2 longitude:longitude2]; [self distanceInMetersFromLocation:location1 toLocation:location2] - (int)distanceInMetersFromLocation:(CLLocation*)location1 toLocation:(CLLocation*)location2 { CLLocationDistance distanceInMeters = [location1 distanceFromLocation:location2]; return distanceInMeters; } 

Jūsų atveju, jei jums reikia kilometrų, tiesiog juos padalinkite iš 1000.

7
26 июня '13 в 11:43 2013-06-26 11:43 atsakymą davė André Cytryn birželio 26 d. 13 val. 11:43 2013-06-26 11:43

Nenoriu pridėti kito atsakymo, tačiau „Google“ žemėlapių v.3 API turi sferinę geometriją (ir daug daugiau). Konvertavę WGS84 dešimtainiais laipsniais, galite tai padaryti:

 <script src="http://maps.google.com/maps/api/js?sensor=false type="text/javascript"></script> distance = google.maps.geometry.spherical.computeDistanceBetween( new google.maps.LatLng(fromLat, fromLng), new google.maps.LatLng(toLat, toLng)); 

Nėra žodžių apie tai, kaip tiksliai „Google“ skaičiavimai yra ar kokie modeliai yra naudojami (nors jis sako „sferinis“, o ne „geoidas“.) Beje, „tiesios linijos“ atstumas, žinoma, skirsis nuo atstumo, jei vienas važiuoja ant žemės paviršiaus tai, matyt, atrodo visiems.

6
20 июля '14 в 3:10 2014-07-20 03:10 atsakymą pateikė Steven Christenson liepos 20 d. 14 d. 3:10 2014-07-20 03:10

Gali būti paprastesnis sprendimas ir teisingesnis: žemės perimetras lygiagrete yra 40 000 km, apie 37 000 - pagal Grinvičo ciklą (arba bet kurią ilgumą). Taigi:

 pythagoras = function (lat1, lon1, lat2, lon2) { function sqr(x) {return x * x;} function cosDeg(x) {return Math.cos(x * Math.PI / 180.0);} var earthCyclePerimeter = 40000000.0 * cosDeg((lat1 + lat2) / 2.0); var dx = (lon1 - lon2) * earthCyclePerimeter / 360.0; var dy = 37000000.0 * (lat1 - lat2) / 360.0; return Math.sqrt(sqr(dx) + sqr(dy)); }; 

Sutinku, kad jis turėtų būti tiksliai sureguliuotas, nes aš pats sakiau, kad tai elipsoidas, todėl spindulys, kurį reikia padauginti iš kosininių pokyčių. Bet tai šiek tiek tikslesnė. Palyginti su „Google“ žemėlapiais, tai labai sumažino klaidą.

5
10 февр. Atsakymą pateikė Meymann , vasario 10 d. 2016-02-10 10:26 '16 at 10:26 AM 2016-02-10 10:26

Atvirkščiai, tai priklauso nuo to, kaip tiksliai norite būti ir kokie yra datų lat ir ilgai. Labai, labai apytiksliai, jūs sukuriate mažą sferinį trigerį, bet ištaisysite faktą, kad žemė nėra sfera, formulės ją apsunkina.

5
26 авг. Atsakymą pateikė Pete Kirkham 26 rug. 2008-08-26 15:59 '08 at 15:59 2008-08-26 15:59

Visi aukščiau pateikti atsakymai rodo, kad žemė yra sfera. Tačiau tikslesnis apytikslis būtų plokščiam sferoidui.

 a= 6378.137#equitorial radius in km b= 6356.752#polar radius in km def Distance(lat1, lons1, lat2, lons2): lat1=math.radians(lat1) lons1=math.radians(lons1) R1=(((((a**2)*math.cos(lat1))**2)+(((b**2)*math.sin(lat1))**2))/((a*math.cos(lat1))**2+(b*math.sin(lat1))**2))**0.5 #radius of earth at lat1 x1=R*math.cos(lat1)*math.cos(lons1) y1=R*math.cos(lat1)*math.sin(lons1) z1=R*math.sin(lat1) lat2=math.radians(lat2) lons2=math.radians(lons2) R1=(((((a**2)*math.cos(lat2))**2)+(((b**2)*math.sin(lat2))**2))/((a*math.cos(lat2))**2+(b*math.sin(lat2))**2))**0.5 #radius of earth at lat2 x2=R*math.cos(lat2)*math.cos(lons2) y2=R*math.cos(lat2)*math.sin(lons2) z2=R*math.sin(lat2) return ((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)**0.5 
5
17 июня '16 в 1:25 2016-06-17 01:25 Atsakymą pateikė Keerthana Gopalakrishnan, birželio 17 d., 16 d., 1:25 2016-06-17 01:25

Čia yra „Haversin“ formulės įdiegimas

 static getDistanceFromLatLonInKm(lat1: number, lon1: number, lat2: number, lon2: number): number { var deg2Rad = deg => { return deg * Math.PI / 180; } var r = 6371; // Radius of the earth in km var dLat = deg2Rad(lat2 - lat1); var dLon = deg2Rad(lon2 - lon1); var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(deg2Rad(lat1)) * Math.cos(deg2Rad(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2); var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); var d = r * c; // Distance in km return d; } 
4
12 дек. atsakymas duotas Sel 12 Dec. 2015-12-12 18:59 '15, 18:59 2015-12-12 18:59

Eksperimentavimas „Python Origin“ yra gretimų JAV centras.

 from haversine import haversine origin = (39.50, 98.35) paris = (48.8567, 2.3508) haversine(origin, paris, miles=True) 

Norėdami gauti atsakymą kilogramais, tiesiog nustatykite mylių = false.

4
14 июля '15 в 8:52 2015-07-14 08:52 atsakymas pateikiamas invoketheshell liepos 14 d. 15, 8:52 2015-07-14 08:52

Norint apskaičiuoti atstumą tarp dviejų taškų sferoje, reikia atlikti „ Great Circle“ skaičiavimą .

Yra keletas C / C + + bibliotekų, kurios gali padėti su žemėlapio projekcija MapTools, jei reikia dvigubai patikrinti savo atstumus iki plokščio paviršiaus. Norėdami tai padaryti, jums reikės skirtingų koordinačių sistemų projekcinės linijos.

MapWindow“ taip pat galite rasti naudingą taškų vizualizavimo priemonę. Be to, kaip atviro kodo šaltinis, tai yra naudingas vadovas, leidžiantis naudoti proj.dll biblioteką, kuri, atrodo, yra pagrindinė atviro kodo projekcijos biblioteka.

3
19 окт. atsakymą pateikė vartotojo18443 19 okt. 2008-10-19 04:30 '08, 4:30, 2008-10-19 04:30

Šis scenarijus [PHP] apskaičiuoja atstumą tarp dviejų taškų.

 public static function getDistanceOfTwoPoints($source, $dest, $unit='K') { $lat1 = $source[0]; $lon1 = $source[1]; $lat2 = $dest[0]; $lon2 = $dest[1]; $theta = $lon1 - $lon2; $dist = sin(deg2rad($lat1)) * sin(deg2rad($lat2)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * cos(deg2rad($theta)); $dist = acos($dist); $dist = rad2deg($dist); $miles = $dist * 60 * 1.1515; $unit = strtoupper($unit); if ($unit == "K") { return ($miles * 1.609344); } else if ($unit == "M") { return ($miles * 1.609344 * 1000); } else if ($unit == "N") { return ($miles * 0.8684); } else { return $miles; } } 
3
21 февр. atsakymą pateikė Er.Subhendu Kumar Pati 21 vas. 2017-02-21 10:04 '17, 10:04 2017-02-21 10:04

Čia priimtas atsakymo įgyvendinimas perduodamas „Java“, jei to reikia.

 package com.project529.garage.util;  private static double EARTH_RADIUS = 6371;  public double getDistanceBetween(double lat1, double lon1, double lat2, double lon2) { double dLat = toRadians(lat2 - lat1); double dLon = toRadians(lon2 - lon1); double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2); double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); double d = EARTH_RADIUS * c; return d; } public double toRadians(double degrees) { return degrees * (Math.PI / 180); } 
2
12 окт. atsakymas duotas Eddnav Oct 12 2015-10-12 23:59 '15, 23:59 pm 2015-10-12 23:59

Aš sumažinau skaičiavimus, supaprastinant formulę.

Čia jis yra Ruby:

 include Math earth_radius_mi = 3959 radians = lambda { |deg| deg * PI / 180 } coord_radians = lambda { |c| { :lat => radians[c[:lat]], :lng => radians[c[:lng]] } } # from/to = { :lat => (latitude_in_degrees), :lng => (longitude_in_degrees) } def haversine_distance(from, to) from, to = coord_radians[from], coord_radians[to] cosines_product = cos(to[:lat]) * cos(from[:lat]) * cos(from[:lng] - to[:lng]) sines_product = sin(to[:lat]) * sin(from[:lat]) return earth_radius_mi * acos(cosines_product + sines_product) end 
2
13 июня '13 в 5:16 2013-06-13 05:16 atsakymą pateikė „ Kache “ birželio 13 d. 13 d. 5:16 2013-06-13 05:16

Naudodami „MySQL“ naudokite šią funkciją, perduodant parametrus naudodami POINT(LONG,LAT)

 CREATE FUNCTION `distance`(a POINT, b POINT) RETURNS double DETERMINISTIC BEGIN RETURN GLength( LineString(( PointFromWKB(a)), (PointFromWKB(b)))) * 100000; -- To Make the distance in meters END; 
1
28 мая '14 в 11:59 2014-05-28 11:59 Atsakymas duotas shanavascet gegužės 28, 14, 11:59 2014-05-28 11:59

Čia yra mano „Java“ programa, skirta apskaičiuoti atstumą dešimtainiais laipsniais po tam tikros paieškos. Aš naudoju vidutinį pasaulio spindulį (iš Vikipedijos) km. Jei norite gauti mylių, naudokite pasaulio spindulį myliomis.

 public static double distanceLatLong2(double lat1, double lng1, double lat2, double lng2) { double earthRadius = 6371.0d; // KM: use mile here if you want mile result double dLat = toRadian(lat2 - lat1); double dLng = toRadian(lng2 - lng1); double a = Math.pow(Math.sin(dLat/2), 2) + Math.cos(toRadian(lat1)) * Math.cos(toRadian(lat2)) * Math.pow(Math.sin(dLng/2), 2); double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); return earthRadius * c; // returns result kilometers } public static double toRadian(double degrees) { return (degrees * Math.PI) / 180.0d; } 
1
12 февр. atsakymą pateikė user2881716 , vasario 12 d. 2014-02-12 23:52 '14, 23:52 pm 2014-02-12 23:52

Kaip minėta, tiksliu skaičiavimu turi būti atsižvelgiama į tai, kad žemė nėra ideali sritis. Pateikiami keli čia siūlomų algoritmų palyginimai:

 geoDistance(50,5,58,3) Haversine: 899 km Maymenn: 833 km Keerthana: 897 km google.maps.geometry.spherical.computeDistanceBetween(): 900 km geoDistance(50,5,-58,-3) Haversine: 12030 km Maymenn: 11135 km Keerthana: 10310 km google.maps.geometry.spherical.computeDistanceBetween(): 12044 km geoDistance(.05,.005,.058,.003) Haversine: 0.9169 km Maymenn: 0.851723 km Keerthana: 0.917964 km google.maps.geometry.spherical.computeDistanceBetween(): 0.917964 km geoDistance(.05,80,.058,80.3) Haversine: 33.37 km Maymenn: 33.34 km Keerthana: 33.40767 km google.maps.geometry.spherical.computeDistanceBetween(): 33.40770 km 

Trumpais atstumais Keerthana algoritmas sutampa su „Google“ žemėlapių algoritmu. Atrodo, kad „Google“ žemėlapiai neatlieka jokių paprastų algoritmų, rodančių, kad tai gali būti pats tiksliausias metodas.

Bet kokiu atveju, čia yra „Keerthana“ algoritmo įgyvendinimas „Javascript“:

 function geoDistance(lat1, lng1, lat2, lng2){ const a = 6378.137; // equitorial radius in km const b = 6356.752; // polar radius in km var sq = x => (x*x); var sqr = x => Math.sqrt(x); var cos = x => Math.cos(x); var sin = x => Math.sin(x); var radius = lat => sqr((sq(a*a*cos(lat))+sq(b*b*sin(lat)))/(sq(a*cos(lat))+sq(b*sin(lat)))); lat1 = lat1 * Math.PI / 180; lng1 = lng1 * Math.PI / 180; lat2 = lat2 * Math.PI / 180; lng2 = lng2 * Math.PI / 180; var R1 = radius(lat1); var x1 = R1*cos(lat1)*cos(lng1); var y1 = R1*cos(lat1)*sin(lng1); var z1 = R1*sin(lat1); var R2 = radius(lat2); var x2 = R2*cos(lat2)*cos(lng2); var y2 = R2*cos(lat2)*sin(lng2); var z2 = R2*sin(lat2); return sqr(sq(x1-x2)+sq(y1-y2)+sq(z1-z2)); } 
1
19 апр. Atsakymas pateikiamas Chong Lip Phang 19 Bal. 2018-04-19 11:42 '18 at 11:42 2018-19 11:42
 function getDistanceFromLatLonInKm(lat1,lon1,lat2,lon2,units) { var R = 6371; // Radius of the earth in km var dLat = deg2rad(lat2-lat1); // deg2rad below var dLon = deg2rad(lon2-lon1); var a = Math.sin(dLat/2) * Math.sin(dLat/2) + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.sin(dLon/2) * Math.sin(dLon/2) ; var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); var d = R * c; var miles = d / 1.609344; if ( units == 'km' ) { return d; } else { return miles; }} 

„Chuck“ sprendimas, galiojantis mylių.

1
08 нояб. Atsakymą pateikė MPaulo 08 lapkričio. 2013-11-08 09:34 '13, 9:34 am 2013-11-08 09:34
 function getDistanceFromLatLonInKm(position1, position2) { "use strict"; var deg2rad = function (deg) { return deg * (Math.PI / 180); }, R = 6371, dLat = deg2rad(position2.lat - position1.lat), dLng = deg2rad(position2.lng - position1.lng), a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(deg2rad(position1.lat)) * Math.cos(deg2rad(position1.lat)) * Math.sin(dLng / 2) * Math.sin(dLng / 2), c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); return R * c; } console.log(getDistanceFromLatLonInKm( {lat: 48.7931459, lng: 1.9483572}, {lat: 48.827167, lng: 2.2459745} )); 
1
29 апр. Atsakymas, kurį pateikė Raphael C Bal 29 2015-04-29 17:22 '15, 17:22 PM 2015-04-29 17:22

Čia yra VB.NET įgyvendinimas, šis įgyvendinimas suteiks jums KM arba Miles rezultatą, remiantis Enum verte.

 Public Enum DistanceType Miles KiloMeters End Enum Public Structure Position Public Latitude As Double Public Longitude As Double End Structure Public Class Haversine Public Function Distance(Pos1 As Position, Pos2 As Position, DistType As DistanceType) As Double Dim R As Double = If((DistType = DistanceType.Miles), 3960, 6371) Dim dLat As Double = Me.toRadian(Pos2.Latitude - Pos1.Latitude) Dim dLon As Double = Me.toRadian(Pos2.Longitude - Pos1.Longitude) Dim a As Double = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(Me.toRadian(Pos1.Latitude)) * Math.Cos(Me.toRadian(Pos2.Latitude)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2) Dim c As Double = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a))) Dim result As Double = R * c Return result End Function Private Function toRadian(val As Double) As Double Return (Math.PI / 180) * val End Function End Class 
1
02 апр. Atsakymas pateikiamas Taiseer Joudeh 02 Bal. 2013-04-02 11:35 '13, 11:35, 2013-04-02 11:35

Yra geras pavyzdys, kaip apskaičiuoti atstumą su PHP http://www.geodatasource.com/developers/php :

  function distance($lat1, $lon1, $lat2, $lon2, $unit) { $theta = $lon1 - $lon2; $dist = sin(deg2rad($lat1)) * sin(deg2rad($lat2)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * cos(deg2rad($theta)); $dist = acos($dist); $dist = rad2deg($dist); $miles = $dist * 60 * 1.1515; $unit = strtoupper($unit); if ($unit == "K") { return ($miles * 1.609344); } else if ($unit == "N") { return ($miles * 0.8684); } else { return $miles; } } 
1
15 янв. atsakymas pateikiamas ayalcinkaya sausio 15 d 2013-01-15 04:48 '13, 4:48, 2013-01-15 04:48

čia yra pavyzdys postgres sql (km, už mylių, pakeiskite versiją 1.609344 su 0.8684)

 CREATE OR REPLACE FUNCTION public.geodistance(alat float, alng float, blat float, blng float) RETURNS float AS $BODY$ DECLARE v_distance float; BEGIN v_distance = asin( sqrt( sin(radians(blat-alat)/2)^2 + ( (sin(radians(blng-alng)/2)^2) * cos(radians(alat)) * cos(radians(blat)) ) ) ) * cast('7926.3352' as float) * cast('1.609344' as float) ; RETURN v_distance; END $BODY$ > 
1
21 дек. Atsakymas suteikiamas fiskai 21 d. 2016-12-21 10:34 '16 at 10:34 am 2016-12-21 10:34

Turite klaidą - metodą „ne“

Taigi buvo pakeista pirmiau aprašyto Rad metodo skambinimo procedūra.

 toRad(lat2-lat1) Math.cos(toRad(lat1)) 

ir pridėjo metodą -

 //degrees to radians function toRad(degree) { rad = degree* Math.PI/ 180; return rad; } 
1
28 сент. atsakymas pateikiamas Avi C 28 Sep 2011-09-28 22:22 '11 prie 22:22 pm 2011-09-28 22:22

„Java“ diegimas pagal „Haversine“ formulę

  • 1
  • 2