C++ numeric::Ptr类代码示例

/** Returns the mod of its operands as a Numeric */
Numeric::Ptr ATFloatOrDerivedImpl::mod(const Numeric::Ptr &other, const DynamicContext* context) const {
    if(other->getPrimitiveTypeIndex() == AnyAtomicType::DECIMAL) {
        // if other is a decimal, promote it to xs:float
        return this->mod((const Numeric::Ptr )other->castAs(this->getPrimitiveTypeIndex(), context), context);
    } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::DOUBLE) {
        // if other is a double, promote this to xs:double
        return ((const Numeric::Ptr )this->castAs(other->getPrimitiveTypeIndex(), context))->mod(other, context);
    } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::FLOAT) {
        // same primitive type, can make comparison
        const ATFloatOrDerivedImpl* otherImpl = (ATFloatOrDerivedImpl*)(const Numeric*)other;
        if(this->isNaN() || otherImpl->isNaN() || this->isInfinite() || otherImpl->isZero()) {
            return notANumber(context);
        } else if(otherImpl->isInfinite() || this->isZero()) {
            return (const Numeric::Ptr )this->castAs(AnyAtomicType::FLOAT, context);
        } else {
            MAPM result = _float;
            MAPM r;
            r = result.integer_divide(otherImpl->_float);
            result -= r * otherImpl->_float;
            if (result == 0 && isNegative())
                return negZero(context);
            return newFloat(result, context);
        }
    } else {
        assert(false); // should never get here, numeric types are xs:decimal, xs:float, xs:integer and xs:double
        return 0;
    }
}

Sequence FunctionRegexGroup::createSequence(DynamicContext *context, int flags) const
{
    XPath2MemoryManager *mm = context->getMemoryManager();

    const RegexGroupStore *store = context->getRegexGroupStore();
    if(store == 0)
        return Sequence(context->getItemFactory()->createString(XMLUni::fgZeroLenString, context), mm);

    Numeric::Ptr indexItem = getParamNumber(1, context)->next(context);
    if(indexItem->isNegative())
        return Sequence(context->getItemFactory()->createString(XMLUni::fgZeroLenString, context), mm);

    const XMLCh *indexStr = indexItem->asString(context);

    int index = 0;
    while(*indexStr != 0) {
        if(*indexStr >= '0' && *indexStr <= '9') {
            index *= 10;
            index += *indexStr - '0';
        }
        ++indexStr;
    }

    const XMLCh *result = store->getGroup(index);
    if(result == 0) result = XMLUni::fgZeroLenString;

    return Sequence(context->getItemFactory()->createString(result, context), mm);
}

 TEST_F(TestNumericFactory, GetShouldReturnValidNumericObject)
 {
   NumericFactory factory;
   factory.Add("TEST", createInstance);
   Numeric::Ptr numeric = factory.Get("TEST", BASE_DECIMAL);
   EXPECT_NE(static_cast<Numeric*>(0), numeric.get());
 }

Item::Ptr PromoteNumericResult::next(DynamicContext *context)
{
  Item::Ptr item = parent_->next(context);
  if(item.notNull()) {
    assert(item->isAtomicValue());
    const AnyAtomicType *atomic = (const AnyAtomicType *)item.get();

    // 3. For each numeric item in the atomic sequence that can be promoted to the expected atomic type using
    //    the promotion rules in B.1 Type Promotion, the promotion is done.
    if(atomic->isNumericValue()) {
      try {
        const Numeric::Ptr promotedType = ((const Numeric*)atomic)->
          promoteTypeIfApplicable(typeIndex_, context);
        if(promotedType.notNull()) {
          item = promotedType;
        }
      } catch (XPath2TypeCastException &e) {
        XQThrow(XPath2ErrorException, X("SequenceType::AtomicTypeConvertFunctionArgResult::next"),
                 X("Numeric type promotion failed (for promotable type)"));
      } catch (const XMLException& e) {
        XQThrow(XPath2ErrorException, X("SequenceType::AtomicTypeConvertFunctionArgResult::next"),
                 X("Numeric type promotion failed (for promotable type)"));
      }
    }
  }
  else {
    parent_ = 0;
  }

  return item;
}

Result FunctionPower::createResult(DynamicContext* context, int flags) const
{
  Numeric::Ptr base = getNumericParam(1, context);
  if(base.isNull()) return 0;
  Numeric::Ptr pow = getNumericParam(2, context);
  if(pow.isNull()) return 0;
  return (Item::Ptr)base->power(pow, context);
}

/** Returns a Numeric object which is the difference of this and
   * other */
Numeric::Ptr ATFloatOrDerivedImpl::subtract(const Numeric::Ptr &other, const DynamicContext* context) const {
  if(other->getPrimitiveTypeIndex() == AnyAtomicType::DECIMAL) {
    // if other is a decimal, promote it to xs:float
    return this->subtract((const Numeric::Ptr )other->castAs(this->getPrimitiveTypeIndex(), context), context);
  } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::DOUBLE) {
    // if other is a double, promote this to xs:double
    return ((const Numeric::Ptr )this->castAs(other->getPrimitiveTypeIndex(), context))->subtract(other, context);
  } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::FLOAT) {
    // same primitive type, can make comparison
    ATFloatOrDerivedImpl* otherImpl = (ATFloatOrDerivedImpl*)(const Numeric*)other;
    if(otherImpl->_state == NaN) return notANumber(context);

    switch (_state) {
      case NaN: return notANumber(context);
      case INF: {
        switch(otherImpl->_state) {
          case NaN: return notANumber(context);   // case taken care of above
          case NEG_NUM:
          case NUM: return infinity(context);     // INF - NUM = INF
          case INF: return notANumber(context);   // INF - INF = NaN
          case NEG_INF: return infinity(context); // INF - (-INF) = INF
          default: assert(false); return 0; // should never get here
        }
      }
      case NEG_INF: {
        switch(otherImpl->_state) {
          case NaN: return notANumber(context);          //case taken care of above
          case NEG_NUM:
          case NUM: return negInfinity(context);         // -INF - NUM = -INF
          case INF: return negInfinity(context);         // -INF - INF = -INF
          case NEG_INF: return notANumber(context);      // -INF - (-INF) = NaN
          default: assert(false); return 0; // should never get here
        }
      }                
      case NEG_NUM:
      case NUM: {
        switch(otherImpl->_state) {
          case NaN: return notANumber(context);          // case taken care of above
          case INF: return negInfinity(context);         // NUM - INF = -INF
          case NEG_INF: return infinity(context);        // NUM - (-INF) = INF
          case NEG_NUM:
          case NUM: return newFloat(_float - otherImpl->_float, context);
          default: assert(false); return 0;  // should never get here
        }
      }
      default: assert(false); return 0;  // should never get here
    } 
  } else {
    assert(false); // should never get here, numeric types are xs:decimal, xs:float, xs:integer and xs:double
    return 0;
  }
}

Sequence FunctionFloor::createSequence(DynamicContext* context, int flags) const
{
  Numeric::Ptr numericArg = getNumericParam(1, context);

  //If the argument is the empty sequence, the empty sequence is returned.
  if(numericArg.isNull()) {
    return Sequence(context->getMemoryManager());
  }

  if(numericArg->isNaN() || numericArg->isInfinite())
    return Sequence(numericArg, context->getMemoryManager());
  return Sequence(numericArg->floor(context), context->getMemoryManager());
}

Sequence FunctionRound::createSequence(DynamicContext* context, int flags) const
{
  XPath2MemoryManager* memMgr = context->getMemoryManager();

  Numeric::Ptr numericArg = getNumericParam(1, context);
    
  //If the argument is the empty sequence, the empty sequence is returned.
  if(numericArg.isNull()) {
    return Sequence(memMgr);
  }

  if(numericArg->isNaN() || numericArg->isInfinite())
    return Sequence(numericArg, memMgr);
  return Sequence(numericArg->round(context), memMgr);
}

  Item::Ptr nextOrTail(Result &tail, DynamicContext *context)
  {
    Numeric::Ptr one = context->getItemFactory()->createDouble(1, context);
    Result source = ClosureResult::create(_func->getArguments()[0], context);

    Numeric::Ptr i = one;
    Numeric::Ptr position = ((Numeric*)_func->getParamNumber(2, context)->next(context).get())->round(context);

    while(i->lessThan(position, context) && source->next(context).notNull()) {
      i = i->add(one, context);
    }

    tail = source;
    return 0;
  }

FTSelection *FTDistance::optimize(FTContext *ftcontext, bool execute) const
{
    XPath2MemoryManager *mm = ftcontext->context->getMemoryManager();

    if(execute || range_.arg1->isConstant()) {
        Result rangeResult = range_.arg1->createResult(ftcontext->context);
        Numeric::Ptr num = (Numeric::Ptr)rangeResult->next(ftcontext->context);
        long distance = ::atol(UTF8(num->asString(ftcontext->context)));

        switch(range_.type) {
        case FTRange::EXACTLY: {
            FTSelection *result = new (mm) FTDistanceLiteral(arg_, FTRange::EXACTLY, distance, 0, unit_, mm);
            result->setLocationInfo(this);
            return result->optimize(ftcontext, execute);
        }
        case FTRange::AT_LEAST: {
            FTSelection *result = new (mm) FTDistanceLiteral(arg_, FTRange::AT_LEAST, distance, 0, unit_, mm);
            result->setLocationInfo(this);
            return result->optimize(ftcontext, execute);
        }
        case FTRange::AT_MOST: {
            FTSelection *result = new (mm) FTDistanceLiteral(arg_, FTRange::AT_MOST, distance, 0, unit_, mm);
            result->setLocationInfo(this);
            return result->optimize(ftcontext, execute);
        }
        case FTRange::FROM_TO: {
            Result rangeResult2 = range_.arg2->createResult(ftcontext->context);
            Numeric::Ptr num2 = (Numeric::Ptr)rangeResult2->next(ftcontext->context);
            long distance2 = ::atol(UTF8(num->asString(ftcontext->context)));

            FTSelection *result = new (mm) FTDistanceLiteral(arg_, FTRange::FROM_TO, distance, distance2, unit_, mm);
            result->setLocationInfo(this);
            return result->optimize(ftcontext, execute);
        }
        }
    }

    FTSelection *newarg = arg_->optimize(ftcontext, execute);
    if(newarg == 0) return 0;

    if(newarg->getType() == WORD) {
        return newarg;
    }

    newarg = new (mm) FTDistance(range_, unit_, newarg, mm);
    newarg->setLocationInfo(this);
    return newarg;
}

/** Rounds this Numeric to the given precision, and rounds a half to even */
Numeric::Ptr ATDecimalOrDerivedImpl::roundHalfToEven(const Numeric::Ptr &precision, const DynamicContext* context) const {
  ATDecimalOrDerived::Ptr decimal_precision = (const Numeric::Ptr)precision->castAs(this->getPrimitiveTypeIndex(), context);
  MAPM exp = MAPM(10).pow(((ATDecimalOrDerivedImpl*)(const ATDecimalOrDerived*)decimal_precision)->_decimal);
  MAPM value = _decimal * exp;
  bool halfVal = false;

  // check if we're rounding on a half value 
  if((value-0.5) == (value.floor())) {
    halfVal = true;
  }
  value = _decimal * exp + 0.5;
  value = value.floor();

  // if halfVal make sure what we return has the least significant digit even
  if (halfVal) {
    if(value.is_odd()) {
      value = value - 1;
    }
  }
  value = value / exp;  
  // if integer, return xs:integer, otherwise xs:decimal    
  if(_isInteger) {
    return context->getItemFactory()->createInteger(value, context);
  }
  return context->getItemFactory()->createDecimal(value, context);
}

/** Rounds this Numeric to the given precision, and rounds a half to even */
Numeric::Ptr ATFloatOrDerivedImpl::roundHalfToEven(const Numeric::Ptr &precision, const DynamicContext* context) const {
    switch (_state) {
    case NaN:
        return notANumber(context);
    case INF:
        return infinity(context);
    case NEG_INF:
        return negInfinity(context);
    case NEG_NUM:
    case NUM:
        break;
    default: {
        assert(false);
        return 0; // should never get here
    }
    }

    if (isZero() && isNegative())
        return this;

    ATFloatOrDerived::Ptr float_precision = (const Numeric::Ptr)precision->castAs(this->getPrimitiveTypeIndex(), context);
    MAPM exp = MAPM(10).pow(((ATFloatOrDerivedImpl*)(const ATFloatOrDerived*)float_precision)->_float);
    MAPM value = _float * exp;
    bool halfVal = false;

    // check if we're rounding on a half value
    if((value-0.5) == (value.floor())) {
        halfVal = true;
    }
    value = _float * exp + 0.5;
    value = value.floor();

    // if halfVal make sure what we return has the least significant digit even
    if (halfVal) {
        if(value.is_odd()) {
            value = value - 1;
        }
    }
    value = value / exp;

    // the spec doesn't actually say to do this, but djf believes this is the correct way to handle rounding of -ve values which will result in 0.0E0
    // if (value == 0 && isNegative())
    // return negZero(context);
    return newFloat(value, context);
}

/** Returns the arithmetic product of its operands as a Numeric */
Numeric::Ptr ATDecimalOrDerivedImpl::mod(const Numeric::Ptr &other, const DynamicContext* context) const {
  if(this->isOfType(other->getTypeURI(), other->getTypeName(), context)) {
    // if both are of the same type exactly, we can perform the modulo
    const ATDecimalOrDerivedImpl* otherImpl = (ATDecimalOrDerivedImpl*)(const Numeric*)other;
  
    if(otherImpl->isZero()) {
      XQThrow2(::IllegalArgumentException, X("ATDecimalOrDerivedImpl::mod"), X("Division by zero [err:FOAR0001]"));
    }
  
    MAPM result = _decimal;
    MAPM r;
    r = result.integer_divide(otherImpl->_decimal);
    result -= r * otherImpl->_decimal;
    // if integer, return xs:integer, otherwise xs:decimal    
    if(_isInteger) {
      return context->getItemFactory()->createInteger(result, context);
    }
    return context->getItemFactory()->createDecimal(result, context);
  } else if(this->getPrimitiveTypeIndex() != other->getPrimitiveTypeIndex()) {
    // if other is not a decimal, then we need to promote this to a float or double
    return ((const Numeric::Ptr )this->castAs(other->getPrimitiveTypeIndex(), context))->mod(other, context);
  } else if (this->isInstanceOfType(other->getTypeURI(), other->getTypeName(), context)) {
    // here we know we have two decimals, and this is 'lower' in the hierarchy than other
    // so cast this to other's type
    return ((const Numeric::Ptr )this->castAs(AnyAtomicType::DECIMAL, other->getTypeURI(), other->getTypeName(), context))->mod(other, context);
  } else if (other->isInstanceOfType(this->getTypeURI(), this->getTypeName(), context)) {
    // here we have two decimals, and this is 'higher' in the hierarchy than other
    // so cast other to this' type
    return this->mod((const Numeric::Ptr )other->castAs(AnyAtomicType::DECIMAL, this->getTypeURI(), this->getTypeName(), context), context);
  } else {
    // we have two separate branches.  if either is instance of integer, cast it to integer, otherwise, cast to decimal
    // revisit: this is not the prettiest way to do it.  You would want to go up the tree one by one instead of
    // jumping to integer and decimal
    ATDecimalOrDerived::Ptr first;
    ATDecimalOrDerived::Ptr second; 
    if(this->_isInteger) {
      first = (const ATDecimalOrDerived::Ptr )this->castAs(AnyAtomicType::DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                           SchemaSymbols::fgDT_INTEGER, context);
    } else {
      first = (const ATDecimalOrDerived::Ptr )this->castAs(AnyAtomicType::DECIMAL, context);
    }
    
    if(((ATDecimalOrDerivedImpl*)(const Numeric*)other)->_isInteger) {
      second = (const ATDecimalOrDerived::Ptr )other->castAs(AnyAtomicType::DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                            SchemaSymbols::fgDT_INTEGER, context);
    } else {
      second = (const ATDecimalOrDerived::Ptr )other->castAs(AnyAtomicType::DECIMAL, context);
    }
    return first->mod(second, context);
  }

}

/** Returns a Numeric object which is the difference of this and
   * other */
Numeric::Ptr ATDecimalOrDerivedImpl::subtract(const Numeric::Ptr &other, const DynamicContext* context) const {
    if(this->isOfType(other->getTypeURI(), other->getTypeName(), context)) {
    // if both are of the same type exactly, we can perform subtraction
    ATDecimalOrDerivedImpl* otherImpl = (ATDecimalOrDerivedImpl*)(const Numeric*)other;
    // if integer, return xs:integer, otherwise xs:decimal    
    if(_isInteger) {
      return context->getItemFactory()->createInteger(_decimal - otherImpl->_decimal, context);
    }
    return context->getItemFactory()->createDecimal(_decimal - otherImpl->_decimal, context);

  } else if(this->getPrimitiveTypeIndex() != other->getPrimitiveTypeIndex()) {
    // if other is not a decimal, then we need to promote this to a float or double
    return ((const Numeric::Ptr )this->castAs(other->getPrimitiveTypeIndex(), context))->subtract(other, context);
  } else if (this->isInstanceOfType(other->getTypeURI(), other->getTypeName(), context)) {
    // here we know we have two decimals, and this is 'lower' in the hierarchy than other
    // so cast this to other's type
    return ((const Numeric::Ptr )this->castAs(AnyAtomicType::DECIMAL, other->getTypeURI(), other->getTypeName(),
                                              context))->subtract(other, context);
  } else if (other->isInstanceOfType(this->getTypeURI(), this->getTypeName(), context)) {
    // here we have two decimals, and this is 'higher' in the hierarchy than other
    // so cast other to this' type
    return this->subtract((const Numeric::Ptr )other->castAs(AnyAtomicType::DECIMAL, getTypeURI(), getTypeName(),
                                                             context), context);
  } else {
    // we have two separate branches.  if either is instance of integer, cast it to integer, otherwise, cast to decimal
    // revisit: this is not the prettiest way to do it.  You would want to go up the tree one by one instead of
    // jumping to integer and decimal
    ATDecimalOrDerived::Ptr first; 
    ATDecimalOrDerived::Ptr second; 
    if(this->_isInteger) {
      first = (const ATDecimalOrDerived::Ptr )this->castAs(AnyAtomicType::DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                           SchemaSymbols::fgDT_INTEGER, context);
    } else {
      first = (const ATDecimalOrDerived::Ptr )this->castAs(AnyAtomicType::DECIMAL, context);
    }

    if(((ATDecimalOrDerivedImpl*)(const Numeric*)other)->_isInteger) {
      second = (const ATDecimalOrDerived::Ptr )other->castAs(AnyAtomicType::DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                            SchemaSymbols::fgDT_INTEGER, context);
    } else {
      second = (const ATDecimalOrDerived::Ptr )other->castAs(AnyAtomicType::DECIMAL, context);
    }
    return first->subtract(second, context);
  }

}

/** Returns a Numeric object which is the sum of this and other */
Numeric::Ptr ATFloatOrDerivedImpl::add(const Numeric::Ptr &other, const DynamicContext* context) const {
    if(other->getPrimitiveTypeIndex() == AnyAtomicType::DECIMAL) {
        // if other is a decimal, promote it to xs:float
        return this->add((const Numeric::Ptr )other->castAs(this->getPrimitiveTypeIndex(), context), context);
    } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::DOUBLE) {
        // if other is a double, promote this to xs:double
        return ((const Numeric::Ptr )this->castAs(other->getPrimitiveTypeIndex(), context))->add(other, context);
    } else if (other->getPrimitiveTypeIndex() == AnyAtomicType::FLOAT) {
        // same primitive type, can make comparison
        ATFloatOrDerivedImpl* otherImpl = (ATFloatOrDerivedImpl*)(const Numeric*)other;
        if(otherImpl->_state == NaN) return notANumber(context);

        switch (_state) {
        case NaN:
            return notANumber(context);
        case INF: {
            switch(otherImpl->_state) {
            case NaN:
                return notANumber(context);       // case taken care of above
            case NEG_NUM:
            case NUM:
                return infinity(context);         // INF + NUM = INF
            case INF:
                return infinity(context);         // INF + INF = INF
            case NEG_INF:
                return notANumber(context);   // INF + (-INF) = NaN
            default:
                assert(false);
                return 0; // should never get here
            }
        }
        case NEG_INF: {
            switch(otherImpl->_state) {
            case NaN:
                return notANumber(context);          //case taken care of above
            case NEG_NUM:
            case NUM:
                return negInfinity(context);         // -INF + NUM = -INF
            case INF:
                return notANumber(context);          // -INF + INF = NaN
            case NEG_INF:
                return negInfinity(context);     // -INF + (-INF) = -INF
            default:
                assert(false);
                return 0; // should never get here
            }
        }
        case NEG_NUM:
        case NUM: {
            switch(otherImpl->_state) {
            case NaN:
                return notANumber(context); // case taken care of above
            case INF:
                return infinity(context);
            case NEG_INF:
                return negInfinity(context);
            case NEG_NUM:
            case NUM:
            {
                // Handle positive and negative zero
                if(_float.sign()==0 && otherImpl->_float!=0)
                    return other;
                else if(_float.sign()!=0 && otherImpl->_float==0)
                    return this;
                else if(_float.sign()==0 && otherImpl->_float==0)
                {
                    if(_state==otherImpl->_state)
                        // sum of two zero of the same sign -> result is equal to any of the two items
                        return this;
                    else
                        // sum of two zero of different sign -> result is equal to +0
                        return newFloat(0, context);
                }
                return newFloat(_float + otherImpl->_float, context);
            }
            default:
                assert(false);
                return 0; // should never get here
            }
        }
        default:
            assert(false);
            return 0; // should never get here
        }
    } else {
        assert(false); // should never get here, numeric types are xs:decimal, xs:float, xs:integer and xs:double
        return 0;
    }
}