Boost logo

Boost :

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++:
> 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.


Boost list run by bdawes at, gregod at, cpdaniel at, john at