unit_converter.cpp

Go to the documentation of this file.

//======================================================================
//======================================================================

//----------------------------------------------------------------------
// System Includes - include with <>
//----------------------------------------------------------------------

#include <assert.h>
#include <iostream>

using namespace std;

//----------------------------------------------------------------------
// Project Includes - include with ""
//----------------------------------------------------------------------


#include "unit_converter.h"

USING_NAMESPACE_SDH

//----------------------------------------------------------------------
// Defines, enums, unions, structs,
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Global variables
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Function definitions
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Class definitions
//----------------------------------------------------------------------


cUnitConverter::cUnitConverter( char const* _kind, char const* _name, char const* _symbol, double _factor, double _offset, int _decimal_places )
{
    assert(_factor != 0.0); // must not be 0 since we devide by it

    kind   = _kind;
    name   = _name;
    symbol = _symbol;
    factor = _factor;
    offset = _offset;
    decimal_places = _decimal_places;
}
//----------------------------------------------------------------------


double cUnitConverter::ToExternal( double internal ) const
{
    return internal * factor + offset;
}
//----------------------------------------------------------------------


cSimpleVector cUnitConverter::ToExternal( cSimpleVector& internal ) const
{
    cSimpleVector rv;

    for ( int i = 0; i < internal.eNUMBER_OF_ELEMENTS; i++ )
    {
        if ( internal.Valid( i ) )
        rv[i] =  internal[i] * factor + offset;
    }
    return rv;
}
//----------------------------------------------------------------------


std::vector<double> cUnitConverter::ToExternal( std::vector<double> const& internal ) const
{
    std::vector<double> rv;

    for ( std::vector<double>::const_iterator vi = internal.begin();
          vi != internal.end();
          vi++ )
    {
        rv.push_back(  *vi * factor + offset );
    }
    return rv;
}
//----------------------------------------------------------------------


double cUnitConverter::ToInternal( double external ) const
{
    return (external - offset) / factor;
}
//----------------------------------------------------------------------


cSimpleVector cUnitConverter::ToInternal( cSimpleVector& external ) const
{
    cSimpleVector rv;

    for ( int i = 0; i < external.eNUMBER_OF_ELEMENTS; i++ )
    {
        if ( external.Valid( i ) )
        rv[i] =  (external[i] - offset) / factor;
    }
    return rv;
}
//----------------------------------------------------------------------


std::vector<double> cUnitConverter::ToInternal( std::vector<double> const& external ) const
{
    std::vector<double> rv;

    for ( std::vector<double>::const_iterator vi = external.begin();
          vi != external.end();
          vi++ )
    {
        rv.push_back( ( *vi - offset) / factor );
    }
    return rv;
}
//----------------------------------------------------------------------


char const* cUnitConverter::GetKind( void ) const
{
    return kind;
}
//----------------------------------------------------------------------


char const* cUnitConverter::GetName( void ) const
{
    return name;
}
//----------------------------------------------------------------------


char const* cUnitConverter::GetSymbol( void ) const
{
    return symbol;
}
//----------------------------------------------------------------------


double cUnitConverter::GetFactor( void ) const
{
    return factor;
}
//----------------------------------------------------------------------



double cUnitConverter::GetOffset( void ) const
{
    return offset;
}
//----------------------------------------------------------------------



int cUnitConverter::GetDecimalPlaces( void ) const
{
    return decimal_places;
}
//======================================================================

NAMESPACE_SDH_START

cUnitConverter const uc_identity( "any", "any", "?", 1.0, 0.0, 4 );

NAMESPACE_SDH_END


//======================================================================
/*
  Here are some settings for the emacs/xemacs editor (and can be safely ignored):
  (e.g. to explicitely set C++ mode for *.h header files)

  Local Variables:
  mode:C++
  mode:ELSE
  End:
*/
//======================================================================