Exemple #1
0
 C& operator = (const C& other) {
     std::cout << "operator = for " << long(this) << " with argument " << long(&other) << "\n";
     return *this;
 }
long
SocketConnection::DirectRead(unsigned char *buf, long ntotal)
{
    char *b = (char*)buf;
    long nread = 0;

    while (nread < ntotal)
    {
        int n = recv(descriptor, b, ntotal-nread, 0);

        if (n < 0)
        {
#if defined(_WIN32)
            //
            // If the last socket error was any of the errors that are
            // typically set by recv then return. For some large messages
            // that VisIt reads, recv returns -1 indicating some kind of
            // failure but the error code does match anything fatal so
            // don't bother returning. In the situations I've observed,
            // it's been okay to continue calling recv until it succeeds.
            //
            int err = WSAGetLastError();
            if(err == WSANOTINITIALISED ||
               err == WSAENETDOWN ||
               err == WSAEFAULT ||
               err == WSAENOTCONN ||
               err == WSAEINTR ||
               err == WSAEINPROGRESS ||
               err == WSAENETRESET ||
               err == WSAENOTSOCK ||
               err == WSAEOPNOTSUPP ||
               err == WSAESHUTDOWN ||
               err == WSAEWOULDBLOCK ||
               err == WSAEMSGSIZE ||
               err == WSAEINVAL ||
               err == WSAECONNABORTED ||
               err == WSAETIMEDOUT ||
               err == WSAECONNRESET ||
               err == WSAEDISCON)
            {
                return long(n);
            }
#else
            return long(n);
#endif
        }
        else if(n == 0)
        {
            ++zeroesRead;

            if(zeroesRead > 100)
            {
                EXCEPTION0(LostConnectionException);
            }
        }
        else
        {
            nread += n;
            b += n;

            // Reset the flag.
            zeroesRead = 0;
        }
    }

    return ntotal;
}
Exemple #3
0
 C(const C& other) {
     std::cout << "Copy constructor for " << long(this) << " with argument " << long(&other) << "\n";
 }
Exemple #4
0
 ~C() {
     std::cout << "Destructor for " << long(this) << "\n";
 }
Exemple #5
0
 C() {
     std::cout << "Default constructor for " << long(this) << "\n";
 }
Exemple #6
0
// Execute an internal function with the supplied array of values.
ClParserValuePtr
ClParserProcessInternFn(ClParserInternFnPtr internfn, const ClParserValueArray &values,
                        int *error_code)
{
  ClParserStackAutoDebugPrint auto_print;

  CL_PARSER_TRACE("ClParserProcessInternFn")

  *error_code = 0;

  uint num_values = values.size();

  ClParserValuePtr value = ClParserValueMgrInst->createValue(values[0]);

  try {
    switch (internfn->getType()) {
      case CLParserInternFnType::VALTYP:
        if (value->isType(CL_PARSER_VALUE_TYPE_ARRAY)) {
          ClParserArrayPtr array = value->getArray();

          value = ClParserValueMgrInst->createValue(
                    (long) (array->getType() | CL_PARSER_VALUE_TYPE_ARRAY));
        }
        else
          value = ClParserValueMgrInst->createValue((long) value->getType());

        break;

      case CLParserInternFnType::ADDR: {
        ClParserValuePtr value1 = ClParserProcessAddrCommand(values, error_code);

        if (*error_code == 0)
          value = value1;

        break;
      }

      //------

      case CLParserInternFnType::IS_CTYPE: {
        if (values[1]->getType() != CL_PARSER_VALUE_TYPE_STRING) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
          return ClParserValuePtr();
        }

        std::string is_type = values[1]->getString()->getText();

        CStrUtil::IsCType is_func = CStrUtil::getIsCType(is_type);

        if (! is_func) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
          return ClParserValuePtr();
        }

        long result;

        if (values[0]->isType(CL_PARSER_VALUE_TYPE_STRING)) {
          std::string text = values[0]->toString()->getString()->getText();

          uint len = text.size();

          uint match = 0;

          for (uint i = 0; i < len; ++i)
            if ((*is_func)(int(text[i])))
              ++match;

          result = (match > 0 && match == len);
        }
        else {
          long integer1 = values[0]->toInt()->getInteger()->getValue();

          result = long((*is_func)(int(integer1)));
        }

        value = ClParserValueMgrInst->createValue(result);

        break;
      }

      //------

      case CLParserInternFnType::WHERE: {
       if (values[0]->getType() != CL_PARSER_VALUE_TYPE_STRING ||
           values[1]->getType() != CL_PARSER_VALUE_TYPE_STRING) {
         ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
          return ClParserValuePtr();
        }

        ClParserStringPtr str1 = values[0]->getString();
        ClParserStringPtr str2 = values[1]->getString();

        value = ClParserProcessWhere((char *) str1->getText().c_str(),
                                     (char *) str2->getText().c_str(),
                                     error_code);

        if (*error_code != 0)
          return ClParserValuePtr();

        break;
      }

      //------

      case CLParserInternFnType::ASSERT:
        value->doAssert();
        break;

      //------

      case CLParserInternFnType::CEIL:
        value = value->ceil();
        break;
      case CLParserInternFnType::FLOOR:
        value = value->floor();
        break;
      case CLParserInternFnType::SIGN:
        value = value->sign();
        break;

      case CLParserInternFnType::SQR:
        value = value->sqr();
        break;
      case CLParserInternFnType::SQRT:
        value = value->sqrt();
        break;

      case CLParserInternFnType::COS:
        value = value->cos();
        break;
      case CLParserInternFnType::SIN:
        value = value->sin();
        break;
      case CLParserInternFnType::TAN:
        value = value->tan();
        break;

      case CLParserInternFnType::ACOS:
        value = value->acos();
        break;
      case CLParserInternFnType::ASIN:
        value = value->asin();
        break;
      case CLParserInternFnType::ATAN:
        value = value->atan();
        break;
      case CLParserInternFnType::ATAN2: {
        double y = values[1]->toReal()->getReal()->getValue();

        value = value->atan(y);

        break;
      }
      case CLParserInternFnType::EXP:
        value = value->exp();
        break;
      case CLParserInternFnType::LOG:
        value = value->log();
        break;
      case CLParserInternFnType::LOG10:
        value = value->log10();
        break;

      case CLParserInternFnType::COSH:
        value = value->cosh();
        break;
      case CLParserInternFnType::SINH:
        value = value->sinh();
        break;
      case CLParserInternFnType::TANH:
        value = value->tanh();
        break;

      case CLParserInternFnType::NORM:
        value = value->norm();
        break;
      case CLParserInternFnType::INVNORM:
        value = value->invnorm();
        break;

      case CLParserInternFnType::CHAR_CONV:
        value = value->toChar();
        break;
      case CLParserInternFnType::INT_CONV:
        value = value->toInt();
        break;
      case CLParserInternFnType::REAL_CONV:
        value = value->toReal();
        break;
      case CLParserInternFnType::STRING_CONV:
        value = value->toString();
        break;

      case CLParserInternFnType::IS_NAN:
        value = value->isNan();
        break;

      case CLParserInternFnType::TOLOWER:
        value = value->toLower();
        break;
      case CLParserInternFnType::TOUPPER:
        value = value->toUpper();
        break;

      case CLParserInternFnType::DIM:
        value = value->dim();
        break;
      case CLParserInternFnType::NDIM:
        value = value->ndim();
        break;
      case CLParserInternFnType::LEN:
        value = value->len();
        break;

      case CLParserInternFnType::MIN:
        value = value->min();
        break;
      case CLParserInternFnType::MAX:
        value = value->max();
        break;
      case CLParserInternFnType::SUM:
        value = value->sum();
        break;

      case CLParserInternFnType::ABS:
        value = value->abs();
        break;

      case CLParserInternFnType::INDEX:
        value = value->index(values[1]);
        break;
      case CLParserInternFnType::RINDEX:
        value = value->rindex(values[1]);
        break;

      case CLParserInternFnType::SORT: {
        if (num_values > 2) {
          ClParserInst->signalError(error_code, ClErr::TOO_MANY_ARGUMENTS);
          return ClParserValuePtr();
        }

        ClParserSortDirection direction = ClParserSortDirection::ASCENDING;

        if (num_values > 1) {
          if (values[1]->getType() != CL_PARSER_VALUE_TYPE_STRING) {
            ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
            return ClParserValuePtr();
          }

          std::string text = values[1]->getString()->getText();

          if      (CStrUtil::casecmp(text, "ascending" ) == 0)
            direction = ClParserSortDirection::ASCENDING;
          else if (CStrUtil::casecmp(text, "descending") == 0)
            direction = ClParserSortDirection::DESCENDING;
        }

        value = value->sort(direction);

        break;
      }

      //------

      case CLParserInternFnType::ARRAY_I: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, 0L);

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }
      case CLParserInternFnType::ARRAY_R: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, 0.0);

        value = ClParserValueMgrInst->createValue(array);

        break;
      }
      case CLParserInternFnType::ARRAY_S: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, "");

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }

      case CLParserInternFnType::ARRCAT: {
        if (values[0]->getType() != CL_PARSER_VALUE_TYPE_ARRAY ||
            values[1]->getType() != CL_PARSER_VALUE_TYPE_ARRAY) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
          break;
        }

        if (values[1]->getType() != CL_PARSER_VALUE_TYPE_ARRAY ||
            values[1]->getArray()->getType() != values[0]->getArray()->getType()) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
          break;
        }

        ClParserArrayPtr array = value->getArray()->concat(*values[1]->getArray());

        if (! array.isValid()) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
          break;
        }

        value = ClParserValueMgrInst->createValue(array);

        break;
      }

      case CLParserInternFnType::INDARR_I: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, 0L);

        array->setIndexArray();

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }
      case CLParserInternFnType::INDARR_R: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, 0.0);

        array->setIndexArray();

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }
      case CLParserInternFnType::INDARR_S: {
        UIntVectorT dims;

        for (uint i = 0; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 0 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(dims, "");

        array->setIndexArray();

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }

      case CLParserInternFnType::SUBARR:
        ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
        break;

      case CLParserInternFnType::TYPARR: {
        if (values[1]->getType() != CL_PARSER_VALUE_TYPE_STRING) {
          ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
          break;
        }

        ClParserStringPtr str1 = values[1]->getString();

        ClParserTypePtr struct_type = ClParserInst->getType((char *) str1->getText().c_str());

        if (! struct_type.isValid()) {
          ClParserInst->signalError(error_code, ClErr::UNDEFINED_STRUCT_TYPE);
          break;
        }

        UIntVectorT dims;

        for (uint i = 1; i < num_values; i++) {
          ClParserValuePtr value1 = ClParserValueMgrInst->createValue(values[i]);

          if (! value1->convertToInteger()) {
            ClParserInst->signalError(error_code, ClErr::INVALID_CONVERSION);
            return ClParserValuePtr();
          }

          int dim = value1->getInteger()->getValue();

          if (dim <= 0 && ! (i == 1 && dim == 0 && num_values == 1)) {
            ClParserInst->signalError(error_code, ClErr::INVALID_DIMENSION);
            return ClParserValuePtr();
          }

          dims.push_back(dim);
        }

        ClParserArrayPtr array = ClParserArray::createArray(struct_type, dims);

        value = ClParserValueMgrInst->createValue(*array);

        break;
      }

      default:
        assert(false);
        break;
    }
  }
  catch (...) {
    ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
    return ClParserValuePtr();
  }

  return value;
}
Exemple #7
0
ClParserValuePtr
ClParserProcessBinaryOperator(ClParserValuePtr rvalue1, ClParserOperatorPtr op,
                              ClParserValuePtr rvalue2, int *error_code)
{
  ClParserValuePtr value1 = rvalue1;
  ClParserValuePtr value2 = rvalue2;

  ClParserStackAutoDebugPrint auto_print;

  CL_PARSER_TRACE("ClParserProcessBinaryOperator")

  *error_code = 0;

  /*-----------------*/

  if (! value1.isValid() || ! op.isValid() || ! value2.isValid()) {
    ClParserInst->signalError(error_code, ClErr::INVALID_BINARY_EXPRESSION);
    return ClParserValuePtr();
  }

  /*-----------------*/

  if (op->isType(CL_PARSER_OP_LOGICAL_AND) ||
      op->isType(CL_PARSER_OP_LOGICAL_OR)) {
    bool boolean1 = value1->toBool();
    bool boolean2 = value2->toBool();

    if (op->isType(CL_PARSER_OP_LOGICAL_AND))
      return ClParserValueMgrInst->createValue((long) (boolean1 && boolean2));
    else
      return ClParserValueMgrInst->createValue((long) (boolean1 || boolean2));
  }

  /*-----------------*/

  if (op->getType() >= CL_PARSER_OP_LESS &&
      op->getType() <= CL_PARSER_OP_NOT_EQUAL) {
    if (! ClParserValue::checkBinaryTypes(value1, value2)) {
      ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
      return ClParserValuePtr();
    }

    int cmp = value1->cmp(value2);

    switch (op->getType()) {
      case CL_PARSER_OP_LESS:
        return ClParserValueMgrInst->createValue(long(cmp <  0));
      case CL_PARSER_OP_LESS_OR_EQUAL:
        return ClParserValueMgrInst->createValue(long(cmp <= 0));
      case CL_PARSER_OP_GREATER:
        return ClParserValueMgrInst->createValue(long(cmp >  0));
      case CL_PARSER_OP_GREATER_OR_EQUAL:
        return ClParserValueMgrInst->createValue(long(cmp >= 0));
      case CL_PARSER_OP_EQUAL:
        return ClParserValueMgrInst->createValue(long(cmp == 0));
      case CL_PARSER_OP_NOT_EQUAL:
        return ClParserValueMgrInst->createValue(long(cmp != 0));
      default:
        assert(false);
        return ClParserValuePtr();
    }
  }

  /*-----------------*/

  if (op->isType(CL_PARSER_OP_ARRAY_TIMES)) {
    if (! value1->isType(CL_PARSER_VALUE_TYPE_ARRAY) ||
        ! value2->isType(CL_PARSER_VALUE_TYPE_ARRAY)) {
      ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
      return ClParserValuePtr();
    }

    ClParserArrayPtr array1 = value1->getArray();
    ClParserArrayPtr array2 = value2->getArray();

    ClParserArrayPtr array = array1->arrayTimes(*array2);

    return ClParserValueMgrInst->createValue(array);
  }

  /*-----------------*/

  if (value1->getType() != value2->getType()) {
    if (op->getType() == CL_PARSER_OP_TIMES &&
        value1->isType(CL_PARSER_VALUE_TYPE_INTEGER))
      return ClParserProcessBinaryOperator(value2, op, value1, error_code);
    else {
      bool fix_list = false;

      if (value1->isType(CL_PARSER_VALUE_TYPE_LIST) ||
          value2->isType(CL_PARSER_VALUE_TYPE_LIST))
        fix_list = true;

      if (value1->isType(CL_PARSER_VALUE_TYPE_LIST) &&
          (op->getType() == CL_PARSER_OP_TIMES ||
           op->getType() == CL_PARSER_OP_DIVIDE))
        fix_list = false;

      if (fix_list) {
        ClParserValuePtr value3 = ClParserValueMgrInst->createValue(CL_PARSER_VALUE_TYPE_LIST);

        if (value1->isType(CL_PARSER_VALUE_TYPE_LIST)) {
          value3->getList()->addValue(value2);

          return ClParserProcessBinaryOperator(value1, op, value3, error_code);
        }
        else {
          value3->getList()->addValue(value1);

          return ClParserProcessBinaryOperator(value3, op, value2, error_code);
        }
      }
    }

    /*-----------------*/

    if (value1->isNumeric() && value2->isNumeric()) {
      if (! ClParserValue::checkBinaryTypes(value1, value2)) {
        ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
        return ClParserValuePtr();
      }
    }
  }

  /*-----------------*/

  if (value1->isType(CL_PARSER_VALUE_TYPE_ARRAY) &&
      value2->isType(CL_PARSER_VALUE_TYPE_ARRAY)) {
    if (! ClParserValue::checkBinaryTypes(value1, value2)) {
      ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_MIX);
      return ClParserValuePtr();
    }
  }

  /*-----------------*/

  ClParserValuePtr value = ClParserValueMgrInst->createValue(value1);

  try {
    switch (op->getType()) {
      case CL_PARSER_OP_PLUS        : return value1->plus(value2);
      case CL_PARSER_OP_MINUS       : return value1->minus(value2);
      case CL_PARSER_OP_TIMES       : return value1->times(value2);
      case CL_PARSER_OP_DIVIDE      : return value1->divide(value2);
      case CL_PARSER_OP_MODULUS     : return value1->modulus(value2);
      case CL_PARSER_OP_POWER       : return value1->power(value2);
      case CL_PARSER_OP_APPROX_EQUAL: return value1->approxEqual(value2);
      case CL_PARSER_OP_BIT_AND     : return value1->bitAnd(value2);
      case CL_PARSER_OP_BIT_OR      : return value1->bitOr(value2);
      case CL_PARSER_OP_BIT_XOR     : return value1->bitXor(value2);
      case CL_PARSER_OP_BIT_LSHIFT  : return value1->bitLShift(value2);
      case CL_PARSER_OP_BIT_RSHIFT  : return value1->bitRShift(value2);

      default: assert(false); return ClParserValuePtr();
    }
  }
  catch (...) {
    ClParserInst->signalError(error_code, ClErr::INVALID_TYPE_FOR_OPERATOR);
    return ClParserValuePtr();
  }
}
Exemple #8
0
std::string TypedValue::pretty() const {
  char buf[20];
  snprintf(buf, sizeof(buf), "0x%lx", long(m_data.num));
  return Trace::prettyNode(tname(m_type).c_str(), std::string(buf));
}
int test_main(int,char *[])
{
    // default constructor
    const bu::quantity<bu::dimensionless>           E1; 
    BOOST_CHECK(E1.value() == double());
    
    // value_type constructor
    const bu::quantity<bu::dimensionless>           E2(E_);
    BOOST_CHECK(E2.value() == E_);

    // copy constructor
    const bu::quantity<bu::dimensionless>           E3(E2);
    BOOST_CHECK(E3.value() == E_);

    // operator=
    const bu::quantity<bu::dimensionless>           E4 = E2;
    BOOST_CHECK(E4.value() == E_);

    // implicit copy constructor value_type conversion
    const bu::quantity<bu::dimensionless,float>     E5(E2);
    BOOST_UNITS_CHECK_CLOSE(E5.value(), float(E_));

    const bu::quantity<bu::dimensionless,long>      E6(E2);
    BOOST_CHECK(E6.value() == long(E_));

    // implicit operator= value_type conversion
    // narrowing conversion disallowed
//    const bu::quantity<bu::dimensionless,float>     E7 = E2;
//    BOOST_UNITS_CHECK_CLOSE(E7.value(),float(E_));
    
    // narrowing conversion disallowed
//    const bu::quantity<bu::dimensionless,long>      E8 = E2;
//    BOOST_CHECK(E8.value() == long(E_));
    
    // const construction
    bu::quantity<bu::dimensionless>                 E9(E2); 
    BOOST_CHECK(E9.value() == E_);
    
//    // value assignment
//    E9.value() = 1.5*bu::dimensionless();
//    BOOST_CHECK(E9.value() == 1.5);
//    
//    // value assignment with implicit conversion
//    E9.value() = 1.5;
//    BOOST_CHECK(E9.value() == 1.5);
//    
//    // value assignment with implicit value_type conversion
//    E9.value() = 2*bu::dimensionless();
//    BOOST_CHECK(E9.value() == double(2));
//
//    // value assignment with implicit value_type conversion
//    E9.value() = 2;
//    BOOST_CHECK(E9.value() == double(2));
    
    // operator+=(this_type)
    E9 = 2.0;
    E9 += E9;
    BOOST_CHECK(E9.value() == 4.0);
    
    // operator-=(this_type)
    E9 = 2.0;
    E9 -= E9;
    BOOST_CHECK(E9.value() == 0.0);
    
    // operator*=(value_type)
    E9 = 2.0;
    E9 *= 2.0;
    BOOST_CHECK(E9.value() == 4.0);
    
    // operator/=(value_type)
    E9 = 2.0;
    E9 /= 2.0;
    BOOST_CHECK(E9.value() == 1.0);
    
    // static construct quantity from value_type
    const bu::quantity<bu::dimensionless>           E(bu::quantity<bu::dimensionless>::from_value(2.5));
    BOOST_CHECK(E.value() == 2.5);
    
    // implicit conversion to value_type
    const double    V1(E9);
    BOOST_CHECK(V1 == E9.value());
    
    const double    V2 = E9;
    BOOST_CHECK(V2 == E9.value());
            
    // unit * scalar
    BOOST_CHECK(bu::dimensionless()*2.0 == bu::quantity<bu::dimensionless>::from_value(2.0));
    
    // unit / scalar
    BOOST_CHECK(bu::dimensionless()/2.0 == bu::quantity<bu::dimensionless>::from_value(0.5));
    
    // scalar * unit
    BOOST_CHECK(2.0*bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0));
    
    // scalar / unit
    BOOST_CHECK(2.0/bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0));

    //  quantity * scalar
    BOOST_CHECK(E*2.0 == bu::quantity<bu::dimensionless>::from_value(5.0));

    //  quantity / scalar
    BOOST_CHECK(E/2.0 == bu::quantity<bu::dimensionless>::from_value(1.25));
    
    // scalar * quantity
    BOOST_CHECK(2.0*E == bu::quantity<bu::dimensionless>::from_value(5.0));

    // scalar / quantity
    BOOST_CHECK(2.0/E == bu::quantity<bu::dimensionless>::from_value(0.8));

    const bu::quantity<bu::dimensionless>       D1(1.0),
                                                D2(2.0);
    
    // unit * quantity
    BOOST_CHECK(bu::dimensionless()*D1 == D1);
    
    // unit / quantity
    BOOST_CHECK(bu::dimensionless()/D1 == D1);
    
    // quantity * unit
    BOOST_CHECK(D1*bu::dimensionless() == D1);
    
    // quantity / unit
    BOOST_CHECK(D1*bu::dimensionless() == D1);
    
    // +quantity
    BOOST_CHECK(+D1 == 1.0*bu::dimensionless());
    
    // -quantity
    BOOST_CHECK(-D1 == -1.0*bu::dimensionless());
    
    // quantity + quantity
    BOOST_CHECK(D2+D1 == 3.0*bu::dimensionless());
    
    // quantity - quantity
    BOOST_CHECK(D2-D1 == 1.0*bu::dimensionless());
    
    // quantity * quantity
    BOOST_CHECK(D1*D2 == 2.0*bu::dimensionless());
    
    // quantity / quantity
    BOOST_CHECK(D2/D1 == 2.0*bu::dimensionless());
    
    // integer power of quantity
    BOOST_CHECK(2.0*bu::pow<2>(D2) == 2.0*std::pow(2.0,2.0)*bu::dimensionless());
    
    // rational power of quantity
    BOOST_CHECK((2.0*bu::pow< bu::static_rational<2,3> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless()));
    
    // integer root of quantity
    BOOST_CHECK(2.0*bu::root<2>(D2) == 2.0*std::pow(2.0,1.0/2.0)*bu::dimensionless());
    
    // rational root of quantity
    BOOST_CHECK((2.0*bu::root< bu::static_rational<3,2> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless()));
    
    const bu::quantity<bu::dimensionless>   A1(0.0),
                                            A2(0.0),
                                            A3(1.0),
                                            A4(-1.0);
                                    
    // operator==
    BOOST_CHECK((A1 == A2) == true);
    BOOST_CHECK((A1 == A3) == false);
    
    // operator!=
    BOOST_CHECK((A1 != A2) == false);
    BOOST_CHECK((A1 != A3) == true);
    
    // operator<
    BOOST_CHECK((A1 < A2) == false);
    BOOST_CHECK((A1 < A3) == true);
    
    // operator<=
    BOOST_CHECK((A1 <= A2) == true);
    BOOST_CHECK((A1 <= A3) == true);
    
    // operator>
    BOOST_CHECK((A1 > A2) == false);
    BOOST_CHECK((A1 > A4) == true);
    
    // operator>=
    BOOST_CHECK((A1 >= A2) == true);
    BOOST_CHECK((A1 >= A4) == true);
    
    return 0;
}