---

Quantity.C

#include <citrus/config.h>

#include <stdio.h>
#include <math.h>

#include <glib.h>

#include <stdexcept>

#include <citrus/Dimension.H>
#include <citrus/DimensionGroup.H>
#include <citrus/UnitExpr.H>
#include <citrus/Prefix.H>
#include <citrus/Unit.H>

// Shamelessly horked from poly.lex.C
#define yy_create_buffer up_create_buffer
#define yy_delete_buffer up_delete_buffer
#define yy_scan_buffer up_scan_buffer
#define yy_scan_string up_scan_string
#define yy_scan_bytes up_scan_bytes
#define yy_flex_debug up_flex_debug
#define yy_init_buffer up_init_buffer
#define yy_flush_buffer up_flush_buffer
#define yy_load_buffer_state up_load_buffer_state
#define yy_switch_to_buffer up_switch_to_buffer
#define yyin upin
#define yyleng upleng
#define yylex uplex
#define yyout upout
#define yyrestart uprestart
#define yytext uptext
#define yywrap upwrap

#include <citrus/lex.H>
#include "upParser.hh"
#include <citrus/Quantity.H>

extern FILE* upin ;
extern FILE* upout ;
extern int upparse() ;
extern YYSTYPE uplval ;
extern Quantity* theResult ;

/* Debugging flags.
 * Define a flag. Pull my finger.
 *
 * DBG_CONVERT          Print the units and dimensions of the quantities
 *                      to be converted.
 */

void Quantity::eval( UnitExpr*                  e,
                     vector<UnitPower>&         upwr,
                     vector<DimensionPower>&    dpwr,
                     double&                    s )
{
  p_eval( e, 1, upwr, dpwr, s ) ;
  /* Now, strip out any units/dimensions that have a 0 exponent */
  
}

void Quantity::p_eval( UnitExpr*                e,
                       int                      x,
                       vector<UnitPower>&       upwr,
                       vector<DimensionPower>&  dpwr,
                       double&                  s )
{
  UnitUnitInfo*                         ui ;
  UnitOperInfo*                         oi ;
  DimensionGroup*                       dgrp ;
  DimensionPower                        dp ;
  vector<DimensionPower>::iterator      dm ;
  vector<UnitPower>::iterator           un ;

  switch (e->m_i->type()) {
  case UnitInfo::UNIT:
    ui = (UnitUnitInfo*)e->m_i ;
    // Only change if operand has dimension to impart
    if ( ui->m_u ) {
      double dscale = 1.0 ;
      if ( ui->m_p )
        dscale *= pow(10, ui->m_p->exp() ) ;
      dscale *=  ui->m_u->scale() ;
      s *= pow( dscale , x*ui->exp() ) ;
      // Don't ever put the "none" dimension into a product!
      if ( ui->m_u != Unit::dimensionless() ) {
        un = find_unit( ui->m_u, upwr ) ;
        if ( un != upwr.end() ) {
          un->m_pwr += ui->exp()*x ;
          if ( un->m_pwr == 0 )
            upwr.erase( un ) ;
        } else {
          upwr.push_back( UnitPower( ui->m_u, ui->m_p, ui->exp()*x ) ) ;
        }
        dgrp = ui->m_u->dgrp() ;
        vector<DimensionPower>::iterator iter = dgrp->m_dims.begin() ;
        while ( iter != dgrp->m_dims.end() ) {
          dp = *iter ;
          dm=find_dimn(dp.m_dim,dpwr) ;
          if ( dm != dpwr.end() ) {
            dm->m_pwr += dp.m_pwr*ui->exp()*x ;
            if ( dm->m_pwr == 0 )
              dpwr.erase( dm ) ;
          } else {
            dpwr.push_back( DimensionPower(dp.m_dim, dp.m_pwr*ui->exp()*x));
          }
          ++iter ;
        }
      }
    }
    break ;
  case UnitInfo::OPER:
    oi = (UnitOperInfo*)e->m_i ;
    if (e->left())
      p_eval( e->left(), x, upwr, dpwr, s ) ;
    if (e->right())
      p_eval( e->right(), oi->op()=='/' ? -1*x : x, upwr, dpwr, s ) ;
    break ;
  }
  return ;
}

Quantity::Quantity()
{
  m_val = dtNaN ;
  m_dimn.push_back( DimensionPower( find_dsym('1'), 1 ) ) ;
  m_units.push_back( UnitPower( Unit::dimensionless(), 0, 1 ) ) ;
  m_dgrp = Unit::dimensionless()->dgrp() ;
  m_scale = 1.0 ;
}

Quantity::Quantity( const Quantity& qty )
{
  m_val = qty.m_val ;
  m_dimn = qty.m_dimn ;
  m_units = qty.m_units ;
  m_dgrp = qty.m_dgrp ;
  m_scale = qty.m_scale ;
}

Quantity::Quantity( const char* dimNum )
{
  if (theResult)
    delete theResult ;

  //fprintf( stderr, "Parsing :%s:\n", dimNum ) ;
  int   tlen = strlen(dimNum) ;
  char* tmp = new char[tlen+2] ;
  strcpy( tmp, dimNum ) ;
  sprintf(tmp+tlen,"\n") ;
  YY_BUFFER_STATE bstate = up_scan_string( tmp ) ;

  bool parsed = !upparse() ;

  up_delete_buffer( bstate ) ;
  delete [] tmp ;

  if ( parsed && theResult ) {
    m_val = theResult->m_val ;
    m_dimn = theResult->m_dimn ;
    m_units = theResult->m_units ;
    m_dgrp = theResult->m_dgrp ;
    m_scale = theResult->m_scale ;
  } else {
    throw new runtime_error( "Could not parse units" ) ;
  }
}

Quantity::Quantity( double v, UnitExpr* e )
  : m_val(v)
{
  m_scale = 1.0 ;
  p_eval( e, 1, m_units, m_dimn, m_scale ) ;
  if ( m_units.size() == 0 )
    m_units.push_back( UnitPower( Unit::dimensionless(), 0, 1 ) ) ;
  if ( m_dimn.size() == 0 ) 
    m_dimn.push_back( DimensionPower( find_dsym('1'), 1 ) ) ;
  m_dgrp = DimensionGroup::find( m_dimn );
}

Quantity::~Quantity()
{

}

void Quantity::print()
{
  fprintf( stdout, " %f [", m_val ) ;
  UnitPower::print( m_units, stdout ) ;
  fprintf( stdout, "] {" ) ;
  //DimensionPower::print( m_dimn ) ;
  fprintf( stdout, "}\n" ) ;
}

bool Quantity::operator == ( const Quantity& o ) const
{
  if ( m_val != o.m_val )
    return false ;

  if ( m_dgrp && o.m_dgrp && m_dgrp == o.m_dgrp )
    return true ;

  return ( m_dimn == o.m_dimn ) ;
}

int convert( Quantity* to, const Quantity* from )
{
#ifdef DBG_CONVERT
  fprintf( stderr, "Convert [") ;
  UnitPower::print( from->m_units, stderr ) ;
  fprintf( stderr, "] {" ) ;
  DimensionPower::print( from->m_dimn, stderr ) ;
  fprintf( stderr, "} to [" ) ;
  UnitPower::print( to->m_units, stderr ) ;
  fprintf( stderr, "] {" ) ;
  DimensionPower::print( to->m_dimn, stderr ) ;
  fprintf( stderr, "}\n" ) ;
#endif // DBG_CONVERT

  if ( (from && to ) &&
       areDimensionsMatched(from->dimension(), to->dimension()) ) {

    if ( from->m_units.size() == 1 && 
         to->m_units.size() == 1 && 
         (from->m_units[0].m_unit->offsetPolicy() ||
          to->m_units[0].m_unit->offsetPolicy()) ) {

      // offsets only make sense if we haven't multiplied units.
      double o_from = from->m_units[0].m_unit->offsetValue()  ;
      double o_to = to->m_units[0].m_unit->offsetValue() ;
      to->m_val = ( from->val() + o_from ) * from->scale()/to->scale() - o_to ;
    } else {
      to->m_val = from->val() * from->scale()/to->scale() ;
    }
    return 0 ;
  } 
  to->m_val = dtNaN ;
  return 1 ;
}

xmlNodePtr Quantity::mathML() const
{
  CHAR* content ;
  xmlNodePtr top = xmlNewNode( NULL, (const CHAR*)"mrow" ) ;

  content = (CHAR*) g_strdup_printf( "%g", m_val ) ;
  xmlNewChild( xmlNewChild( top, NULL, (const CHAR*)"mrow", NULL ),
               NULL, (const CHAR*)"mi", content ) ;
  g_free( content ) ;

  xmlNewChild( top, NULL,
               (const CHAR*)"mo", (const CHAR*)"&NonBreakingSpace;" ) ;
  xmlAddChild( top, UnitPower::mathML( m_units ) ) ;

  return top ;
}

C++ Reference Manual

20010520