C:/nobackup/private/physical_svn/trunk/test/manual_test.cpp

Go to the documentation of this file.

/*=============================================================================
    physical quantities / units / constants
    Copyright (c) 2006, 2007 Martin Schulz
    http://physical.sourceforge.net
  
    This is private code by Martin Schulz.
  
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#include <boost/test/auto_unit_test.hpp>

// this is the old "main" program. Use as building blocks for other test cases...


/* ************************************************************************************** */

#include "physical/exception.hpp"
#include "physical/fixedphysical.hpp"
#include "physical/dynamicunit.hpp"
#include "physical/quantity.hpp"
#include "physical/unit.hpp"
#include "physical/unitsymbol.hpp"
#include "physical/format.hpp"
#include "physical/parser.hpp"
#include "physical/dimension.hpp"
#include "physical/autoformat.hpp"

#include <iostream>
#include "physical/autoformat.hpp"


void try_to_parse(std::string formula) {
   physical::parser::Parser p;

   try {
      physical::DynamicPhysical<SI> q = p.parse(formula);
      std::cout << "parsing of " << formula << " succeeded: " << q <<"\n";

   } catch(const physical::parser::parser_exception& e) {
      std::cout << "parsing of " << formula << " failed after " << e.string_to_parse.substr(0, e.sucessfully_parsed_up_to) << "\n";
   };

};


BOOST_AUTO_UNIT_TEST( manual_test ) {

   namespace quantity=physical::quantity_si_double;
        namespace unit=physical::unit_si_float;
        using physical::DynamicPhysical;
        using physical::DynamicUnit;
        using physical::format::format;
        using physical::format::FormatSpec;

        std::cout << "Hello World!\n";

        std::cout << "numerical value of meter: " << unit::meter.numerical_value << "\n";
        std::cout << "numerical value of kilometer: " << unit::kilometer.numerical_value << "\n";

        std::cout << "numerical value of hour: " << unit::hour.numerical_value << "\n";

        DynamicUnit<SI> d_hour(unit::hour);
        DynamicPhysical<SI> day= 24*unit::hour;

        std::cout << "numerical value of day: " << day.numerical_value << "\n";

        double spd = (day / DynamicPhysical<SI>(unit::second) ).numerical_value; // FIXME automatic conversion should work again!!!
        std::cout << "number of seconds per day: " << spd << "\n";

        std::cout << "day = " << day << "\n";

        quantity::mass  m = unit::gram;

        // FormatSpecs can be stored and handles e.g. by standard containers:
        std::vector<FormatSpec<SI>> hourspecs;
        hourspecs.push_back(FormatSpec<SI>("h",unit::hour,2)); 
        hourspecs.push_back(FormatSpec<SI>("hour(s)",unit::hour,2));
        hourspecs.push_back(FormatSpec<SI>("Stunde(n)",unit::hour,2));
        hourspecs.push_back(FormatSpec<SI>("heure(s)",unit::hour,2));


        std::cout << "day = " << format(day, hourspecs[0]) << "\n";
        std::cout << "day = " << format(day, hourspecs[1]) << "\n";
        std::cout << "day = " << format(day, hourspecs[2]) << "\n";
        std::cout << "day = " << format(day, hourspecs[3]) << "\n";

        // pre-created formatter object
        physical::format::formatter<SI> f(hourspecs[3]);
        std::cout << "day = " << f(day) << "\n";


        physical::format::Dimension("units of time usually used by machines", unit::second);
        physical::format::Dimension human_clock 
                = physical::format::DimensionDef<quantity::time>("units of time usually used by humans")
                .add(FormatSpec<SI>("hours", unit::hour, 2))
                .add(FormatSpec<SI>("minutes", 60*unit::second, 0))
                .add(FormatSpec<SI>("seconds", unit::second, 0));

        
        std::cout << "day/dimension = " << format(day, human_clock.get(0)) << "\n";
        std::cout << "day/dimension = " << format(human_clock.get(0))(day) << "\n";

        quantity::velocity velocity = 50*unit::kilometer/unit::hour;
        DynamicPhysical<SI> dvelocity = 50*unit::kilometer/unit::hour;

        std::cout << "50kmh = " << DynamicPhysical<SI>(velocity) << "\n"; // FIXME automatic conversion should work again!!!
        std::cout << "50kmh = " << dvelocity << "\n";

        quantity::length side = 20*unit::meter;
        quantity::area square = side*side;
        std::cout << "area = " << DynamicPhysical<SI>(square) << "\n"; // FIXME automatic conversion should work again!!!
        
        FormatSpec<SI> areaspec("m*m", unit::meter*unit::meter, 3);
        std::cout << "area = " << format(DynamicPhysical<SI>(square), areaspec) << "\n";// FIXME automatic conversion should work again!!!


        quantity::temperature temp= 18*unit::celsius; // implicit conversion DynamicPhysical->FixedPhysical
        DynamicPhysical<SI> temp2= 20*unit::celsius;

        try {
                // this is an invalid conversion and should throw an exception:
                DynamicPhysical<SI> length = 200*unit::meter;
                quantity::temperature temp = length;
        } catch(const std::exception& e) {
                std::cout << "Could not convert length to temperature: " << e.what() << "\n";
        }

        std::cout << "celsius.factor " << unit::celsius.scale.factor << "\n";
        std::cout << "celsius.origin " << unit::celsius.scale.origin << "\n";

        std::cout << "temp.numerical_value " << temp.numerical_value << "\n";

        std::cout << "temp.numerical_value " << temp.numerical_value << "\n";

        std::cout << "room temperature = " << format<SI>(temp, FormatSpec<SI>("K", unit::kelvin, 4)) << "\n";
        std::cout << "room temperature = " << format<SI>(temp, FormatSpec<SI>("°C", unit::celsius, 4)) << "\n";

        quantity::temperature freezing_point = 0*unit::celsius;

        std::cout << "freezing_point = " << format<SI>(freezing_point, FormatSpec<SI>("K", unit::kelvin, 4)) << "\n";
        std::cout << "freezing_point = " << format<SI>(freezing_point, FormatSpec<SI>("°C", unit::celsius, 4)) << "\n";
        std::cout << "freezing_point = " << format<SI>(freezing_point, FormatSpec<SI>("°F", unit::fahrenheit, 4)) << "\n";
        std::cout << "freezing_point = " << format<SI>(freezing_point, FormatSpec<SI>("°R", unit::reaumur, 4)) << "\n";

        quantity::temperature boiling_point = 100*unit::celsius;

        std::cout << "boiling_point = " << format<SI>(boiling_point, FormatSpec<SI>("K", unit::kelvin, 4)) << "\n";
        std::cout << "boiling_point = " << format<SI>(boiling_point, FormatSpec<SI>("°C", unit::celsius, 4)) << "\n";
        std::cout << "boiling_point = " << format<SI>(boiling_point, FormatSpec<SI>("°F", unit::fahrenheit, 4)) << "\n";
        std::cout << "boiling_point = " << format<SI>(boiling_point, FormatSpec<SI>("°R", unit::reaumur, 4)) << "\n";

        // try the parser:
        try_to_parse("0.5");
        try_to_parse("1.5[]");
        try_to_parse("2.5[1]");
        try_to_parse("3.5[123]");
        try_to_parse("4.5[m]");
        try_to_parse("5.5[kg]");
        try_to_parse("6.5[kg^5]");
        try_to_parse("7.5[m*A*s^-1*kg^5]");
        try_to_parse("8.5[m]");
        try_to_parse("9.5[m*A]");
        try_to_parse("10.5[m*A*s^-1]");
        try_to_parse("11.5[m*A*s^-1*kg^5]");
        try_to_parse("12.5[m*s*grad]");
        try_to_parse("13.5[m*s*Grad]");
        try_to_parse("14.5[rad]");
        try_to_parse("15.5[m/s]");

};

---

hosted on