disponibilità in Python

Question

SymPy è un ottimo strumento per fare conversioni di unità in Python:

>>> from sympy.physics import units 
>>> 12. * units.inch/units.m 
0.304800000000000 

Si può facilmente rotolare il proprio:

>>> units.BTU = 1055.05585 * units.J 
>>> units.BTU 
1055.05585*m**2*kg/s**2 

Tuttavia, non posso implementare questa nella mia applicazione, a meno Posso convertire i gradi C (assoluto) in K in gradi F in gradi R o qualsiasi combinazione di essi.

ho pensato che forse qualcosa di simile a questo dovrebbe funzionare:

units.degC = <<somefunc of units.K>> 

Ma è chiaro che questa è la strada sbagliata per scendere. Qualche suggerimento per implementare in modo pulito le conversioni delle unità di tipo "offset" in SymPy?

Nota: sono aperto a provare altri moduli di conversione unità, ma non conosco alcun altro oltre a Unum e l'ho trovato ingombrante.

Modifica: OK, ora è chiaro che ciò che voglio fare è determinare innanzitutto se le due grandezze da confrontare si trovano nello stesso sistema di coordinate. (come le unità di tempo che fanno riferimento a epoche o fusi orari diversi o dB a un'ampiezza diretta), effettuare la trasformazione appropriata, quindi effettuare la conversione. Esistono strumenti generali di gestione dei sistemi di coordinate? Sarebbe grandioso.

Vorrei supporre che ° F e ° C si riferiscano sempre ad Δ ° F Δ ° C ​​all'interno di un'espressione ma si riferiscono ad assoluto quando si è soli. Mi stavo chiedendo se ci fosse un modo per rendere una funzione units.degF e schiaffare un decoratore property() su di esso per far fronte a queste due condizioni.

Ma per ora, mi misi units.C == units.K e cercare di mettere bene in chiaro nella documentazione utilizzare le funzioni convertCtoK(...) e convertFtoR(...) quando si tratta di unità assolute. (Sto scherzando No non lo farò..)

Answer 1

Personalmente mi piace Quantities grazie alla sua integrazione NumPy, tuttavia fa solo temperature relative, non assolute.

Answer 2

La documentazione Unum ha una buona writeup sul perché questo è difficile:

Unum è in grado di gestire in modo affidabile le conversioni tra ° Celsius e Kelvin. Il problema è indicato come "problema di origine falsa": lo 0 ° Celsius è definito come 273,15 K. Questo è davvero un caso speciale e noioso, poiché in generale il valore 0 non è influenzato dalla conversione di unità, ad es. 0 [m] = 0 [miglia] = .... Qui, la conversione Kelvin/° Celsius è caratterizzata da un fattore 1 e un offset di 273,15 K. L'offset non è fattibile nella versione corrente di Unum.

Inoltre, presumibilmente non sarà mai integrato in una versione futura perché esiste anche un problema concettuale: l'offset dovrebbe essere applicato se la quantità rappresenta una temperatura assoluta, ma non dovrebbe se la quantità rappresenta una differenza di temperature. Ad esempio, un innalzamento della temperatura di 1 ° C è equivalente a un aumento di 1 K. È impossibile indovinare cosa c'è nella mente dell'utente, che si tratti di una temperatura assoluta o relativa. La questione delle quantità assolute e relative non è importante per le altre unità poiché la risposta non influisce sulla regola di conversione. Unum non è in grado di fare la distinzione tra i due casi.

È piuttosto facile vedere concettualmente i problemi cercando di rappresentare simbolicamente la conversione della temperatura assoluta. Con qualsiasi unità relativa normale, la matematica dell'unità (x unit) * 2 == (x * 2) unit è commutativa.Con temperature assolute, che si rompono, è difficile fare qualcosa di più complesso delle conversioni di temperatura diritte senza altre dimensioni dell'unità. Probabilmente stai meglio tenere tutti i calcoli in Kelvin e convertirli in e da altre unità di temperatura solo nei punti di entrata e di uscita del tuo codice.

Answer 3

esempio, come potrebbe funzionare:

>>> T(0*F) + 10*C 
T(265.37222222222221*K) # or T(47767/180*K) 
>>> T(0*F + 10*C) 
T(283.15*K) 
>>> 0*F + T(10*C) 
T(283.15*K) 
>>> 0*F + 10*C 
10*K 
>>> T(0*F) + T(10*C) 
Traceback (most recent call last): 
File "<stdin>", line 1, in <module> 
TypeError: unsupported operand type(s) for +: 'absolute_temperature' and \ 
'absolute_temperature' 
>>> T(0*F) - T(10*C) 
T(245.37222222222223*K) # or T(44167/180*K) 
>>> 0*F - 10*C 
-10*K 

Answer 4

Il pacchetto natu gestisce unità di temperatura. Per esempio, si può fare questo: sono supportati anche

>>> from natu.units import K, degC, degF 
>>> T = 25*degC 
>>> T/K 
298.1500 
>>> T/degF 
77.0000 
>>> 0*degC + 100*K 
100.0 degC 

prefissi:

>>> from natu.units import mdegC 
>>> 100*mdegC/K 
273.2500 

natu gestisce anche le unità non lineari come la decibel, non solo quelli con offset come degree Celsius e degree Fahrenheit.

relativi al primo esempio che ha dato, si può fare questo:.

>>> from natu import units 
>>> 12*units.inch/units.m 
0.3048 

BTU è già integrato nel È possibile modificare la sua unità di visualizzazione di m ** 2 * kg/s ** 2, ma per impostazione predefinita natu semplifica l'unità su J:

>>> from natu.units import BTU 
>>> BTU.display = 'm2*kg/s2' 
>>> 1*BTU 
1055.05585262 J