Lines Matching defs:APFloat
1 //===-- APFloat.cpp - Implement APFloat class -----------------------------===//
14 #include "llvm/ADT/APFloat.h"
43 /// in a switch statement to classify how the interaction of two APFloat's
211 if (&Sem == &llvm::APFloat::IEEEhalf())
213 else if (&Sem == &llvm::APFloat::BFloat())
215 else if (&Sem == &llvm::APFloat::IEEEsingle())
217 else if (&Sem == &llvm::APFloat::IEEEdouble())
219 else if (&Sem == &llvm::APFloat::IEEEquad())
221 else if (&Sem == &llvm::APFloat::PPCDoubleDouble())
223 else if (&Sem == &llvm::APFloat::PPCDoubleDoubleLegacy())
225 else if (&Sem == &llvm::APFloat::Float8E5M2())
227 else if (&Sem == &llvm::APFloat::Float8E5M2FNUZ())
229 else if (&Sem == &llvm::APFloat::Float8E4M3())
231 else if (&Sem == &llvm::APFloat::Float8E4M3FN())
233 else if (&Sem == &llvm::APFloat::Float8E4M3FNUZ())
235 else if (&Sem == &llvm::APFloat::Float8E4M3B11FNUZ())
237 else if (&Sem == &llvm::APFloat::Float8E3M4())
239 else if (&Sem == &llvm::APFloat::FloatTF32())
241 else if (&Sem == &llvm::APFloat::Float8E8M0FNU())
243 else if (&Sem == &llvm::APFloat::Float6E3M2FN())
245 else if (&Sem == &llvm::APFloat::Float6E2M3FN())
247 else if (&Sem == &llvm::APFloat::Float4E2M1FN())
249 else if (&Sem == &llvm::APFloat::x87DoubleExtended())
611 D->exponent += static_cast<APFloat::ExponentType>((dot - p) - (dot > p));
613 static_cast<APFloat::ExponentType>((p - D->firstSigDigit)
1141 return (IsMaxExp && APFloat::hasSignificand(*semantics))
1217 const APFloat::integerPart *IEEEFloat::significandParts() const {
1221 APFloat::integerPart *IEEEFloat::significandParts() {
1244 APFloat::integerPart IEEEFloat::addSignificand(const IEEEFloat &rhs) {
1257 APFloat::integerPart IEEEFloat::subtractSignificand(const IEEEFloat &rhs,
1352 status = extendedAddend.convert(extendedSemantics, APFloat::rmTowardZero,
1354 assert(status == APFloat::opOK);
1532 APFloat::cmpResult IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const {
1574 APFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
1644 APFloat::opStatus IEEEFloat::normalize(roundingMode rounding_mode,
1778 APFloat::opStatus IEEEFloat::addOrSubtractSpecials(const IEEEFloat &rhs,
1907 APFloat::opStatus IEEEFloat::multiplySpecials(const IEEEFloat &rhs) {
1951 APFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
2000 APFloat::opStatus IEEEFloat::modSpecials(const IEEEFloat &rhs) {
2038 APFloat::opStatus IEEEFloat::remainderSpecials(const IEEEFloat &rhs) {
2088 APFloat::opStatus IEEEFloat::addOrSubtract(const IEEEFloat &rhs,
2121 APFloat::opStatus IEEEFloat::add(const IEEEFloat &rhs,
2127 APFloat::opStatus IEEEFloat::subtract(const IEEEFloat &rhs,
2133 APFloat::opStatus IEEEFloat::multiply(const IEEEFloat &rhs,
2153 APFloat::opStatus IEEEFloat::divide(const IEEEFloat &rhs,
2173 APFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
2283 APFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) {
2321 APFloat::opStatus IEEEFloat::fusedMultiplyAdd(const IEEEFloat &multiplicand,
2367 APFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
2418 if (exponent + 1 >= (int)APFloat::semanticsPrecision(*semantics))
2427 APInt IntegerConstant(NextPowerOf2(APFloat::semanticsPrecision(*semantics)),
2429 IntegerConstant <<= APFloat::semanticsPrecision(*semantics) - 1;
2454 APFloat::cmpResult IEEEFloat::compare(const IEEEFloat &rhs) const {
2531 APFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
2679 APFloat::opStatus IEEEFloat::convertToSignExtendedInteger(
2792 APFloat::opStatus
2825 APFloat::opStatus IEEEFloat::convertFromUnsignedParts(
2853 APFloat::opStatus IEEEFloat::convertFromAPInt(const APInt &Val, bool isSigned,
2870 APFloat::opStatus
2896 APFloat::opStatus
2912 Expected<APFloat::opStatus>
3006 APFloat::opStatus
3091 Expected<APFloat::opStatus>
3286 Expected<APFloat::opStatus>
3508 // Conversion from APFloat to/from host float/double. It may eventually be
3514 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
3559 // Declare fltSemantics before APFloat that uses it (and
3914 // always set to 1 for consistency in APFloat's internal representation.
4292 // APFloat. The formula comes from "How to Print Floating-Point Numbers
4517 bool IEEEFloat::getExactInverse(APFloat *inv) const {
4541 *inv = APFloat(reciprocal, *semantics);
4591 APFloat::opStatus IEEEFloat::next(bool nextDown) {
4699 bool WillCrossBinadeBoundary = !APFloat::hasSignificand(*semantics) ||
4773 return APFloat::IEK_NaN;
4775 return APFloat::IEK_Zero;
4777 return APFloat::IEK_Inf;
4785 Normalized.normalize(APFloat::rmNearestTiesToEven, lfExactlyZero);
4814 if (Exp == APFloat::IEK_NaN) {
4820 if (Exp == APFloat::IEK_Inf)
4825 Exp = Exp == APFloat::IEK_Zero ? 0 : Exp + 1;
4831 Floats(new APFloat[2]{APFloat(semIEEEdouble), APFloat(semIEEEdouble)}) {
4837 Floats(new APFloat[2]{APFloat(semIEEEdouble, uninitialized),
4838 APFloat(semIEEEdouble, uninitialized)}) {
4843 : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
4844 APFloat(semIEEEdouble)}) {
4850 Floats(new APFloat[2]{
4851 APFloat(semIEEEdouble, APInt(64, I.getRawData()[0])),
4852 APFloat(semIEEEdouble, APInt(64, I.getRawData()[1]))}) {
4856 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
4857 APFloat &&Second)
4859 Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
4867 Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
4868 APFloat(RHS.Floats[1])}
4893 APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
4894 const APFloat &c, const APFloat &cc,
4897 APFloat z = a;
4909 if (AComparedToC == APFloat::cmpGreaterThan) {
4924 APFloat zz = aa;
4926 if (AComparedToC == APFloat::cmpGreaterThan) {
4941 APFloat q = a;
4972 APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
5007 APFloat A(LHS.Floats[0]), AA(LHS.Floats[1]), C(RHS.Floats[0]),
5018 APFloat::opStatus DoubleAPFloat::add(const DoubleAPFloat &RHS,
5023 APFloat::opStatus DoubleAPFloat::subtract(const DoubleAPFloat &RHS,
5031 APFloat::opStatus DoubleAPFloat::multiply(const DoubleAPFloat &RHS,
5032 APFloat::roundingMode RM) {
5075 APFloat A = Floats[0], B = Floats[1], C = RHS.Floats[0], D = RHS.Floats[1];
5077 APFloat T = A;
5086 APFloat Tau = A;
5092 APFloat V = A;
5095 APFloat W = B;
5102 APFloat U = T;
5117 APFloat::opStatus DoubleAPFloat::divide(const DoubleAPFloat &RHS,
5118 APFloat::roundingMode RM) {
5120 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5122 Tmp.divide(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()), RM);
5127 APFloat::opStatus DoubleAPFloat::remainder(const DoubleAPFloat &RHS) {
5129 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5131 Tmp.remainder(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
5136 APFloat::opStatus DoubleAPFloat::mod(const DoubleAPFloat &RHS) {
5138 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5139 auto Ret = Tmp.mod(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
5144 APFloat::opStatus
5147 APFloat::roundingMode RM) {
5149 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5151 APFloat(semPPCDoubleDoubleLegacy, Multiplicand.bitcastToAPInt()),
5152 APFloat(semPPCDoubleDoubleLegacy, Addend.bitcastToAPInt()), RM);
5157 APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
5159 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5170 APFloat::cmpResult
5191 APFloat::fltCategory DoubleAPFloat::getCategory() const {
5209 Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x7fefffffffffffffull));
5210 Floats[1] = APFloat(semIEEEdouble, APInt(64, 0x7c8ffffffffffffeull));
5223 Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x0360000000000000ull));
5234 APFloat::cmpResult DoubleAPFloat::compare(const DoubleAPFloat &RHS) const {
5237 if (Result == APFloat::cmpEqual)
5262 Expected<APFloat::opStatus> DoubleAPFloat::convertFromString(StringRef S,
5265 APFloat Tmp(semPPCDoubleDoubleLegacy);
5271 APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
5273 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5279 APFloat::opStatus
5284 return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
5288 APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
5292 APFloat Tmp(semPPCDoubleDoubleLegacy);
5298 APFloat::opStatus
5303 APFloat Tmp(semPPCDoubleDoubleLegacy);
5309 APFloat::opStatus
5314 APFloat Tmp(semPPCDoubleDoubleLegacy);
5325 return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
5371 APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
5375 bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
5377 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
5380 APFloat Inv(semPPCDoubleDoubleLegacy);
5382 *inv = APFloat(semPPCDoubleDouble, Inv.bitcastToAPInt());
5397 APFloat::roundingMode RM) {
5404 APFloat::roundingMode RM) {
5406 APFloat First = frexp(Arg.Floats[0], Exp, RM);
5407 APFloat Second = Arg.Floats[1];
5408 if (Arg.getCategory() == APFloat::fcNormal)
5415 APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
5423 DoubleAPFloat(Semantics, APFloat(std::move(F), S),
5424 APFloat(semIEEEdouble));
5430 Expected<APFloat::opStatus> APFloat::convertFromString(StringRef Str,
5435 hash_code hash_value(const APFloat &Arg) {
5436 if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
5438 if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
5443 APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
5444 : APFloat(Semantics) {
5450 FPClassTest APFloat::classify() const {
5463 APFloat::opStatus APFloat::convert(const fltSemantics &ToSemantics,
5476 *this = APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
5482 *this = APFloat(std::move(getIEEE()), ToSemantics);
5488 APFloat APFloat::getAllOnesValue(const fltSemantics &Semantics) {
5489 return APFloat(Semantics, APInt::getAllOnes(Semantics.sizeInBits));
5492 void APFloat::print(raw_ostream &OS) const {
5499 LLVM_DUMP_METHOD void APFloat::dump() const {
5505 void APFloat::Profile(FoldingSetNodeID &NID) const {
5513 APFloat::opStatus APFloat::convertToInteger(APSInt &result,
5525 double APFloat::convertToDouble() const {
5530 APFloat Temp = *this;
5539 float128 APFloat::convertToQuad() const {
5544 APFloat Temp = *this;
5553 float APFloat::convertToFloat() const {
5558 APFloat Temp = *this;