Newsgroup: it.comp.lang.c++
Titolo: Annuncio libreria open source di incapsulamento misure

Salve,
sto sviluppando in C++ una libreria di template (che sta tutta in un 
file header), per incapsulare grandezze arbitrarie dotate di unita' di 
misura (per esempio: lunghezze in metri, angoli in gradi, vettori del 
piano in chilometri all'ora, punti dello spazio in millimetri).
Il seguente link punta a un documento che contiene una bozza dei requisiti:
http://digilander.libero.it/carlmila/Requisiti.pdf
Ho già sviluppato buona parte delle funzionalità, e ho intenzione di 
pubblicare la libreria su SourceForge.
Se qualcuno la ritiene utile per i propri scopi, gradirei che 
collaborasse a formulare i requisiti secondo le proprie esigenze, ed 
eventualmente revisionasse l'implementazione.
A chi mi scrive in privato mandero' il codice.
-- 
Carlo Milanesi
http://carlomilanesi.wordpress.com/


P.S.: Nell'indirizzo e-mail, il nome "carlo.nospam.milanesi" va 
sostituito con "carlo.milanesi".


 A chi mi scrive in privato mandero' il codice.
Ah, nel PDF non c'è ancora il codice.
A che mail ti posso scrivere ? E' valida quella che appare ?
Ciao (a me interessa)
Se poi per caso decidessi di portare a C#, che ne penseresti 
di "aiutarmi" (non so se sia il caso di dire collaborare) 
col mio programma didattico ?
Vorrebbe essere un tutor bivalente, sia per studenti che 
insegnanti.
Ci metterei sia un modulo editor-authoring, che un modello 
per eseguire i compiti e valutare lo svolgimento. MA, 
ripeto, l'enfasi è tutta sul procedimento e sulla 
correttezza dimensionale, più che non sui meri risultati.
Se vuoi ne parliamo
ciao
Soviet

 piano in chilometri all'ora, punti dello spazio in millimetri).
...
Dirò una banalità perché sicuramente l'avrai già valutata (e inoltre io 
non la conosco se non per "sentito dire", quindi non so se possa fare a 
caso tuo), ma hai dato un'occhiata a boost.units ?


Grazie, hai fatto bene a ricordarmelo.
Avevo guardato a quella libreria tre o quattro anni fa, prima che 
facesse parte di Boost, e adesso grazie al tuo consiglio, me la sono 
scaricata e la ho rivalutata (o meglio ri-svalutata).
Secondo me ha parecchi difetti irrimediabili, per cui ho iniziato a 
scriverne un'altra. La mia ha qualcosa in piu' e qualcosa in meno.
Per esempio, io non ho le grandezze complesse, perche' nel mio lavoro 
non ne ho mai avuto bisogno. Ma ho gli spazi vettoriali e affini a una, 
due e tre dimensioni, e permetto, anzi costringo, a definire le proprie 
grandezze e unita' di misura.
E poi la mia libreria e' molto piu' compatta.
Considera il seguente esempio di Boost::Units (ho tolto la parte 
relativa alle quantita' complesse):
#include <iostream>
#include <boost/units/systems/si/energy.hpp>
#include <boost/units/systems/si/force.hpp>
#include <boost/units/systems/si/length.hpp>
#include <boost/units/systems/si/io.hpp>
using namespace boost::units;
using namespace boost::units::si;
quantity<energy>
work(const quantity<force>& F,const quantity<length>& dx) {
     return F*dx;
}
int main() {
     quantity<force>     F(2.0*newton);
     quantity<length>    dx(2.0*meter);
     quantity<energy>    E(work(F,dx));
     std::cout << "F  = " << F << std::endl
               << "dx = " << dx << std::endl
               << "E  = " << E << std::endl
               << std::endl;
     return 0;
}
Il mio codice equivalente e' il seguente:
#include <measure.hpp>
#include <iostream>
DEFINE_MAGNITUDE(length)
DEFINE_UNIT(meter, length, " m", 1, 0)
DEFINE_MAGNITUDE(time)
DEFINE_UNIT(second, time, " s", 1, 0)
DEFINE_MAGNITUDE(mass)
DEFINE_UNIT(kg, mass, " Kg", 1, 0)
DEFINE_MAGNITUDE(speed)
DEFINE_UNIT(meter_per_second, speed, " m/s", 1, 0)
DEFINE_MAGNITUDE(acceleration)
DEFINE_UNIT(meter_per_second2, acceleration, " m/s2", 1, 0)
DEFINE_MAGNITUDE(force)
DEFINE_UNIT(newton, force, " N", 1, 0)
DEFINE_MAGNITUDE(energy)
DEFINE_UNIT(joule, energy, " J", 1, 0)
DEFINE_DERIVED_UNIT(meter_per_second, second, meter)
DEFINE_DERIVED_UNIT(meter_per_second2, second, meter_per_second)
DEFINE_DERIVED_UNIT(kg, meter_per_second2, newton)
DEFINE_DERIVED_UNIT(newton, meter, joule)
int main() {
     rel_measure<newton> F(2.0);
     rel_measure<meter> dx(2.0);
     rel_measure<joule> E(F * dx);
     std::cout << "F  = " << F << std::endl
               << "dx = " << dx << std::endl
               << "E  = " << E << std::endl
               << std::endl;
     return 0;
}
Compilando entrambi con VC++, come dimensioni dei file ottengo:
boost.cpp 735
boost.obj 1.548.635
boost.exe 203.776
measures.cpp 1.108
measures.obj 113.409
measures.exe 126.976
Inoltre, il tempo di compilazione della versione di Boost e' oltre il 
triplo.
Infine, la versione di Boost ti costringe a installare gran parte di 
Boost (decine di megabyte).


 Boost (decine di megabyte).
Sei la seconda persona che sento parlare male di Boost.
Considerato che due anni fa ne sentivo parlare solo bene, è un 
cambiamento interessante. Se non altro significa che è abbastanza buona 
da farsi usare nonostante le sue magagne.


Hai un'idea di quanti usino Boost? E in particolare di quali moduli e 
per quali applicazioni?
Io penso che il principale fattore che ne scoraggia l'uso sia 
l'interdipendenza dei moduli, cioe' che per padroneggiare un modulo in 
realta' bisogna padroneggiarlo quasi tutto, il che richiede un 
investimento inaccettabile per la maggior parte delle aziende.


 aziende.
non solo... io mi ritengo un programmatore di livello
medio-basso e boost è totalmente al di fuori della mia
portata (OK, mi direte allora che mi sono sopravvalutato
perché la sanno usare cani e porci). Ogni volta che provo
a usarla saltano fuori tante di quelle dipendenze
dall'ambiente che lascio stare e mi riscrivo quel che mi
serve. Anche la documentazione è complicata, almeno per me.
ciao!
Apx.
-- 
Un corpo immerso in un liquido si bagna.
Un corpo immerso nel cemento sapeva troppo.
Un corpo immerso in un altro corpo si diverte.
Un corpo immerso in due corpi è un'orgia.

 Sei la seconda persona che sento parlare male di Boost.
+1
Poi me motivi aziendali sono costretto ad usarla, ma nel complesso la 
considero sempre una terza scelta.