Calcolare la distanza in chilometri tra due coordinate con Go

Calcolare la distanza tra due coordinate geografiche (latitudine e longitudine) è una problematica comune nello sviluppo di applicazioni che richiedono il calcolo delle distanze tra punti sulla superficie terrestre. Il linguaggio Go (Golang) offre un ambiente perfetto per implementare questo tipo di operazioni in maniera efficiente. In questo articolo, ti guiderò attraverso i passaggi per calcolare la distanza in chilometri tra due coordinate utilizzando la formula dell'Haversine.

La formula dell'haversine è un'equazione che consente di calcolare la distanza del percorso più breve (la "distanza ortodromica") tra due punti su una sfera, in particolare sulla superficie terrestre, considerando la curvatura del pianeta.

La formula è la seguente:

$$a = \sin^2\left(\frac{\Delta \varphi}{2}\right) + \cos(\varphi_1) \cdot \cos(\varphi_2) \cdot \sin^2\left(\frac{\Delta \lambda}{2}\right)$$

$$c = 2 \cdot \text{atan2}\left(\sqrt{a}, \sqrt{1-a}\right)$$

$$d = R \cdot c$$

Ecco un esempio di come implementare il calcolo della distanza utilizzando la formula dell'Haversine:

package main

import (
    "fmt"
    "math"
)

// Funzione per convertire i gradi in radianti
func toRadians(degrees float64) float64 {
    return degrees * math.Pi / 180
}

// Funzione per calcolare la distanza tra due coordinate
func haversine(lat1, lon1, lat2, lon2 float64) float64 {
    const R = 6371 // Raggio della Terra in km

    // Convertire le coordinate da gradi a radianti
    lat1Rad := toRadians(lat1)
    lon1Rad := toRadians(lon1)
    lat2Rad := toRadians(lat2)
    lon2Rad := toRadians(lon2)

    // Differenze tra le coordinate
    deltaLat := lat2Rad - lat1Rad
    deltaLon := lon2Rad - lon1Rad

    // Applicare la formula dell'Haversine
    a := math.Sin(deltaLat/2)*math.Sin(deltaLat/2) +
        math.Cos(lat1Rad)*math.Cos(lat2Rad)*
            math.Sin(deltaLon/2)*math.Sin(deltaLon/2)
    c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))

    // Calcolare la distanza
    distance := R * c
    return distance
}

func main() {
    // Coordinate di esempio
    lat1 := 41.9028  // Roma
    lon1 := 12.4964
    lat2 := 48.8566  // Parigi
    lon2 := 2.3522

    // Calcolare la distanza
    distance := haversine(lat1, lon1, lat2, lon2)

    // Stampare il risultato
    fmt.Printf("La distanza tra le coordinate è: %.2f km\n", distance)
}

Spiegazione del codice:

1. toRadians: Questa funzione converte i gradi in radianti, essenziale per l'uso delle funzioni trigonometriche.
2. haversine: Questa funzione prende in input le coordinate di due punti (latitudine e longitudine) e restituisce la distanza in chilometri. Si basa sulla formula dell'Haversine.
3. main: Qui vengono definiti i punti di esempio (Roma e Parigi), e la distanza tra loro viene calcolata e stampata.

Alcune considerazioni:

• Precisione: La formula dell'Haversine è accurata per la maggior parte delle distanze, ma potrebbe non essere perfetta su scala molto ridotta o a latitudini molto elevate, dove la curvatura della Terra diventa più significativa. In questi casi, è possibile considerare formule più complesse come la Vincenty formula.

• Prestazioni: Il calcolo dell'Haversine è computazionalmente poco costoso e può essere eseguito rapidamente anche su grandi dataset di coordinate geografiche.

Conclusione

Il calcolo della distanza tra due coordinate geografiche è un problema comune che può essere risolto facilmente in Go utilizzando la formula dell'Haversine. Con pochi passi, abbiamo visto come implementare questa formula e ottenere distanze precise in chilometri. Grazie alla semplicità e alle potenti librerie matematiche di Go, questo tipo di calcolo è rapido e efficiente, rendendo Go una scelta eccellente per le applicazioni che richiedono operazioni geografiche.