Discussion :

[Alikendarfen]

D'accord, c'est un calcul...

Mais sinon, on pourrait peut être utiliser des lambda + tables de hash type1/type2 > fonction de conversion ? (je n'ai pas beaucoup réfléchit : simple intuition).


Egalement on pourrait envisager un petit moteur de règles : induction du bon chemin pour aboutir la conversion de A > C (en passant par B si nécessaire).
Ce qui pourrait avoir d'autres types d'applications (Rete un peu amélioré par exemple).

Mais effectivement, ça sort du scope de la lib de dev.net telle que définie actuellement.

[hegros]

2) à chaque fois qu'on ajoute une unité, il faudrait modifier toutes les autres pour gérer les divisions par cette nouvelle unité. Or je veux que l'API reste extensible, et que ça puisse fonctionner de la même manière avec des unités créées par l'utilisateur... donc cette option ne convient pas non plus...

Et en utilisant MEF cela pourrait rester extensible non ?

Mais bon, ça n'a pas un intérêt fou il me semble... De toutes façons le but de cette API est avant tout la conversion d'unités, pas les calculs savants

Beh la conversion d'unités cela reste du calculs savants Comment convertir des kms parcourut par un avion en joules ou en électron volt ou en énergie primaire

[Bluedeep]

Beh la conversion d'unités cela reste du calculs savants Comment convertir des kms parcourut par un avion en joules ou en électron volt ou en énergie primaire

Non décidable, car cela suppose de connaitre la masse de l'avion,l'altitude de vol (masse volumique du fluide dans lequel le mobile se déplace), la surface de maitre-couple, le profil alaire (on optimise pour la vitesse ou la maniabilité à basse vitesse ? - si on décide qu'un avion peut s’accommoder d'une piste d'atterrissage de navette spatiale, le bilan énergétique peut être beaucoup plus positif).

Quant à la conversion Joule <=> eV , cela relève plus de l'âne savant et de la classe de 3ème (ou de 2nde peut être, je ne sais plus).

[Nathanael Marchand]

Cela dit, il est possible de faire des calculs juste sur l'homogeneité des unités. Je me souviens qu'au bac ca m'avait bien servi sur ma TI
Si je multiplie du Coulomb par du Pascal en divisant par des Newtons paf! Ca fait des chocapics
C'était ce genre de calcul qu'elle me faisait.

[calagan99]

J'ai mis +1 à Nathanaël, juste pour les Chocapics
Un peu de douceur dans ce post scientiste

[Bluedeep]

Cela dit, il est possible de faire des calculs juste sur l'homogeneité des unités. Je me souviens qu'au bac ca m'avait bien servi sur ma TI
Si je multiplie du Coulomb par du Pascal en divisant par des Newtons paf! Ca fait des chocapics
C'était ce genre de calcul qu'elle me faisait.

Tu vas peut être rentrer dans l’histoire pour avoir énoncé "la version du pauvre du théorème de Vaschy-Buckingham" (qui est une base de l'AD (*)).






(*) mais nooooon pas l'Active Directory ! l'Analyse Dimensionnelle

[tomlev]

(je n'ai pas beaucoup réfléchit : simple intuition).

Moi si

Cela dit, il est possible de faire des calculs juste sur l'homogeneité des unités. Je me souviens qu'au bac ca m'avait bien servi sur ma TI
Si je multiplie du Coulomb par du Pascal en divisant par des Newtons paf! Ca fait des chocapics
C'était ce genre de calcul qu'elle me faisait.

Justement je suis depuis tout à l'heure sur une idée qui permet ce genre de trucs... C'est juste un proto pour l'instant, si ça donne quelque chose ce sera peut-être intégré à Dvp.NET

Petit aperçu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using System;
using SharpMeasure;
using SharpMeasure.Length;
using SharpMeasure.Time;
 
namespace ConsoleTests
{
    // Alias pour les unités composites
    // Pas obligatoire, mais plus pratique...
    using Kmh = FractionalUnit<Kilometer, Hour>;
    using Mph = FractionalUnit<Mile, Hour>;
 
    class Program
    {
        static void Main(string[] args)
        {
            // distance est en mètres (Measure<Meter>)
            var distance = 100.Unit<Meter>();
 
            Console.WriteLine("Distance:");
            Console.WriteLine(distance);
            Console.WriteLine(distance.Convert<Foot>());
            Console.WriteLine();
 
            // distance est en secondes (Measure<Second>)
            var time = 9.58.Unit<Second>();
 
            Console.WriteLine("Time:");
            Console.WriteLine(time);
            Console.WriteLine(time.Convert<Minute>());
            Console.WriteLine();
 
            // speed est en m/s (Measure<FractionalUnit<Meter, Second>>)
            var usainBoltSpeed = distance.DivideBy(time);
            var speedKmh = usainBoltSpeed.Convert<Kmh>();
            var speedMph = speedKmh.Convert<Mph>();
 
            Console.WriteLine("Usain Bolt's speed:");
            Console.WriteLine(usainBoltSpeed);
            Console.WriteLine(speedKmh);
            Console.WriteLine(speedMph);
            Console.ReadLine();
        }
    }
}

Ce qui donne :

Distance:
100 m
328,083989501312 ft

Time:
9,58 s
0,159666666666667 min

Usain Bolt's speed:
10,4384133611691 m/s
37,5782881002088 km/h
23,3500656790647 mi/h

Les unités "composites" (m/s, km/h...) sont "créées" automatiquement, comme en F#

Par contre ça fout par terre tout l'API qui est déjà en place dans Dvp.NET

[hegros]

Non décidable, car cela suppose de connaitre la masse de l'avion,l'altitude de vol (masse volumique du fluide dans lequel le mobile se déplace), la surface de maitre-couple, le profil alaire (on optimise pour la vitesse ou la maniabilité à basse vitesse ? - si on décide qu'un avion peut s’accommoder d'une piste d'atterrissage de navette spatiale, le bilan énergétique peut être beaucoup plus positif).

Quant à la conversion Joule <=> eV , cela relève plus de l'âne savant et de la classe de 3ème (ou de 2nde peut être, je ne sais plus).

Ce n'est pas une unité du SI pourtant elle a une correspondance en joule.je découvre l'analyse dimensionnelle après ce sont des estimations cela ne prédit rien d'une distance ou vitesse sur l'énergie consommée puisque l'on ne connaît pas la force du vent, des résistances etc...il faut que ces unités soient convertibles par groupes de 2,3 ou+

le problème du typage en double est bien encapsulé

[androz]

Je sais pas si ça vous intéresse, mais à la suite des discussions sur la précision des différents types, je vous propose un petit document sur lequel je suis tombé il y a un mois environ, très intéressant :
What Every Computer Scientist Should Know About Floating Point

[Alikendarfen]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
            // speed est en m/s (Measure<FractionalUnit<Meter, Second>>)

Les unités "composites" (m/s, km/h...) sont "crées" automatiquement, comme en F#

C'est très esthétique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

time.Convert<Minute>()

ça par contre, c'est en "dur" ?

On peut ajouter des correspondances ? Traiter d'autre types de conversions (par ex: ° => F) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Convert.Define<Celsius, Fahrenheit>( c => a * c + b );

?

... ce qui supposerait de définir Fahrenheit comme... quel type ?

[Bluedeep]

Ce n'est pas une unité du SI pourtant elle a une correspondance en joule.

C'est évident et c'est pour cela que je disais que la conversion relevait de l'âne savant puisqu'il suffit de faire une division de la valeur en J par 1.6e-19 (à peu près).

[Bluedeep]

... ce qui supposerait de définir Fahrenheit comme... quel type ?

Si tu avais regardé la librairie DVP.Net, tu aurais vu que les types Celsius et Farhenheit y sont. (ainsi que les conversions que tu mentionnes).

[Bluedeep]

des résistances

Les résistances, c'est (en gros) du Bernouilly et elles se calculent en fonction de la vitesse a partir du profil alaire, de la surface de maître couple et de la masse volumique du fluide. C'est pour cela que je ne le mentionnais pas.

[Er3van]

Les résistances, c'est (en gros) du Bernouilly et elles se calculent en fonction de la vitesse a partir du profil alaire, de la surface de maître couple et de la masse volumique du fluide. C'est pour cela que je ne le mentionnais pas.

"C'est pas faux."

+1 juste parce que j'ai rien compris.

[Alikendarfen]

Si tu avais regardé la librairie DVP.Net, tu aurais vu que les types Celsius et Farhenheit y sont. (ainsi que les conversions que tu mentionnes).

La lib actuelle c'est une chose (et j'ai bien vu que les températures y figurent).

Ce dont je parlais, c'est de cette nouvelle version indiquée par Tomlev et du fait qu'elle soit extensible (ou pas).

[tomlev]

ça par contre, c'est en "dur" ?

Comment ça ? Ici Minute est un paramètre de type générique, tu peux utiliser quel autre type d'unité à la place. Ca doit juste implémenter une interface IUnit qui définit comment faire la conversion vers l'unité du SI

On peut ajouter des correspondances ? Traiter d'autre types de conversions (par ex: ° => F) ?

Oui, on peut ajouter de nouvelles unités en créant des nouvelles classes qui implémentent IUnit, ça prend 3 lignes... Par contre avec le prototype actuel la conversion entre °C et °F n'est pas possible, parce que ça ne gère que les conversions de type ax, pas ax + b. Mais ça va s'arranger

... ce qui supposerait de définir Fahrenheit comme... quel type ?

une classe Fahrenheit qui implémente une interface IUnit

Si ça t'intéresse le code est là :
http://code.google.com/p/tomsoft/sou...2FSharpMeasure

[DonQuiche]

Rooh, la discussion a pris un tour bien intéressant.

Permettez-moi d'ajouter une solution qui me semble plus robuste en m'appuyant sur mon passé de physicien.

A la base, nous n'avons besoin que d'une poignée d'unités, une par dimension, c'est à dire sept. Concentrons-nous pour l'instant sur distance, temps et masse, et toutes leurs combinaisons possibles (vitesse = distance/temps, énergie = masse*vitesse^2, etc) et choisissons les unités du S.I.

12 km/h = 12 * (1/3.6) m^1 * s^-1 * kg^0 [3.33 m/s]
Donc pour représenter 12 km/h, il nous faut 5 valeurs : 12 ; 1/3.6 ; +1 ; -1 ; 0


Commençons par la classe de base qui contient l'essentiel de notre code.

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public abstract class DimensionnedValue
{
   protected double m_value;
   private readonly double m_coefficient;
   private readonly int m_massDimension;
   private readonly int m_timeDimension;
   private readonly int m_lengthDimension;
 
   protected Dimensonnedalue() { }
 
   protected DimensionnedValue(double value, double coefficient, int massDimension, int timeDimension, int lengthDimension) { ...  }
 
   public Value { get { return m_value; } }
 
   public bool IsDistance { get { return m_lengthDimension == 1 && m_massDimension == 0 && m_timeDimension == 0; } }
 
   protected double ConvertFrom(DimensionnedValue other)
   {
      // Vérifier que les massDimension, lengthDimension, etc... Sont bien les mêmes pour this et other.
     // Car on peut seulement convertir une vitesse en vitesse, pas une vitesse en distance.
      AssertDimensionsMatchWith(other);
 
      return m_coefficient * other.m_value / other.m_coefficient;
   }
 
   public static DimensionnedValue operator *(DimensionnedValue x, DimensionedValue y)
   {
       return new DimensionnedValue(
           x.m_value * y.m_value,
           x.m_coefficient * y.m_coefficient,
           x.m_massDimension * y.m_massDimension,
           ...);
 
   } 
}

Définir une unité est ensuite très court et très facile.

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public sealed class MetersPerSecond : DimensionnedValue
{
    public MetersPerSecond(double value) 
       : base(value, 1.0, 0, -1, 1)
 
    public static MetersPerSecond operator implicit(DimensionnedUnit x)
    {
        return new MetersPerSecond(ConvertFrom(x));
    }
}

Voilà !
Du coup, on peut implémenter très facilement de nouvelles unités sans avoir explicitement à spécifier des tonnes de conversions, il suffit d'une conversion implicite depuis DimensionnedValue par classe. Et voilà le résultat...

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
KmPerHour speed = new KmPerHour(5);
 
 // On utilise la conversion implicite définie sur MetersPerSecond depuis n'importe quelle unité
MetersPerSecond speed2 = (MetersPerSecond)speed;
 
// Même chose de m/s en km/h
DimensionnedUnit speed3 = new Meters(5) * new Seconds(4);
KmPerHour speed4 = (KmPerHour)speed3;
 
// La conversion suivante renverra une exception (via AssertDimensionsMatchWith que je n'ai expliqué sans fournir le code) puisqu'on ne peut pas convertir une vitesse en distance.
var distance = (Meters)speed4;

Enfin, le système crée implicitement de nouvelles unités à la volée sans avoir besoin de classe ! Par exemple, si Joules (kg*m^2*s^-2) n'a pas été définit, on peut simplement faire :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
var energyInJoules = new Kg(5) * new MetersPerSecond(4) * new MetersPerSecond(4);  // 80J
 
// AJoutons une bête fonction de clonage "NewValue" avec ne changeant que m_value et...
var newEnergyInJoules = energyInJoules.NewValue(12); // 12J

EDIT : Correction de l'introduction qui faisait l'amalgame entre dimension et unité.

[tomlev]

Bien vu, j'avais pas pensé à cette approche là

Par contre c'est bien si tu ne travailles qu'avec des unités du SI... si tu veux faire des conversions en Mile, Ounce, Gallon etc ça marche plus

[DonQuiche]

Mais si on peut travailler avec des miles & co.

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public sealed class Miles : DimensionnedValue
{
    public Miles(double value) 
       : base(value, 1609.344, 0, 0, 1)
 
    public static Miles operator implicit(DimensionnedUnit x)
    {
        return new Miles(ConvertFrom(x));
    }
}

On pourrait ajouter le constructeur suivant à DimensionnedValue afin de rendre les choses plus claires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
protected DimensionnedUnit(double value, DimensionnedValue one)
{
   m_value = value;
   m_cofficient = one.m_value * one.m_coefficient;
   m_massDimension = one.m_massDimension;
   ...
}
 
// En code ça donnerait ceci:
public MilesPerHour(double value) : base (value, new Meters(1609.344) / new Seconds(3600))

Je crois que la seule faille concerne les unités obtenues par translation, comme le Kevin et le Celsius (0°c = 273K ; 100°C = 373K). Mais ça se corrige facilement.

[tomlev]

Ah oui, au temps pour moi...

Reste juste un problème à mon sens : si tu définis par exemple l'opérateur d'addition, comment vérifies-tu que ce sont des valeurs "compatibles" ? Par exemple pour qu'on ne puisse pas additionner des mètres et des secondes ? Certes, tu peux vérifier les dimensions et lever une exception, mais l'erreur ne sera détectée qu'à l'exécution... Alors qu'avec ma solution, les unités sont fortement typées, donc ce genre d'erreur est détectée à la compilation