[boost] Re: runtime unit-modifiablephysical-quantitiesusingpqs1-00-01

From: Dan W. (danw_at_[hidden])
Date: 2004-01-06 06:34:48

Andy Little wrote:
> ( BTW re your prev example... You Cant use floats as template params... not
> allowed in C++:
...snip...
> So as you say I can never represent real powers here... ie its short
> sighted.

Got it.  So Hell with it!: The day someone needs the pi'th power of 
brightness, she can use candelas^(22/7);  big deal.

> however if I  named  some ints
>  static int const one = 1;
>   static int const minus_two = -2;
> I could still represent Force using the names at source code level:
> abstract_pq< one,one,minus_two> Force;

Nah!  Forget Force, just make an abstraction, then you can provide a 
basic SI units sets one can install like a 'sans serif' font.
You could even dictate the use of double as value type, in such a 
supplement (though I'd find that frustrating); --just as long as you 
don't dictate a value type at library level.

> But  because they are names they are more versatile:
> A simple metaprogramming class
> template< int x>
> struct Rep{
>     const static int value = x;    // notably 'static' Therefore I do not
> need a class object to get at this  name
> };

How about,

  template< int SingleDimTag, std::string DimName >
  struct SingleDimID;
  //where SingleDimTag is a compile time gen. incrementing
  //int to provide dim identification/selection

  template< int SingleUnitTag, std::string UnitName >
  struct SingleDimUnitID;
  //where UnitTag is a compile time gen. incrementing
  //int to provide unit identification/selection

  template< SingleDimID SDID, SingleDimUnitID SDUID >
  struct SingleDimUnit;

  template< SingleDimUnit DU, typename Rep, const Rep val >
  struct SingleDimUnitRep;
  //where Rep specifies the value type, and val the
  //numeric representation for the specific unit.

  template< int N, unsigned int D >
  struct fractional_power;

  template< DimUnitRep, fractional_power >
  struct SingleDimUnitRepPower;

  template< typelist< SingleDimUnitRepPower SDURP > >
  struct NDimAsSingleUnits;
  //note that this is template class that references single
  //dimensional units that compose it, but does not have its
  //own proper unit tag.

  template< int NDimTag, std::string DimName >
  struct NDimID;
  //just to have a proper name for a multi-dim

  template< int NDimUnitTag, std::string UnitName >
  struct NDimUnitID;
  //just to have a proper name for composite or
  //multi-dim unit.

  template< NDimID NDID, NDimUnitID NDUID >
  struct NDimUnit;

  template< NDimAsSingleUnits NDASU, NDimUnit NDU >
  struct NDimProperUnit;
  //to associate a multi-dim unit to a proper unit

  Okay, that's it for me, I need a whole pot of coffee now.

> Using Rep I can redo my names as types:
> typedef  one Rep<1>;
> typedef  two Rep<2>;
> typedef  minus_one Rep<-2>;
> the value is available but with a bit more work:
> int x = one::value;  //  ie x =1;
> Changing the declaration/def of  abstract_pq
> template< typename  L, typename T, typename M>
> class abstract_pq{
> private:        // nobodys business what goes on in here
>         static int const  from_p1  = L::value;   // extract the value from
> the type... any Type with a  suitable 'value' will work
>     ...
> };
> and now :
> abstract_pq< 1,1,-2> Force1;                // ERROR invalid template
> arguments
> abstract_pq< one,one,minus_two> Force;  // ok still works fine using the new
> definitions
> ie names are much more versatile... the Rep types could be replaced by
> Rationals etc
> But some downsides are: it puts a lot of people off (why say 'one', not 1 )
> ...its another layer of complexity... its harder to debug.
> Nevertheless I shall probably have to go that way.

Hope NOT...

>>And the value type has to absolutely be a template type. Someone will
>>want a 7-bit type to make prinatble ascii characters a dimension... you
>>never know.
> 
> Oops ....... The value_type is and has always been part of it:

That was a mistake, man;  snap out of it  :)

>>Template type for now. Don't even bother with such details.
> 
> (I Accept that abstract_pq template params may need to be types as above.)
> However I need something that works for me Now, Now, Now
> My major Major criticism of all the other units libs is "Heres My Great
> Lib..."
> then  there are a couple of  headers of  template code
> followed by   'Oh ...BTW... you have to define your own units... dont worry
> it'll be no problem' .

Yeah, I agree that to only provide the bare bones thing is harsh, I 
wouldn't mind having SI units or other useful sytems coming with a 
library to help me get rolling, but the abstraction underneath is what's 
most important to make available, NOT the concrete types.

> Even with integer only powers the thing is useful. I dont need fractional
> powers much... when I do I'll follow my advice... But will watch to see what
> others come up with.
> BTW  >>Current noise:  nA/(Hz^(0.5))  //"nano-Amps per root-Hertz"
>>>Voltage noise:
> Is very useful.
> Can use this for a 'how to work around limitations of my type' example ...

You DO need fractional powers, IMHO;  how else could you have 
representations for temporaries in long formulas where arbitrary roots 
of expressions may be taken?

> Yep ... Dont have a clue what this SIUnits syntax is about:
> Length L =  5 * meters ;

I find that hateful too, * also used for pointer de-referencing,... It's 
painful to the eye;  but it's convenient for implementation, I suppose, 
as meters my have a numeric representation, e.g. 2^16.  I'd even 
consider overloading, say, the comma operator:

template < typename T const, std::string const UnitName >
unit operator,( const T number, UnitName name );

then have a macro

#define meters ,meter

so as to be able to write

meter<int> braking_distance = 77 meters;

But there may be precedence collisions to consider, and a macro is a 
macro... "meters<int>(77)" would probably be the best compromise.

>>and like I
>>said, what I *needed* it for, in my present project, was to count bytes
>>with a short, and things like that;  which I would rather use a typed
>>type, but one that doesn't impose on me that I use double, etc.
> Hmm... sounds like you will have to wait for someones "all singing "
> version... maybe Mathiass Schabel is your man.
> my lib is called *physical*_quantities... it does what its says on the tin.

False Advertising was never a criticism lobbed at your lib.  Just that 
if you insist on it being just physical, few will have much use for it.

dan