2010-12-27 16 views
8

Questo codice di script java e di esempio è da link text
Guarda la sezione sulle lossodromie.- javascript to php


Dato un punto iniziale e una distanza d lungo il rilevamento costante θ, questo calcola il punto di destinazione. Se si mantiene un rilevamento costante lungo una lossodromia, si avanza gradualmente verso uno dei poli.

Formula:

α = d/R (angular distance) 
    lat2 = lat1 + α.cos(θ) 
    Δφ = ln(tan(lat2/2+π/4)/tan(lat1/2+π/4)) [= the ‘stretched’ latitude difference] 
if E:W line q = cos(lat1)  
otherwise q = Δlat/Δφ 
    Δlon = α.sin(θ)/q 
    lon2 = (lon1+Δlon+π) % 2.π − π 
    where ln is natural log and % is modulo, Δlon is taking shortest route (<180°), and R is the earth’s radius 

JavaScript:

lat2 = lat1 + d*Math.cos(brng); 
var dPhi = Math.log(Math.tan(lat2/2+Math.PI/4)/Math.tan(lat1/2+Math.PI/4)); 
var q = (!isNaN(dLat/dPhi)) ? dLat/dPhi : Math.cos(lat1); // E-W line gives dPhi=0 
var dLon = d*Math.sin(brng)/q; 
// check for some daft bugger going past the pole, normalise latitude if so 
if (Math.abs(lat2) > Math.PI/2) lat2 = lat2>0 ? Math.PI-lat2 : -(Math.PI-lat2); 
lon2 = (lon1+dLon+Math.PI)%(2*Math.PI) - Math.PI; 

Sto cercando di convertirlo in sintassi di PHP, ma io non sto ottenendo il risultato desiderato. Ho la parte di latitudine che funziona bene. Ho anche incluso i miei dati di test.


MIO CODICE PHP

// test data 
$R = 6371; 
$tlatitude = 50.7; 
$tlongitude = -105.214; 
$theading = 124; 
$d = 50; 

$projlat = $tlatitude + rad2deg(($d/$R)*COS(deg2rad($theading))); 

//Δφ = ln(tan(lat2/2+π/4)/tan(lat1/2+π/4)) 
$delta_phi = log(tan(deg2rad($projlat/2) + pi()/4)/(tan(deg2rad($tlatitude/2) + pi()/4))); 

//q = Δlat/Δφ 
$delta_lat = deg2rad($projlat - $tlatitude); 

$q = $delta_lat/$delta_phi; 


//Δlon = α.sin(θ)/q 
$delta_long = rad2deg($d/$R*sin(deg2rad($theading))/$q); 

$projlong = $tlongitude + $delta_long; 

ottengo $projlong = -104.84

secondo la pagina fa riferimento la risposta dovrebbe essere -104.63.

Ora sto cercando di farlo funzionare senza tener conto dell'est-ovest e delle possibilità del polo.

+1

Incollare nel proprio codice PHP e aggiungere una riga 'echo round ($ projlong, 2);' mi dà l'output '-104.63'. Ottieni l'output di '-104,84'? – thirtydot

+0

sì, quello che stavo ottenendo .... tuttavia ho seguito il tuo piombo e incollato il "mio" codice in una nuova pagina HTML/php e ho ottenuto la risposta corretta .... guardando la mia pagina originale ho scoperto che avevo ho usato pi invece di pi() e questo sembra influenzare il risultato ... Penso che stavo inseguendo la mia coda. – brian

+7

Se hai trovato l'errore, scrivilo come risposta e impostalo come accettato, in modo che la domanda non rimanga aperta. –

risposta

0

javascript ha più precisione rispetto php un'occhiata a questa battuta http://ru2.php.net/manual/en/function.doubleval.php

una volta che ho bisogno di controllare alcune IBAN con l'algoritmo di Luhn. Il mio codice javascript ha funzionato bene. Ma il mio php non è riuscito, quindi dopo alcune ricerche, ho trovato lo scherzo e ho dovuto ricodificare le operazioni di base (add, sub, compute, divide, modulo) in base alla stringa e non al numero.

Forse dovresti ricodificarlo anche tu, per ottenere la tua precisione prevista. Non dovremmo usare php per calcoli di alta precisione.

1

Ho avuto alcuni problemi durante i calcoli della distanza in cui i miei errori sarebbero cresciuti un po 'dopo un po'. Ho scoperto che se facevo un cast per (doppio) nel mio codice la precisione aumentava. Non ho esaminato il codice C in PHP per vedere cosa ha causato questo però. Potrei dopo aver scaricato la mia versione BC del codice.

Se è necessaria maggiore precisione, consultare le funzioni BC in PHP. http://php.net/manual/en/book.bc.php

Inoltre, si ricorda che l'ordine di esecuzione dei calcoli in un computer influirà sulla precisione.Cioè, il calcolo muggito

$d/$R*sin(deg2rad($theading))/$q 

non renderà lo stesso risultato di

$d*sin(deg2rad($theading))/$q/$R 

e questo può anche dare un terzo risultato

$d*sin(deg2rad($theading))/($q*$R) 

Questo ha a che fare con la precisione limitata per i numeri vicini allo zero (0) nei computer.