Release Notes

| Home | Libraries | People | FAQ | More

## Release Notes

1.2 (March 2010)

- Added autoprefix ready for Boost 1.43

1.0.0 (August 1, 2008) :

- Initial release with Boost 1.36

0.7.1 (March 14, 2007) :

- Boost.Typeof emulation support.
- attempting to rebind a heterogeneous_system to a different set of dimensions now fails.
- cmath.hpp now works with como-win32.
- minor changes to the tests and examples to make msvc 7.1 happy.

0.7.0 (March 13, 2007) :

- heterogeneous and mixed system functionality added.
- added fine-grained implicit unit conversion on a per fundamental dimension basis.
- added a number of utility metafunction classes and predicates.
- `boost/units/operators.hpp` now uses `BOOST_TYPEOF` when possible.
- angular units added in `boost/units/systems/angle/gradians.hpp` and `boost/units/systems/angle/gradians.hpp`. Implicit conversion of radians between trigonometric, SI, and CGS systems is allowed.
- a variety of `unit` and `quantity` tests added.
- examples now provide self-tests.

0.6.2 (February 22, 2007) :

- changed template order in `unit` so dimension precedes unit system
- added `homogeneous_system<S>` for unit systems
- incorporated changes to `boost/units/dimension.hpp` (compile-time sorting by predicate), `boost/units/conversion.hpp` (thread-safe implementation of quantity conversions), and `boost/units/io.hpp` (now works with any `std::basic_ostream`) by SW
- added abstract units in `boost/units/systems/abstract.hpp` to allow abstract dimensional analysis
- new example demonstrating implementation of code based on requirements from Michael Fawcett (radar_beam_height.cpp)

0.6.1 (February 13, 2007) :

- added metafunctions to test if a type is
  - a valid dimension list (`is_dimension_list<D>`)
  - a unit (`is_unit<T>` and `is_unit_of_system<U,System>`)
  - a quantity (`is_quantity<T>` and `is_quantity_of_system<Q,System>`)
- quantity conversion factor is now computed at compile time
- static constants now avoid ODR problems
- unit_example_14.cpp now uses Boost.Timer
- numerous minor fixes suggested by SW

0.6.0 (February 8, 2007) :

- incorporated Steven Watanabe's optimized code for dimension.hpp, leading to dramatic decreases in compilation time (nearly a factor of 10 for unit_example_4.cpp in my tests).

0.5.8 (February 7, 2007) :

- fixed `#include` in `boost/units/systems/si/base.hpp` (thanks to Michael Fawcett and Steven Watanabe)
- removed references to obsolete `base_type` in __unit_info (thanks to Michael Fawcett)
- moved functions in `boost/units/cmath.hpp` into `boost::units` namespace (thanks to Steven Watanabe)
- fixed `#include` guards to be consistently named `BOOST_UNITS_XXX` (thanks to Steven Watanabe)

0.5.7 (February 5, 2007) :

- changed quantity conversion helper to increase flexibility
- minor documentation changes
- submitted for formal review as a Boost library

0.5.6 (January 22, 2007) :

- added IEEE 1541 standard binary prefixes along with SI prefixes to and extended algebra of `scale` and `scaled_value` classes (thanks to Kevin Lynch)
- split SI units into separate header files to minimize the "kitchen sink" include problem (thanks to Janek Kozicki)
- added convenience classes for declaring fundamental dimensions and composite dimensions with integral powers (`fundamental_dimension` and `composite_dimension` respectively)

0.5.5 (January 18, 2007) :

- template parameter order in `quantity` switched and default `value_type` of `double` added (thanks to Andrey Semashev and Paul Bristow)
- added implicit `value_type` conversion where allowed (thanks to Andrey Semashev)
- added `quantity_cast` for three cases (thanks to Andrey Semashev):
  - constructing `quantity` from raw `value_type`
  - casting from one `value_type` to another
  - casting from one `unit` to another (where conversion is allowed)
- added`metre` and `metres` and related constants to the SI system for the convenience of our Commonwealth friends...

0.5.4 (January 12, 2007) :

- completely reimplemented unit conversion to allow for arbitrary unit conversions between systems
- strict quantity construction is default; quantities can be constructed from bare values by using static member `from_value`

0.5.3 (December 12, 2006) :

- added Boost.Serialization support to `unit` and `quantity` classes
- added option to enforce strict construction of quantities (only constructible by multiplication of scalar by unit or quantity by unit) by preprocessor `MCS_STRICT_QUANTITY_CONSTRUCTION` switch

0.5.2 (December 4, 2006) :

- added `<cmath>` wrappers in the `std` namespace for functions that can support quantities

0.5.1 (November 3, 2006) :

- converted to Boost Software License
- boostified directory structure and file paths

0.5 (November 2, 2006) :

- completely reimplemented SI and CGS unit systems and changed syntax for quantities
- significantly streamlined `pow` and `root` so for most applications it is only necessary to define `power_typeof_helper` and `root_typeof_helper` to gain this functionality
- added a selection of physical constants from the CODATA tables
- added a skeleton `complex` class that correctly supports both `complex<quantity<Y,Unit> >` and `quantity<complex<Y>,Unit>` as an example
- investigate using Boost.Typeof for compilers that do not support `typeof`

0.4 (October 13, 2006) :

- `pow<R>` and `root<R>` improved for user-defined types
- added unary + and unary - operators
- added new example of interfacing with `boost::math::quaternion`
- added optional preprocessor switch to enable implicit unit conversions (`BOOST_UNITS_ENABLE_IMPLICIT_UNIT_CONVERSIONS`)

0.3 (September 6, 2006) :

- Support for `op(X x,Y y)` for g++ added. This is automatically active when compiling with gcc and can be optionally enabled by defining the preprocessor constant `BOOST_UNITS_HAS_TYPEOF`

0.2 (September 4, 2006) : Second alpha release based on slightly modified code from 0.1 release

0.1 (December 13, 2003) : written as a Boost demonstration of MPL-based dimensional analysis in 2003.