Struttura dei dati per accedere alle unità di misura

Le librerie Boost per C ++ includono un articolo su analisi dimensionale che presenta un'implementazione di esempio della gestione delle unità di misura.

Riassumendo: le unità di misura sono rappresentate come vettori, con ogni elemento del vettore che rappresenta una dimensione fondamentale:

typedef int dimension[7]; // m  l  t  ...
dimension const mass      = {1, 0, 0, 0, 0, 0, 0};
dimension const length    = {0, 1, 0, 0, 0, 0, 0};
dimension const time      = {0, 0, 1, 0, 0, 0, 0};

Le unità derivate sono combinazioni di queste. Ad esempio, forza (massa * distanza / tempo ^ 2) sarebbe rappresentata come

dimension const force  = {1, 1, -2, 0, 0, 0, 0};

Le unità Imperial contro SI possono essere gestite aggiungendo un fattore di conversione.

Questa implementazione si basa su tecniche specifiche del C ++ (usando la metaprogrammazione del modello per trasformare facilmente diverse unità di misura in diversi tipi di tempo di compilazione), ma i concetti dovrebbero trasferirsi ad altri linguaggi di programmazione.

Ho appena rilasciato Units.NET su Github e su NuGet .

Ti dà tutte le unità e le conversioni comuni. È leggero, unità testata e supporta PCL.

Verso la tua domanda:

• Questo è nella parte più leggera delle implementazioni. Il focus è di aiutare nella rappresentazione inequivocabile, nella conversione e nella costruzione di unità di misura.
• Non esiste un risolutore di equazioni, non ricava automaticamente nuove unità dai calcoli.
• Un grande enume per la definizione delle unità.
• Classe UnitConverter per la conversione dinamica tra unità.
• Strutture dati immutabili per la conversione esplicita tra le unità.
• Operatori sovraccaricati per aritmetica semplice.
• Estendere a nuove unità e conversioni è questione di aggiungere una nuova enumerazione per la conversione dinamica e aggiungere un'unità di misura di classe, come Lunghezza, per definire proprietà esplicite di conversione e sovraccarico dell'operatore.

Devo ancora vedere il Santo Graal delle soluzioni in questo settore. Come affermi, può facilmente diventare troppo complesso o troppo prolisso per lavorare. A volte, è meglio mantenere le cose semplici e per le mie esigenze questo approccio si è dimostrato sufficiente.

Conversione esplicita

Length meter = Length.FromMeters(1);
double cm = meter.Centimeters; // 100
double yards = meter.Yards; // 1.09361
double feet = meter.Feet; // 3.28084
double inches = meter.Inches; // 39.3701

Pressure p = Pressure.FromPascal(1);
double kpa = p.KiloPascals; // 1000
double bar = p.Bars; // 1 × 10-5
double atm = p.Atmosphere; // 9.86923267 × 10-6
double psi = p.Psi; // 1.45037738 × 10-4

Conversione dinamica

// Explicitly
double m = UnitConverter.Convert(1, Unit.Kilometer, Unit.Meter); // 1000
double mi = UnitConverter.Convert(1, Unit.Kilometer, Unit.Mile); // 0.621371
double yds = UnitConverter.Convert(1, Unit.Meter, Unit.Yard); // 1.09361

// Or implicitly.
UnitValue val = GetUnknownValueAndUnit();

// Returns false if conversion was not possible.
double cm;
val.TryConvert(LengthUnit.Centimeter, out cm);

Se riesci a passare a F # usando C #, F # ha un sistema di unità di misura (implementato usando i metadati sui valori) che sembra si adatti a ciò che stai cercando di fare:

link

In particolare:

// Additionally, we can define types measures which are derived from existing measures as well:

[<Measure>] type m                  (* meter *)
[<Measure>] type s                  (* second *)
[<Measure>] type kg                 (* kilogram *)
[<Measure>] type N = (kg * m)/(s^2) (* Newtons *)
[<Measure>] type Pa = N/(m^2)       (* Pascals *)

Sulla base del fatto che tutte le conversioni richieste sono le ridimensionamenti delle conversioni (eccetto se devi supportare le conversioni di temperatura. I calcoli in cui la conversione implica un offset sono significativamente più complessi), progetterei il mio sistema di "unità di misura" in questo modo:

• Una classe unit contenente un fattore di scala, una stringa per la rappresentazione testuale dell'unità e un riferimento a cui unit scala. La rappresentazione testuale è lì per scopi di visualizzazione e il riferimento all'unità di base per sapere a quale unità si trova il risultato quando si fa la matematica su valori con unità diverse.

  Per ogni unità supportata, viene fornita un'istanza statica della classe unit .

• Una classe UOM contenente un valore e un riferimento al unit del valore. La classe UOM fornisce operatori sovraccaricati per l'aggiunta / sottrazione di un altro UOM e per la moltiplicazione / divisione con un valore adimensionale.

  Se l'addizione / sottrazione viene eseguita su due UOM con lo stesso unit , viene eseguita direttamente. Altrimenti entrambi i valori vengono convertiti nelle rispettive unità di base e aggiunti / sottratti. Il risultato è riportato come base unit .

L'utilizzo sarebbe come

unit volts = new unit(1, "V"); // base-unit is self
unit Newtons = new unit(1, "N"); // base-unit is self
unit kiloNewtons = new unit(1000, "kN", Newtons);
//...
UOM myUom1 = new UOM(10, volts);
UOM myUom2 = new UOM(43.2, kiloNewtons);

Poiché le operazioni su unità incompatibili non sono considerate un problema, non ho cercato di rendere il design sicuro per il tipo in questo senso. È possibile aggiungere un controllo di runtime verificando che due unità si riferiscano alla stessa unità di base.

Pensa a ciò che sta facendo il tuo codice e cosa permetterà. Avere una semplice enumerazione con tutte le unità possibili in esso consente di fare qualcosa come convertire Volt in metri. Ovviamente non è valido per un umano, ma il software sarà felice di provarlo.

Ho fatto qualcosa di vagamente simile a questo una volta, e la mia implementazione aveva classi base astratte (lunghezza, peso, ecc.) che tutte implementavano IUnitOfMeasure . Ogni classe di basi astratte ha definito un tipo predefinito (classe Length ha un'implementazione predefinita di classe Meter ) che userebbe per tutti i lavori di conversione. Quindi IUnitOfMeasure ha implementato due metodi diversi, ToDefault(decimal) e FromDefault(decimal) .

Il numero effettivo che volevo avvolgere era un tipo generico che accetta IUnitOfMeasure come argomento generico. Dire qualcosa come Measurement<Meter>(2.0) ti dà sicurezza di tipo automatico. L'implementazione delle corrette conversioni implicite e dei metodi matematici su queste classi consente di fare cose come Measurement<Meter>(2.0) * Measurement<Inch>(12) e restituire un risultato nel tipo predefinito ( Meter ). Non ho mai elaborato unità derivate come Newton; Li ho semplicemente lasciati come Kilogram * Meter / Second / Second.

Credo che la risposta sia nella risposta Overflow dello stack di MarioVW a:

Practical Example Where Tuple can be used in .Net 4-0?

With tuples you could easily implement a two-dimensional dictionary (or n-dimensional for that matter). For example, you could use such a dictionary to implement a currency exchange mapping:

var forex = new Dictionary<Tuple<string, string>, decimal>();
forex.Add(Tuple.Create("USD", "EUR"), 0.74850m); // 1 USD = 0.74850 EUR
forex.Add(Tuple.Create("USD", "GBP"), 0.64128m);
forex.Add(Tuple.Create("EUR", "USD"), 1.33635m);
forex.Add(Tuple.Create("EUR", "GBP"), 0.85677m);
forex.Add(Tuple.Create("GBP", "USD"), 1.55938m);
forex.Add(Tuple.Create("GBP", "EUR"), 1.16717m);
forex.Add(Tuple.Create("USD", "USD"), 1.00000m);
forex.Add(Tuple.Create("EUR", "EUR"), 1.00000m);
forex.Add(Tuple.Create("GBP", "GBP"), 1.00000m);
decimal result;
result = 35.0m * forex[Tuple.Create("USD", "EUR")]; // USD 35.00 = EUR 26.20
result = 35.0m * forex[Tuple.Create("EUR", "GBP")]; // EUR 35.00 = GBP 29.99
result = 35.0m * forex[Tuple.Create("GBP", "USD")]; // GBP 35.00 = USD 54.58

Avevo un bisogno simile per la mia applicazione. Tuple è anche immutabile, il che vale anche per oggetti come pesi e misure ... Come dice il proverbio "una pinta fa un giro il mondo intorno".

Il mio codice prototype: link

I miei punti di progettazione:

1. Scelta di UM (Unità di misura) come proprietà get / set

   Length len = new Length();
   len.Meters = 2.0;
   Console.WriteLine(len.Feet);
   

2. Costruttore con nome per la scelta di UoM

   Length len = Length.FromMeters(2.0);
   

3. Supporto ToString per UoM

   Console.WriteLine(len.ToString("ft"));
   Console.WriteLine(len.ToString("F15"));
   Console.WriteLine(len.ToString("ftF15"));
   

4. Conversione di andata e ritorno (perdita di arrotondamento trascurabile consentita con doppia precisione)

   Length lenRT = Length.FromMeters(Length.FromFeet(Length.FromMeters(len.Meters).Feet).Meters);
   

5. Sovraccarico dell'operatore (ma mancante controllo del tipo dimensionale)

   // Quite messy, buggy, unsafe, and might not be possible without using F# or C++ MPL.
   // It goes on to say that Dimensional Analysis is not an optional feature for UoM -
   // whether you use it directly or not. It is required.
   

C'è un buon articolo su una rivista in senso stretto che è in tedesco: link

L'idea di base è di avere una classe di unità come la lunghezza con una misurazione di base. La classe contiene il fattore di conversione, gli overload dell'operatore, gli overload ToString, il parser delle stringhe e un'implementazione come un indicizzatore. Abbiamo persino implementato anche la vista Architectual ma non è stata rilasciata come libreria.

public class Length : MeasurementBase
    {
        protected static double[] LengthFactors = { 1, 100, 1000, 0.001, 100 / 2.54 };
        protected static string[] LengthSymbols = { "m", "cm", "mm", "km", "in" };
...
      public virtual double this[Units unit]
        {
            get { return BaseValue * LengthFactors[(int)unit]; }
            set { BaseValue = value / LengthFactors[(int)unit]; }
        }
...

        public static ForceDividedByLength operator *(Length length, Pressure pressure1)
        {
            return new ForceDividedByLength(pressure1[Pressure.Units.kNm2] * length[Units.m], ForceDividedByLength.Units.kNm);
        }

...

Quindi vedi l'utilizzo con l'operatore Pressure o semplicemente:

var l = new Length(5, Length.Units.m)    
Area a = l * new Length("5 m");
a.ToString() // -> 25 m^2
double l2 = l[Length.Units.ft];

Ma come hai detto, non ho trovato nemmeno l'unicorno:)

Questa è la ragion d'essere del comando Unix units , che fa tutto usando un approccio basato su file di dati per specificare le relazioni.