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; }
C(const C& other) { std::cout << "Copy constructor for " << long(this) << " with argument " << long(&other) << "\n"; }
~C() { std::cout << "Destructor for " << long(this) << "\n"; }
C() { std::cout << "Default constructor for " << long(this) << "\n"; }
// 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; }
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(); } }
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; }