From 0d67266b5759f89dbf63b72d4d1172c7a421a4a2 Mon Sep 17 00:00:00 2001 From: Mark Benvenuto Date: Thu, 10 Nov 2022 16:36:34 -0500 Subject: SERVER-69668 FLE2 range float precision: update OSTType algorithm --- buildscripts/lldb/lldb_printers.py | 11 + src/mongo/crypto/SConscript | 1 + src/mongo/crypto/encryption_fields_validation.cpp | 50 +- src/mongo/crypto/encryption_fields_validation.h | 5 + .../crypto/encryption_fields_validation_test.cpp | 74 +++ src/mongo/crypto/fle_crypto.cpp | 273 ++++++-- src/mongo/crypto/fle_crypto.h | 15 +- src/mongo/crypto/fle_crypto_test.cpp | 398 ++++++++++-- src/mongo/crypto/fle_crypto_test_vectors.cpp | 116 +++- src/mongo/crypto/fle_fields_util.cpp | 2 +- .../crypto/test_vectors/edges_decimal128.cstruct | 700 ++++++++++---------- src/mongo/crypto/test_vectors/edges_double.cstruct | 680 ++++++++++---------- .../mincover_decimal128_precision.cstruct | 394 ++++++++++++ .../test_vectors/mincover_double_precision.cstruct | 705 +++++++++++++++++++++ src/mongo/platform/decimal128.cpp | 9 + src/mongo/platform/decimal128.h | 2 + 16 files changed, 2652 insertions(+), 783 deletions(-) create mode 100644 src/mongo/crypto/encryption_fields_validation_test.cpp create mode 100644 src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct create mode 100644 src/mongo/crypto/test_vectors/mincover_double_precision.cstruct diff --git a/buildscripts/lldb/lldb_printers.py b/buildscripts/lldb/lldb_printers.py index 6c0bee9d53b..63dea8ca7f1 100644 --- a/buildscripts/lldb/lldb_printers.py +++ b/buildscripts/lldb/lldb_printers.py @@ -21,6 +21,7 @@ try: import collections from bson import json_util from bson.codec_options import CodecOptions + from bson import Decimal128 except ImportError: print("Warning: Could not load bson library for Python {}.".format(sys.version)) print("Check with the pip command if pymongo 3.x is installed.") @@ -36,6 +37,8 @@ def __lldb_init_module(debugger, *_args): debugger.HandleCommand("type summary add mongo::StatusWith -F lldb_printers.StatusWithPrinter") debugger.HandleCommand("type summary add mongo::StringData -F lldb_printers.StringDataPrinter") debugger.HandleCommand("type summary add mongo::UUID -F lldb_printers.UUIDPrinter") + debugger.HandleCommand("type summary add mongo::Decimal128 -F lldb_printers.Decimal128Printer") + debugger.HandleCommand( "type summary add --summary-string '${var.m_pathname}' 'boost::filesystem::path'") debugger.HandleCommand( @@ -111,6 +114,14 @@ def UUIDPrinter(valobj, *_args): # pylint: disable=invalid-name return str(uuid.UUID("".join(uuid_hex_bytes))) +def Decimal128Printer(valobj, *_args): # pylint: disable=invalid-name + """Print the Decimal128's string value.""" + value = valobj.GetChildMemberWithName("_value") + low64 = value.GetChildMemberWithName("low64").GetValueAsUnsigned() + high64 = value.GetChildMemberWithName("high64").GetValueAsUnsigned() + return Decimal128((high64, low64)) + + class UniquePtrPrinter: """Pretty printer for std::unique_ptr.""" diff --git a/src/mongo/crypto/SConscript b/src/mongo/crypto/SConscript index 9e403911625..facbaa5a689 100644 --- a/src/mongo/crypto/SConscript +++ b/src/mongo/crypto/SConscript @@ -132,6 +132,7 @@ env.CppUnitTest( source=[ 'aead_encryption_test.cpp', 'encryption_fields_util_test.cpp', + 'encryption_fields_validation_test.cpp', 'fle_crypto_test.cpp', 'fle_crypto_test_vectors.cpp', 'mechanism_scram_test.cpp', diff --git a/src/mongo/crypto/encryption_fields_validation.cpp b/src/mongo/crypto/encryption_fields_validation.cpp index b873a7dfdf3..136e51a0fee 100644 --- a/src/mongo/crypto/encryption_fields_validation.cpp +++ b/src/mongo/crypto/encryption_fields_validation.cpp @@ -33,6 +33,7 @@ #include "mongo/crypto/encryption_fields_gen.h" #include "mongo/crypto/encryption_fields_util.h" #include "mongo/db/field_ref.h" +#include namespace mongo { @@ -103,13 +104,41 @@ void validateRangeIndex(BSONType fieldType, QueryTypeConfig& query) { if (!query.getMin().has_value()) { if (fieldType == NumberDouble) { - query.setMin(mongo::Value(std::numeric_limits::min())); + query.setMin(mongo::Value(std::numeric_limits::lowest())); query.setMax(mongo::Value(std::numeric_limits::max())); } else { query.setMin(mongo::Value(Decimal128::kLargestNegative)); query.setMax(mongo::Value(Decimal128::kLargestPositive)); } } + + if (query.getPrecision().has_value()) { + uint32_t precision = query.getPrecision().value(); + if (fieldType == NumberDouble) { + uassert( + 6966805, + "The number of decimal digits for minimum value must be less then or equal " + "to precision", + validateDoublePrecisionRange(query.getMin()->coerceToDouble(), precision)); + uassert( + 6966806, + "The number of decimal digits for maximum value must be less then or equal " + "to precision", + validateDoublePrecisionRange(query.getMax()->coerceToDouble(), precision)); + + } else { + auto minDecimal = query.getMin()->coerceToDecimal(); + uassert(6966807, + "The number of decimal digits for minimum value must be less then or " + "equal to precision", + validateDecimal128PrecisionRange(minDecimal, precision)); + auto maxDecimal = query.getMax()->coerceToDecimal(); + uassert(6966808, + "The number of decimal digits for maximum value must be less then or " + "equal to precision", + validateDecimal128PrecisionRange(maxDecimal, precision)); + } + } } // We want to perform the same validation after sanitizing floating // point parameters, so we call FMT_FALLTHROUGH here. @@ -229,4 +258,23 @@ void validateEncryptedFieldConfig(const EncryptedFieldConfig* config) { fieldPaths.push_back(std::move(newPath)); } } + +bool validateDoublePrecisionRange(double d, uint32_t precision) { + double maybe_integer = d * pow(10.0, precision); + double floor_integer = floor(maybe_integer); + + // We want to prevent users from making mistakes by specifing extra precision in the bounds. + // Since floating point is inaccurate, we need to account for this when testing for equality by + // considering the values almost equal to likely mean the bounds are within the precision range. + auto e = std::numeric_limits::epsilon(); + return fabs(maybe_integer - floor_integer) <= (e * floor_integer); +} + +bool validateDecimal128PrecisionRange(Decimal128& dec, uint32_t precision) { + Decimal128 maybe_integer = dec.scale(precision); + Decimal128 floor_integer = maybe_integer.round(); + + return maybe_integer == floor_integer; +} + } // namespace mongo diff --git a/src/mongo/crypto/encryption_fields_validation.h b/src/mongo/crypto/encryption_fields_validation.h index 26ac2932e77..6735d7b2b1e 100644 --- a/src/mongo/crypto/encryption_fields_validation.h +++ b/src/mongo/crypto/encryption_fields_validation.h @@ -31,6 +31,8 @@ #include "mongo/bson/bsontypes.h" #include "mongo/db/exec/document_value/value.h" +#include "mongo/platform/decimal128.h" + namespace mongo { class EncryptedField; @@ -52,4 +54,7 @@ Value coerceValueToRangeIndexTypes(Value val, BSONType fieldType); void validateEncryptedField(const EncryptedField* field); void validateEncryptedFieldConfig(const EncryptedFieldConfig* config); + +bool validateDoublePrecisionRange(double d, uint32_t precision); +bool validateDecimal128PrecisionRange(Decimal128& dec, uint32_t precision); } // namespace mongo diff --git a/src/mongo/crypto/encryption_fields_validation_test.cpp b/src/mongo/crypto/encryption_fields_validation_test.cpp new file mode 100644 index 00000000000..5ab9b2a432a --- /dev/null +++ b/src/mongo/crypto/encryption_fields_validation_test.cpp @@ -0,0 +1,74 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * . + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/platform/basic.h" + +#include "mongo/crypto/encryption_fields_validation.h" + +#include "mongo/platform/decimal128.h" +#include "mongo/unittest/unittest.h" + +namespace mongo { + + +TEST(FLEValidationUtils, ValidateDoublePrecisionRange) { + + + ASSERT(validateDoublePrecisionRange(3.000, 0)); + ASSERT(validateDoublePrecisionRange(3.000, 1)); + ASSERT(validateDoublePrecisionRange(3.000, 2)); + + ASSERT_FALSE(validateDoublePrecisionRange(3.100, 0)); + ASSERT(validateDoublePrecisionRange(3.100, 1)); + ASSERT(validateDoublePrecisionRange(3.100, 2)); + + ASSERT(validateDoublePrecisionRange(1.000, 3)); + + ASSERT_FALSE(validateDoublePrecisionRange(3.140, 1)); +} + +bool validateDecimal128PrecisionRangeTest(std::string s, uint32_t precision) { + Decimal128 dec(s); + return validateDecimal128PrecisionRange(dec, precision); +} + +TEST(FLEValidationUtils, ValidateDecimalPrecisionRange) { + + ASSERT(validateDecimal128PrecisionRangeTest("3.000", 0)); + ASSERT(validateDecimal128PrecisionRangeTest("3.000", 1)); + ASSERT(validateDecimal128PrecisionRangeTest("3.000", 2)); + + ASSERT_FALSE(validateDecimal128PrecisionRangeTest("3.100", 0)); + ASSERT(validateDecimal128PrecisionRangeTest("3.100", 1)); + ASSERT(validateDecimal128PrecisionRangeTest("3.100", 2)); + + ASSERT_FALSE(validateDecimal128PrecisionRangeTest("3.140", 1)); +} + +} // namespace mongo diff --git a/src/mongo/crypto/fle_crypto.cpp b/src/mongo/crypto/fle_crypto.cpp index 512b61a6ef3..2aa75de066e 100644 --- a/src/mongo/crypto/fle_crypto.cpp +++ b/src/mongo/crypto/fle_crypto.cpp @@ -37,6 +37,7 @@ #include #include #include +#include #include #include #include @@ -83,10 +84,10 @@ // Optional defines to help with debugging // // Appends unencrypted fields to the state collections to aid in debugging -//#define FLE2_DEBUG_STATE_COLLECTIONS +// #define FLE2_DEBUG_STATE_COLLECTIONS // Verbose std::cout to troubleshoot the EmuBinary algorithm -//#define DEBUG_ENUM_BINARY 1 +// #define DEBUG_ENUM_BINARY 1 #ifdef FLE2_DEBUG_STATE_COLLECTIONS static_assert(kDebugBuild == 1, "Only use in debug builds"); @@ -140,6 +141,7 @@ constexpr size_t kHmacKeyOffset = 64; constexpr boost::multiprecision::uint128_t k1(1); constexpr boost::multiprecision::int128_t k10(10); +constexpr boost::multiprecision::uint128_t k10ui(10); #ifdef FLE2_DEBUG_STATE_COLLECTIONS constexpr auto kDebugId = "_debug_id"; @@ -747,19 +749,12 @@ std::unique_ptr getEdges(FLE2RangeInsertSpec spec, int sparsity) { uassert(6775508, "max bound must be double", !maxBound.has_value() || maxBound->type() == BSONType::NumberDouble); - // TODO - SERVER-69667 remove - uassert(7006610, - "unexpected min bound", - !minBound.has_value() || - minBound->numberDouble() == std::numeric_limits::min()); - uassert(7006611, - "unexpected max bound", - !maxBound.has_value() || - maxBound->numberDouble() == std::numeric_limits::max()); - return getEdgesDouble(element.Double(), - minBound.map([](BSONElement m) { return m.Double(); }), - maxBound.map([](BSONElement m) { return m.Double(); }), - sparsity); + return getEdgesDouble( + element.Double(), + minBound.map([](BSONElement m) { return m.Double(); }), + maxBound.map([](BSONElement m) { return m.Double(); }), + spec.getPrecision().map([](std::int32_t m) { return static_cast(m); }), + sparsity); case BSONType::NumberDecimal: uassert(6775509, @@ -768,19 +763,12 @@ std::unique_ptr getEdges(FLE2RangeInsertSpec spec, int sparsity) { uassert(6775510, "max bound must be decimal", !maxBound.has_value() || maxBound->type() == BSONType::NumberDecimal); - // TODO - SERVER-69667 remove - uassert(7006612, - "unexpected min bound", - !minBound.has_value() || - minBound->numberDecimal() == Decimal128::kLargestNegative); - uassert(7006613, - "unexpected max bound", - !maxBound.has_value() || - maxBound->numberDecimal() == Decimal128::kLargestPositive); - return getEdgesDecimal128(element.numberDecimal(), - minBound.map([](BSONElement m) { return m.numberDecimal(); }), - maxBound.map([](BSONElement m) { return m.numberDecimal(); }), - sparsity); + return getEdgesDecimal128( + element.numberDecimal(), + minBound.map([](BSONElement m) { return m.numberDecimal(); }), + maxBound.map([](BSONElement m) { return m.numberDecimal(); }), + spec.getPrecision().map([](std::int32_t m) { return static_cast(m); }), + sparsity); default: uassert(6775500, "must use supported FLE2 range type", false); @@ -1512,6 +1500,14 @@ boost::multiprecision::int128_t exp10(int x) { return pow(k10, x); } +boost::multiprecision::uint128_t exp10ui128(int x) { + return pow(k10ui, x); +} + +double exp10Double(int x) { + return pow(10, x); +} + } // namespace std::vector getMinCover(const FLE2RangeFindSpec& spec, uint8_t sparsity) { @@ -1573,8 +1569,11 @@ std::vector getMinCover(const FLE2RangeFindSpec& spec, uint8_t spar includeLowerBound, upperBound.numberDouble(), includeUpperBound, - indexMin.Double(), - indexMax.Double(), + indexMin.numberDouble(), + indexMax.numberDouble(), + edgesInfo.getPrecision().map( + [](std::int32_t m) { return static_cast(m); }), + sparsity); case NumberDecimal: return minCoverDecimal128(lowerBound.numberDecimal(), @@ -1583,6 +1582,9 @@ std::vector getMinCover(const FLE2RangeFindSpec& spec, uint8_t spar includeUpperBound, indexMin.numberDecimal(), indexMax.numberDecimal(), + edgesInfo.getPrecision().map( + [](std::int32_t m) { return static_cast(m); }), + sparsity); default: // IDL validates that no other type is permitted. @@ -3501,9 +3503,10 @@ OSTType_Int64 getTypeInfo64(int64_t value, OSTType_Double getTypeInfoDouble(double value, boost::optional min, - boost::optional max) { + boost::optional max, + boost::optional precision) { uassert(6775007, - "Must specify both a lower and upper bound or no bounds.", + "Must specify both a lower bound and upper bound or no bounds.", min.has_value() == max.has_value()); uassert(6775008, @@ -3525,6 +3528,70 @@ OSTType_Double getTypeInfoDouble(double value, value = 0; } + // When we use precision mode, we try to represent as a double value that fits in [-2^63, 2^63] + // (i.e. is a valid int64) + // + // This check determines if we can represent the precision truncated value as a 64-bit integer + // I.e. Is ((ub - lb) * 10^precision) < 64 bits. + // + // It is important we determine whether a range and its precision fit without looking that value + // because the encoding for precision truncated doubles is incompatible with the encoding for + // doubles without precision. + // + bool use_precision_mode = false; + uint32_t bits_range; + if (precision.has_value()) { + + // Subnormal representations can support up to 5x10^-324 as a number + uassert(6966801, + "Precision must be between 0 and 324 inclusive", + precision.get() >= 0 && precision.get() <= 324); + + uassert(6966803, + "Must specify both a lower bound, upper bound and precision", + min.has_value() == max.has_value() && max.has_value() == precision.has_value()); + + double range = max.get() - min.get(); + + // We can overflow if max = max double and min = min double so make sure we have finite + // number after we do subtraction + if (std::isfinite(range)) { + + // This creates a range which is wider then we permit by our min/max bounds check with + // the +1 but it is as the algorithm is written in the paper. + double rangeAndPrecision = (range + 1) * exp10Double(precision.get()); + + if (std::isfinite(rangeAndPrecision)) { + + double bits_range_double = log2(rangeAndPrecision); + bits_range = ceil(bits_range_double); + + if (bits_range < 64) { + use_precision_mode = true; + } + } + } + } + + if (use_precision_mode) { + + // Take a number of xxxx.ppppp and truncate it xxxx.ppp if precision = 3. We do not change + // the digits before the decimal place. + double v_prime = trunc(value * exp10Double(precision.get())) / exp10Double(precision.get()); + int64_t v_prime2 = (v_prime - min.get()) * exp10Double(precision.get()); + + invariant(v_prime2 < std::numeric_limits::max() && v_prime2 >= 0); + + uint64_t ret = static_cast(v_prime2); + + // Adjust maximum value to be the max bit range. This will be used by getEdges/minCover to + // trim bits. + uint64_t max_value = (1ULL << bits_range) - 1; + invariant(ret <= max_value); + + return {ret, 0, max_value}; + } + // When we translate the double into "bits", the sign bit means that the negative numbers // get mapped into the higher 63 bits of a 64-bit integer. We want them to map into the lower // 64-bits so we invert the sign bit. @@ -3552,12 +3619,45 @@ OSTType_Double getTypeInfoDouble(double value, return {uv, 0, std::numeric_limits::max()}; } +boost::multiprecision::uint128_t toInt128FromDecimal128(Decimal128 dec) { + // This algorithm only works because it assumes we are dealing with Decimal128 numbers that are + // valid uint128 numbers. This means the Decimal128 has to be an integer or else the result is + // undefined. + invariant(dec.isFinite()); + invariant(!dec.isNegative()); + + // If after rounding, the number has changed, we have a fraction, not an integer. + invariant(dec.round() == dec); + + boost::multiprecision::uint128_t ret(dec.getCoefficientHigh()); + + ret <<= 64; + ret |= dec.getCoefficientLow(); + + auto exponent = static_cast(dec.getBiasedExponent()) - Decimal128::kExponentBias; + + auto e1 = exp10ui128(labs(exponent)); + if (exponent < 0) { + ret /= e1; + } else { + ret *= e1; + } + + // Round-trip our new Int128 back to Decimal128 and make sure it is equal to the original + // Decimal128 or else. + Decimal128 roundTrip(ret.str()); + invariant(roundTrip == dec); + + return ret; +} + // For full algorithm see SERVER-68542 OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value, boost::optional min, - boost::optional max) { + boost::optional max, + boost::optional precision) { uassert(6854201, - "Must specify both a lower and upper bound or no bounds.", + "Must specify both a lower bound and upper bound or no bounds.", min.has_value() == max.has_value()); uassert(6854202, @@ -3575,6 +3675,95 @@ OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value, value >= min.value() && value <= max.value()); } + // When we use precision mode, we try to represent as a decimal128 value that fits in [-2^127, + // 2^127] (i.e. is a valid int128) + // + // This check determines if we can represent the precision truncated value as a 128-bit integer + // I.e. Is ((ub - lb) * 10^precision) < 128 bits. + // + // It is important we determine whether a range and its precision fit without looking that value + // because the encoding for precision truncated decimal128 is incompatible with normal + // decimal128 values. + bool use_precision_mode = false; + int bits_range = 0; + if (precision.has_value()) { + uassert(6966804, + "Must specify both a lower bound, upper bound and precision", + min.has_value() == max.has_value() && max.has_value() == precision.has_value()); + + uassert(6966802, + "Precision must be between 0 and 6182 inclusive", + precision.get() >= 0 && precision.get() <= 6142); + + + Decimal128 bounds = max.get().subtract(min.get()).add(Decimal128(1)); + + if (bounds.isFinite()) { + Decimal128 bits_range_dec = bounds.scale(precision.get()).logarithm(Decimal128(2)); + + if (bits_range_dec.isFinite() && bits_range_dec < Decimal128(128)) { + // kRoundTowardPositive is the same as C99 ceil() + + bits_range = bits_range_dec.toIntExact(Decimal128::kRoundTowardPositive); + + if (bits_range < 128) { + use_precision_mode = true; + } + } + } + } + + if (use_precision_mode) { + // Example value: 31.4159 + // Example Precision = 2 + + // Shift the number up + // Returns: 3141.9 + Decimal128 valueScaled = value.scale(precision.get()); + + // Round the number down + // Returns 3141.0 + Decimal128 valueTruncated = valueScaled.round(Decimal128::kRoundTowardZero); + + // Shift the number down + // Returns: 31.41 + Decimal128 v_prime = valueTruncated.scale(-static_cast(precision.get())); + + // Adjust the number by the lower bound + // Make it an integer by scaling the number + // + // Returns 3141.0 + Decimal128 v_prime2 = v_prime.subtract(min.get()).scale(precision.get()); + + invariant(v_prime2.logarithm(Decimal128(2)).isLess(Decimal128(128))); + + // Now we need to get the Decimal128 out as a 128-bit integer + // But Decimal128 does not support conversion to Int128. + // + // If we think the Decimal128 fits in the range, based on the maximum value, we try to + // convert to int64 directly. + if (bits_range < 64) { + + // Try conversion to int64, it may fail but since it is easy we try this first. + // + uint32_t signalingFlags = Decimal128::SignalingFlag::kNoFlag; + + std::int64_t vPrimeInt264 = v_prime2.toLongExact(&signalingFlags); + + if (signalingFlags == Decimal128::SignalingFlag::kNoFlag) { + std::uint64_t vPrimeUInt264 = static_cast(vPrimeInt264); + return {vPrimeUInt264, 0, (1ULL << bits_range) - 1}; + } + } + + boost::multiprecision::uint128_t u_ret = toInt128FromDecimal128(v_prime2); + + boost::multiprecision::uint128_t max_dec = + (boost::multiprecision::uint128_t(1) << bits_range) - 1; + + return {u_ret, 0, max_dec}; + } + bool isNegative = value.isNegative(); int32_t scale = value.getBiasedExponent() - Decimal128::kExponentBias; int64_t highCoefficent = value.getCoefficientHigh(); @@ -3743,16 +3932,18 @@ std::unique_ptr getEdgesInt64(int64_t value, std::unique_ptr getEdgesDouble(double value, boost::optional min, boost::optional max, + boost::optional precision, int sparsity) { - auto aost = getTypeInfoDouble(value, min, max); + auto aost = getTypeInfoDouble(value, min, max, precision); return getEdgesT(aost.value, aost.min, aost.max, sparsity); } std::unique_ptr getEdgesDecimal128(Decimal128 value, boost::optional min, boost::optional max, + boost::optional precision, int sparsity) { - auto aost = getTypeInfoDecimal128(value, min, max); + auto aost = getTypeInfoDecimal128(value, min, max, precision); return getEdgesT(aost.value, aost.min, aost.max, sparsity); } @@ -3919,9 +4110,10 @@ std::vector minCoverDouble(double lowerBound, bool includeUpperBound, boost::optional min, boost::optional max, + boost::optional precision, int sparsity) { - auto a = getTypeInfoDouble(lowerBound, min, max); - auto b = getTypeInfoDouble(upperBound, min, max); + auto a = getTypeInfoDouble(lowerBound, min, max, precision); + auto b = getTypeInfoDouble(upperBound, min, max, precision); dassert(a.min == b.min); dassert(a.max == b.max); adjustBounds(a, includeLowerBound, b, includeUpperBound); @@ -3936,9 +4128,10 @@ std::vector minCoverDecimal128(Decimal128 lowerBound, bool includeUpperBound, boost::optional min, boost::optional max, + boost::optional precision, int sparsity) { - auto a = getTypeInfoDecimal128(lowerBound, min, max); - auto b = getTypeInfoDecimal128(upperBound, min, max); + auto a = getTypeInfoDecimal128(lowerBound, min, max, precision); + auto b = getTypeInfoDecimal128(upperBound, min, max, precision); dassert(a.min == b.min); dassert(a.max == b.max); adjustBounds(a, includeLowerBound, b, includeUpperBound); diff --git a/src/mongo/crypto/fle_crypto.h b/src/mongo/crypto/fle_crypto.h index 298092c8bec..6c0bb59095f 100644 --- a/src/mongo/crypto/fle_crypto.h +++ b/src/mongo/crypto/fle_crypto.h @@ -1141,7 +1141,8 @@ struct OSTType_Double { OSTType_Double getTypeInfoDouble(double value, boost::optional min, - boost::optional max); + boost::optional max, + boost::optional precision); /** * Describe the encoding of an BSON Decimal (i.e. IEEE 754 Decimal128) * @@ -1159,9 +1160,13 @@ struct OSTType_Decimal128 { boost::multiprecision::uint128_t max; }; +boost::multiprecision::uint128_t toInt128FromDecimal128(Decimal128 dec); + OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value, boost::optional min, - boost::optional max); + boost::optional max, + boost::optional precision); + struct FLEFindEdgeTokenSet { EDCDerivedFromDataToken edc; @@ -1216,11 +1221,14 @@ std::unique_ptr getEdgesInt64(int64_t value, std::unique_ptr getEdgesDouble(double value, boost::optional min, boost::optional max, + boost::optional precision, int sparsity); std::unique_ptr getEdgesDecimal128(Decimal128 value, boost::optional min, boost::optional max, + boost::optional precision, + int sparsity); /** * Mincover calculator @@ -1248,6 +1256,7 @@ std::vector minCoverDouble(double lowerBound, bool includeUpperBound, boost::optional min, boost::optional max, + boost::optional precision, int sparsity); std::vector minCoverDecimal128(Decimal128 lowerBound, @@ -1256,6 +1265,8 @@ std::vector minCoverDecimal128(Decimal128 lowerBound, bool includeUpperBound, boost::optional min, boost::optional max, + boost::optional precision, + int sparsity); /** * Utility functions manipulating buffers. diff --git a/src/mongo/crypto/fle_crypto_test.cpp b/src/mongo/crypto/fle_crypto_test.cpp index 652e56dab2f..e7dc119953e 100644 --- a/src/mongo/crypto/fle_crypto_test.cpp +++ b/src/mongo/crypto/fle_crypto_test.cpp @@ -32,6 +32,7 @@ #include "mongo/crypto/fle_crypto.h" #include +#include #include #include #include @@ -2354,9 +2355,9 @@ TEST(RangeTest, Int64_Errors) { ASSERT_THROWS_CODE(getTypeInfo64(4, LLONG_MIN, LLONG_MIN), AssertionException, 6775005); } - TEST(RangeTest, Double_Bounds) { -#define ASSERT_EIB(x, z) ASSERT_EQ(getTypeInfoDouble((x), -1E100, 1E100).value, (z)); +#define ASSERT_EIB(x, z) \ + ASSERT_EQ(getTypeInfoDouble((x), boost::none, boost::none, boost::none).value, (z)); // Larger numbers map to larger uint64 ASSERT_EIB(-1111, 4570770991734587392ULL); @@ -2403,24 +2404,99 @@ TEST(RangeTest, Double_Bounds) { #undef ASSERT_EIB } +TEST(RangeTest, Double_Bounds_Precision) { +#define ASSERT_EIBP(x, y, z) ASSERT_EQ(getTypeInfoDouble((x), -100000, 100000, y).value, (z)); + + ASSERT_EIBP(3.141592653589, 1, 1000031); + ASSERT_EIBP(3.141592653589, 2, 10000314); + ASSERT_EIBP(3.141592653589, 3, 100003141); + ASSERT_EIBP(3.141592653589, 4, 1000031415); + ASSERT_EIBP(3.141592653589, 5, 10000314159); + ASSERT_EIBP(3.141592653589, 6, 100003141592); + ASSERT_EIBP(3.141592653589, 7, 1000031415926); +#undef ASSERT_EIBP + + +#define ASSERT_EIBB(v, ub, lb, prc, z) \ + { \ + auto _ost = getTypeInfoDouble((v), lb, ub, prc); \ + ASSERT_NE(_ost.max, 18446744073709551615ULL); \ + ASSERT_EQ(_ost.value, z); \ + } +#define ASSERT_EIBB_OVERFLOW(v, ub, lb, prc, z) \ + { \ + auto _ost = getTypeInfoDouble((v), lb, ub, prc); \ + ASSERT_EQ(_ost.max, 18446744073709551615ULL); \ + ASSERT_EQ(_ost.value, z); \ + } + + ASSERT_EIBB(0, 1, -1, 3, 1000); + ASSERT_EIBB(0, 1, -1E5, 3, 100000000); + + ASSERT_EIBB(-1E-33, 1, -1E5, 3, 100000000); + + ASSERT_EIBB_OVERFLOW(0, + std::numeric_limits::max(), + std::numeric_limits::lowest(), + 3, + 9223372036854775808ULL); + + ASSERT_EIBB(3.141592653589, 5, 0, 0, 3); + ASSERT_EIBB(3.141592653589, 5, 0, 1, 31); + + ASSERT_EIBB(3.141592653589, 5, 0, 2, 314); + + ASSERT_EIBB(3.141592653589, 5, 0, 3, 3141); + ASSERT_EIBB(3.141592653589, 5, 0, 16, 31415926535890000); + + + ASSERT_EIBB(-5, -1, -10, 3, 5000); -TEST(RangeTest, Double_Errors) { - ASSERT_THROWS_CODE(getTypeInfoDouble(1, boost::none, 2), AssertionException, 6775007); - ASSERT_THROWS_CODE(getTypeInfoDouble(1, 0, boost::none), AssertionException, 6775007); - ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 1), AssertionException, 6775009); + ASSERT_EIBB_OVERFLOW(1E100, + std::numeric_limits::max(), + std::numeric_limits::lowest(), + 3, + 15326393489903895421ULL); - ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 3), AssertionException, 6775010); - ASSERT_THROWS_CODE(getTypeInfoDouble(4, 2, 3), AssertionException, 6775010); + ASSERT_EIBB(1E9, 1E10, 0, 3, 1000000000000); + ASSERT_EIBB(1E9, 1E10, 0, 0, 1000000000); - ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::infinity(), 1, 2), + ASSERT_EIBB(-5, 10, -10, 0, 5); + ASSERT_EIBB(-5, 10, -10, 2, 500); + + ASSERT_EIBB_OVERFLOW(1E-30, 10E-30, 1E-30, 35, 13381399884061196960ULL); + +#undef ASSERT_EIBB +#undef ASSERT_EIBB_OVERFLOW +} + +TEST(RangeTest, Double_Bounds_Precision_Errors) { + + ASSERT_THROWS_CODE( + getTypeInfoDouble(1, boost::none, boost::none, 1), AssertionException, 6966803); + + ASSERT_THROWS_CODE(getTypeInfoDouble(1, 1, 2, -1), AssertionException, 6966801); + ASSERT_THROWS_CODE(getTypeInfoDouble(1, 1, 2, 325), AssertionException, 6966801); +} + +TEST(RangeTest, Double_Errors) { + ASSERT_THROWS_CODE(getTypeInfoDouble(1, boost::none, 2, 5), AssertionException, 6775007); + ASSERT_THROWS_CODE(getTypeInfoDouble(1, 0, boost::none, 5), AssertionException, 6775007); + ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 1, 5), AssertionException, 6775009); + + ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 3, 5), AssertionException, 6775010); + ASSERT_THROWS_CODE(getTypeInfoDouble(4, 2, 3, 5), AssertionException, 6775010); + + + ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::infinity(), 1, 2, 5), AssertionException, 6775008); - ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::quiet_NaN(), 1, 2), + ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::quiet_NaN(), 1, 2, 5), AssertionException, 6775008); - ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::signaling_NaN(), 1, 2), + ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits::signaling_NaN(), 1, 2, 5), AssertionException, 6775008); } @@ -2431,24 +2507,25 @@ TEST(EdgeCalcTest, SparsityConstraints) { ASSERT_THROWS_CODE(getEdgesInt32(1, 0, 8, -1), AssertionException, 6775101); ASSERT_THROWS_CODE(getEdgesInt64(1, 0, 8, 0), AssertionException, 6775101); ASSERT_THROWS_CODE(getEdgesInt64(1, 0, 8, -1), AssertionException, 6775101); - ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 0), AssertionException, 6775101); - ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, -1), AssertionException, 6775101); + ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 5, 0), AssertionException, 6775101); + ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 5, -1), AssertionException, 6775101); } TEST(MinCoverCalcTest, MinCoverConstraints) { ASSERT(minCoverInt32(2, true, 1, true, 0, 7, 1).empty()); ASSERT(minCoverInt64(2, true, 1, true, 0, 7, 1).empty()); - ASSERT(minCoverDouble(2, true, 1, 0, true, 7, 1).empty()); + ASSERT(minCoverDouble(2, true, 1, true, 0, 7, boost::none, 1).empty()); ASSERT(minCoverDecimal128( - Decimal128(2), true, Decimal128(1), true, Decimal128(0), Decimal128(7), 1) + Decimal128(2), true, Decimal128(1), true, Decimal128(0), Decimal128(7), 5, 1) .empty()); } -TEST(RangeTest, Decimal1238_Bounds) { -#define ASSERT_EIB(x, z) \ - ASSERT_EQ(boost::multiprecision::to_string( \ - getTypeInfoDecimal128(Decimal128(x), boost::none, boost::none).value), \ - (z)); +TEST(RangeTest, Decimal128_Bounds) { +#define ASSERT_EIB(x, z) \ + ASSERT_EQ( \ + boost::multiprecision::to_string( \ + getTypeInfoDecimal128(Decimal128(x), boost::none, boost::none, boost::none).value), \ + (z)); // Larger numbers map tw larger uint64 ASSERT_EIB(-1234567890E7, "108549948892579231731687303715884111887"); @@ -2531,42 +2608,200 @@ TEST(RangeTest, Decimal1238_Bounds) { #undef ASSERT_EIB } -TEST(RangeTest, Decimal1238_Errors) { - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, Decimal128(2)), + +TEST(RangeTest, Decimal128_Bounds_Precision) { + +#define ASSERT_EIBP(x, y, z) \ + ASSERT_EQ( \ + getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128(100000), y).value, \ + (z)); + + ASSERT_EIBP("3.141592653589E-1", 10, 1000003141592653); + ASSERT_EIBP("31.41592653589E-2", 10, 1000003141592653); + ASSERT_EIBP("314.1592653589E-3", 10, 1000003141592653); + ASSERT_EIBP("3141.592653589E-4", 10, 1000003141592653); + ASSERT_EIBP("31415.92653589E-5", 10, 1000003141592653); + ASSERT_EIBP("314159.2653589E-6", 10, 1000003141592653); + ASSERT_EIBP("3141592.653589E-7", 10, 1000003141592653); + ASSERT_EIBP("31415926.53589E-8", 10, 1000003141592653); + +#undef ASSERT_EIBP + +#define ASSERT_EIBPL(x, y, z) \ + ASSERT_EQ( \ + getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128("1E22"), y).value, \ + boost::multiprecision::uint128_t(z)); + + ASSERT_EIBPL("3.1415926535897932384626433832795E20", 5, "31415926535897942384626433"); + ASSERT_EIBPL("3.1415926535897932384626433832795E20", 6, "314159265358979423846264338"); + + ASSERT_EIBPL("3.1415926535897932384626433832795E20", 7, "3141592653589794238462643383"); + + ASSERT_EIBPL("3.1415926535897932384626433832795E20", 8, "31415926535897942384626433832"); + +#undef ASSERT_EIBP + +#define ASSERT_EIBP(x, y, z) \ + ASSERT_EQ( \ + getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128(100000), y).value, \ + (z)); + + ASSERT_EIBP(3.141592653589, 1, 1000031); + ASSERT_EIBP(3.141592653589, 2, 10000314); + ASSERT_EIBP(3.141592653589, 3, 100003141); + ASSERT_EIBP(3.141592653589, 4, 1000031415); + ASSERT_EIBP(3.141592653589, 5, 10000314159); + ASSERT_EIBP(3.141592653589, 6, 100003141592); + ASSERT_EIBP(3.141592653589, 7, 1000031415926); +#undef ASSERT_EIBP + + +#define ASSERT_EIBB(v, ub, lb, prc, z) \ + { \ + auto _ost = getTypeInfoDecimal128(Decimal128(v), Decimal128(lb), Decimal128(ub), prc); \ + ASSERT_NE(_ost.max.str(), "340282366920938463463374607431768211455"); \ + ASSERT_EQ(_ost.value, z); \ + } + +#define ASSERT_EIBB_OVERFLOW(v, ub, lb, prc, z) \ + { \ + auto _ost = getTypeInfoDecimal128(Decimal128(v), Decimal128(lb), Decimal128(ub), prc); \ + ASSERT_EQ(_ost.max.str(), "340282366920938463463374607431768211455"); \ + ASSERT_EQ(_ost.value, z); \ + } + + ASSERT_EIBB(0, 1, -1, 3, 1000); + ASSERT_EIBB(0, 1, -1E5, 3, 100000000); + + ASSERT_EIBB(-1E-33, 1, -1E5, 3, 100000000); + + ASSERT_EIBB_OVERFLOW( + 0, + Decimal128::kLargestPositive, + Decimal128::kLargestNegative, + 3, + boost::multiprecision::uint128_t("170141183460469231731687303715884105728")); + ASSERT_EIBB_OVERFLOW( + 0, + std::numeric_limits::max(), + std::numeric_limits::lowest(), + 3, + boost::multiprecision::uint128_t("170141183460469231731687303715884105728")); + + ASSERT_EIBB(3.141592653589, 5, 0, 0, 3); + ASSERT_EIBB(3.141592653589, 5, 0, 1, 31); + + ASSERT_EIBB(3.141592653589, 5, 0, 2, 314); + + ASSERT_EIBB(3.141592653589, 5, 0, 3, 3141); + ASSERT_EIBB(3.141592653589, 5, 0, 16, 31415926535890000); + + + ASSERT_EIBB(-5, -1, -10, 3, 5000); + + + ASSERT_EIBB_OVERFLOW( + 1E100, + std::numeric_limits::max(), + std::numeric_limits::lowest(), + 3, + boost::multiprecision::uint128_t("232572183460469231731687303715884099485")); + + ASSERT_EIBB(1E9, 1E10, 0, 3, 1000000000000); + ASSERT_EIBB(1E9, 1E10, 0, 0, 1000000000); + + + ASSERT_EIBB(-5, 10, -10, 0, 5); + ASSERT_EIBB(-5, 10, -10, 2, 500); + + + ASSERT_EIBB(5E-30, 10E-30, 1E-30, 35, boost::multiprecision::uint128_t("400000")); + +#undef ASSERT_EIBB +#undef ASSERT_EIBB_OVERFLOW +} + +TEST(RangeTest, Decimal128_Errors) { + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, Decimal128(2), 5), AssertionException, 6854201); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(0), boost::none), + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(0), boost::none, 5), AssertionException, 6854201); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(1)), + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(1), 5), AssertionException, 6854203); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(3)), + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(3), 5), AssertionException, 6854204); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(4), Decimal128(2), Decimal128(3)), + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(4), Decimal128(2), Decimal128(3), 5), AssertionException, 6854204); ASSERT_THROWS_CODE( - getTypeInfoDecimal128(Decimal128::kPositiveInfinity, boost::none, boost::none), + getTypeInfoDecimal128(Decimal128::kPositiveInfinity, boost::none, boost::none, boost::none), + AssertionException, + 6854202); + ASSERT_THROWS_CODE( + getTypeInfoDecimal128(Decimal128::kNegativeInfinity, boost::none, boost::none, boost::none), AssertionException, 6854202); + ASSERT_THROWS_CODE( - getTypeInfoDecimal128(Decimal128::kNegativeInfinity, boost::none, boost::none), + getTypeInfoDecimal128(Decimal128::kPositiveNaN, boost::none, boost::none, boost::none), AssertionException, 6854202); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128::kPositiveNaN, boost::none, boost::none), + ASSERT_THROWS_CODE( + getTypeInfoDecimal128(Decimal128::kNegativeNaN, boost::none, boost::none, boost::none), + AssertionException, + 6854202); +} + + +TEST(RangeTest, Decimal128_Bounds_Precision_Errors) { + + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, boost::none, 1), AssertionException, - 6854202); + 6966804); - ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128::kNegativeNaN, boost::none, boost::none), + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(1), Decimal128(2), -1), AssertionException, - 6854202); + 6966802); + + ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(1), Decimal128(2), 6143), + AssertionException, + 6966802); +} + +void roundTripDecimal128_Int128(std::string dec_str) { + Decimal128 dec(dec_str); + + auto ret = toInt128FromDecimal128(dec); + + Decimal128 roundTrip(ret.str()); + ASSERT(roundTrip == dec); +} + +TEST(RangeTest, Decimal128_to_Int128) { + roundTripDecimal128_Int128("0"); + roundTripDecimal128_Int128("123"); + roundTripDecimal128_Int128("40000000"); + roundTripDecimal128_Int128("40000000.00"); + roundTripDecimal128_Int128("40000000.00000"); + roundTripDecimal128_Int128("40000000.000000000000"); + + roundTripDecimal128_Int128("40000.000E5"); + roundTripDecimal128_Int128("40000000E10"); + roundTripDecimal128_Int128("40000.000E10"); + roundTripDecimal128_Int128("40000000E20"); + roundTripDecimal128_Int128("40000.000E20"); + roundTripDecimal128_Int128("40000000E30"); + roundTripDecimal128_Int128("40000.000E30"); + roundTripDecimal128_Int128("4E37"); } // Tests to make sure that the getMinCover() interface properly calculates the mincover when given a @@ -2608,6 +2843,44 @@ void assertMinCoverResult(A lb, } } +template +void assertMinCoverResultPrecision(A lb, + bool lbIncluded, + B ub, + bool ubIncluded, + C min, + D max, + int sparsity, + int precision, + std::initializer_list expectedList) { + std::vector expected{expectedList}; + std::vector elems; + auto vals = BSON_ARRAY(lb << ub << min << max); + vals.elems(elems); + + FLE2RangeFindSpecEdgesInfo edgesInfo; + + edgesInfo.setLowerBound(elems[0]); + edgesInfo.setLbIncluded(lbIncluded); + edgesInfo.setUpperBound(elems[1]); + edgesInfo.setUbIncluded(ubIncluded); + edgesInfo.setIndexMin(elems[2]); + edgesInfo.setIndexMax(elems[3]); + edgesInfo.setPrecision(precision); + + FLE2RangeFindSpec spec; + spec.setEdgesInfo(edgesInfo); + + spec.setFirstOperator(Fle2RangeOperator::kGt); + spec.setPayloadId(1234); + + auto result = getMinCover(spec, sparsity); + ASSERT_EQ(result.size(), expected.size()); + for (size_t i = 0; i < result.size(); i++) { + ASSERT_EQ(result[i], expected[i]) << spec.toBSON(); + } +} + TEST(MinCoverInterfaceTest, Int32_Basic) { assertMinCoverResult(7, true, 32, true, 0, 32, 1, {"000111", "001", "01", "100000"}); assertMinCoverResult(7, false, 32, false, 0, 32, 1, {"001", "01"}); @@ -3466,35 +3739,41 @@ TEST(MinCoverInterfaceTest, Decimal_Basic) { } TEST(MinCoverInterfaceTest, InfiniteRangeBounds) { - assertMinCoverResult(7, + assertMinCoverResult(7.0, true, std::numeric_limits::infinity(), true, - 0, - 32, + 0.0, + 32.0, 1, - {"000111", "001", "01", "100000"}); - assertMinCoverResult(0, + { + "11000000000111", + "11000000001", + "1100000001000000000000000000000000000000000000000000000000000000", + }); + assertMinCoverResult(0.0, true, - 8, + 8.0, true, - 0, - 32, + 0.0, + 32.0, 1, { - "000", - "001000", + "10", + "11000000000", + "1100000000100000000000000000000000000000000000000000000000000000", }); assertMinCoverResult(-std::numeric_limits::infinity(), true, - 8, + 8.0, true, - 0, - 32, + 0.0, + 32.0, 1, { - "000", - "001000", + "10", + "11000000000", + "1100000000100000000000000000000000000000000000000000000000000000", }); } @@ -3513,6 +3792,31 @@ TEST(MinCoverInteraceTest, InvalidBounds) { assertMinCoverResult(0, true, 0, false, 0, 7, 1, {}), AssertionException, 6901317); } +// Test point queries and that trimming bitstrings is correct in precision mode +TEST(MinCoverInteraceTest, Precision_Equal) { + assertMinCoverResultPrecision(3.14159, true, 3.14159, true, 0.0, 10.0, 1, 2, {"00100111010"}); + assertMinCoverResultPrecision(Decimal128(3.14159), + true, + Decimal128(3.14159), + true, + Decimal128(0.0), + Decimal128(10.0), + 1, + 2, + {"00100111010"}); + + assertMinCoverResultPrecision(3.1, true, 3.1, true, 0.0, 12.0, 1, 1, {"00011111"}); + assertMinCoverResultPrecision(Decimal128(3.1), + true, + Decimal128(3.1), + true, + Decimal128(0.0), + Decimal128(12.0), + 1, + 1, + {"00011111"}); +} + DEATH_TEST_REGEX(MinCoverInterfaceTest, Error_MinMaxTypeMismatch, "Tripwire assertion.*6901300") { std::vector elems; auto vals = BSON_ARRAY(10 << 11 << 4 << 11.5); diff --git a/src/mongo/crypto/fle_crypto_test_vectors.cpp b/src/mongo/crypto/fle_crypto_test_vectors.cpp index ce05c8ab97a..448da457457 100644 --- a/src/mongo/crypto/fle_crypto_test_vectors.cpp +++ b/src/mongo/crypto/fle_crypto_test_vectors.cpp @@ -138,6 +138,14 @@ TEST(EdgeCalcTest, Int64_TestVectors) { } } +std::unique_ptr getEdgesDoubleForTest(double value, + boost::optional min, + boost::optional max, + int sparsity) { + // The non-precision test vectors set min/max which is not allowed + return getEdgesDouble(value, boost::none, boost::none, boost::none, sparsity); +} + TEST(EdgeCalcTest, Double_TestVectors) { std::vector> testVectors = { #include "test_vectors/edges_double.cstruct" @@ -148,6 +156,16 @@ TEST(EdgeCalcTest, Double_TestVectors) { } +std::unique_ptr getEdgesDecimal128ForTest(Decimal128 value, + boost::optional min, + boost::optional max, + int sparsity) { + + // The non-precision test vectors set min/max which is not allowed + return getEdgesDecimal128(value, boost::none, boost::none, boost::none, sparsity); +} + + TEST(EdgeCalcTest, Decimal128_TestVectors) { std::vector> testVectors = { #include "test_vectors/edges_decimal128.cstruct" @@ -213,24 +231,118 @@ TEST(MinCoverCalcTest, Int64_TestVectors) { } } +std::vector minCoverDoubleForTest(double lowerBound, + bool includeLowerBound, + double upperBound, + bool includeUpperBound, + boost::optional min, + boost::optional max, + int sparsity) { + // The non-precision test vectors set min/max which is not allowed + return minCoverDouble(lowerBound, + includeLowerBound, + upperBound, + includeUpperBound, + boost::none, + boost::none, + boost::none, + sparsity); +} + TEST(MinCoverCalcTest, Double_TestVectors) { MinCoverTestVector testVectors[] = { #include "test_vectors/mincover_double.cstruct" }; for (const auto& testVector : testVectors) { - ASSERT_TRUE(testVector.validate(minCoverDouble)); + ASSERT_TRUE(testVector.validate(minCoverDoubleForTest)); } } +std::vector minCoverDecimal128ForTest(Decimal128 lowerBound, + bool includeLowerBound, + Decimal128 upperBound, + bool includeUpperBound, + boost::optional min, + boost::optional max, + int sparsity) { + + // The non-precision test vectors set min/max which is not allowed + return minCoverDecimal128(lowerBound, + includeLowerBound, + upperBound, + includeUpperBound, + boost::none, + boost::none, + boost::none, + sparsity); +} + + TEST(MinCoverCalcTest, Decimal128_TestVectors) { MinCoverTestVector testVectors[] = { #include "test_vectors/mincover_decimal128.cstruct" }; for (const auto& testVector : testVectors) { - ASSERT_TRUE(testVector.validate(minCoverDecimal128)); + ASSERT_TRUE(testVector.validate(minCoverDecimal128ForTest)); } } #pragma clang optimize on + +template +struct MinCoverTestVectorPrecision { + T rangeMin, rangeMax; + T min, max; + int sparsity; + uint32_t precision; + std::string expect; + + bool validate( + std::function( + T, bool, T, bool, boost::optional, boost::optional, uint32_t, int)> algo) const { + auto result = algo(rangeMin, true, rangeMax, true, min, max, precision, sparsity); + + std::stringstream ss(expect); + std::vector vexpect; + std::string item; + while (std::getline(ss, item, '\n') && !item.empty()) { + vexpect.push_back(std::move(item)); + } + + if (std::equal(result.begin(), result.end(), vexpect.begin())) { + return true; + } + + LOGV2_ERROR(6966809, + "MinCover algorithm produced unexpected result", + "rangeMin"_attr = rangeMin, + "rangeMax"_attr = rangeMax, + "min"_attr = min, + "max"_attr = max, + "sparsity"_attr = sparsity, + "precision"_attr = precision, + "expect"_attr = expect, + "got"_attr = result); + return false; + } +}; + +TEST(MinCoverCalcPrecisionTest, Double_TestVectors) { + MinCoverTestVectorPrecision testVectors[] = { +#include "test_vectors/mincover_double_precision.cstruct" + }; + for (const auto& testVector : testVectors) { + ASSERT_TRUE(testVector.validate(minCoverDouble)); + } +} + +TEST(MinCoverCalcPrecisionTest, Decimal128_TestVectors) { + MinCoverTestVectorPrecision testVectors[] = { +#include "test_vectors/mincover_decimal128_precision.cstruct" + }; + for (const auto& testVector : testVectors) { + ASSERT_TRUE(testVector.validate(minCoverDecimal128)); + } +} } // namespace mongo diff --git a/src/mongo/crypto/fle_fields_util.cpp b/src/mongo/crypto/fle_fields_util.cpp index 02653266b8a..94e6f107ef0 100644 --- a/src/mongo/crypto/fle_fields_util.cpp +++ b/src/mongo/crypto/fle_fields_util.cpp @@ -156,5 +156,5 @@ void validateIDLFLE2RangeFindSpec(const FLE2RangeFindSpec* placeholder) { auto lb = edgesInfo.getLowerBound().getElement(); auto ub = edgesInfo.getUpperBound().getElement(); validateQueryBounds(min.type(), lb, ub); -} // namespace mongo +} } // namespace mongo diff --git a/src/mongo/crypto/test_vectors/edges_decimal128.cstruct b/src/mongo/crypto/test_vectors/edges_decimal128.cstruct index a7d8130eaff..46d99cc33da 100644 --- a/src/mongo/crypto/test_vectors/edges_decimal128.cstruct +++ b/src/mongo/crypto/test_vectors/edges_decimal128.cstruct @@ -1,4 +1,4 @@ - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 1, { "1", "10", "100", @@ -129,7 +129,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 2, { "10", "1000", "100000", @@ -196,7 +196,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 3, { "100", "100000", "100000000", @@ -242,7 +242,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 4, { "1000", "10000000", "100000000000", @@ -277,7 +277,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -296,7 +296,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -312,7 +312,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -327,7 +327,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -338,7 +338,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -346,14 +346,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, { "1", "10", "100", @@ -484,7 +484,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, { "10", "1000", "100000", @@ -551,7 +551,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, { "100", "100000", "100000000", @@ -597,7 +597,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, { "1000", "10000000", "100000000000", @@ -632,7 +632,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -651,7 +651,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -667,7 +667,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -682,7 +682,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -693,7 +693,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -701,14 +701,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { "1", "10", "100", @@ -839,7 +839,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { "10", "1000", "100000", @@ -906,7 +906,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { "100", "100000", "100000000", @@ -952,7 +952,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { "1000", "10000000", "100000000000", @@ -987,7 +987,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -1006,7 +1006,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -1022,7 +1022,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -1037,7 +1037,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -1048,7 +1048,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -1056,14 +1056,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 1, { "1", "10", "100", @@ -1194,7 +1194,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 2, { "10", "1000", "100000", @@ -1261,7 +1261,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 3, { "100", "100000", "100000000", @@ -1307,7 +1307,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 4, { "1000", "10000000", "100000000000", @@ -1342,7 +1342,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -1361,7 +1361,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -1377,7 +1377,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -1392,7 +1392,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -1403,7 +1403,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -1411,14 +1411,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { "1", "10", "100", @@ -1549,7 +1549,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { "10", "1000", "100000", @@ -1616,7 +1616,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { "100", "100000", "100000000", @@ -1662,7 +1662,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { "1000", "10000000", "100000000000", @@ -1697,7 +1697,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -1716,7 +1716,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -1732,7 +1732,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -1747,7 +1747,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -1758,7 +1758,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -1766,14 +1766,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { "1", "10", "100", @@ -1904,7 +1904,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { "10", "1000", "100000", @@ -1971,7 +1971,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { "100", "100000", "100000000", @@ -2017,7 +2017,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { "1000", "10000000", "100000000000", @@ -2052,7 +2052,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -2071,7 +2071,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -2087,7 +2087,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -2102,7 +2102,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -2113,7 +2113,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -2121,14 +2121,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, { "1", "10", "100", @@ -2259,7 +2259,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -2326,7 +2326,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -2372,7 +2372,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, { "1000", "10000000", "100000000000", @@ -2407,7 +2407,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -2426,7 +2426,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -2442,7 +2442,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -2457,7 +2457,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -2468,7 +2468,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -2476,14 +2476,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, { "1", "10", "100", @@ -2614,7 +2614,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -2681,7 +2681,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -2727,7 +2727,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, { "1000", "10000000", "100000000000", @@ -2762,7 +2762,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -2781,7 +2781,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -2797,7 +2797,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -2812,7 +2812,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -2823,7 +2823,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -2831,14 +2831,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, { "1", "10", "100", @@ -2969,7 +2969,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -3036,7 +3036,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -3082,7 +3082,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, { "1000", "10000000", "100000000000", @@ -3117,7 +3117,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -3136,7 +3136,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -3152,7 +3152,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -3167,7 +3167,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", @@ -3178,7 +3178,7 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", @@ -3186,14 +3186,14 @@ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, { "0", "01", "010", @@ -3324,7 +3324,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, { "01", "0101", "010100", @@ -3391,7 +3391,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, { "010", "010100", "010100011", @@ -3437,7 +3437,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, { "0101", "01010001", "010100011100", @@ -3472,7 +3472,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -3491,7 +3491,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -3507,7 +3507,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -3522,7 +3522,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -3533,7 +3533,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -3541,14 +3541,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { "0", "01", "010", @@ -3679,7 +3679,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { "01", "0101", "010100", @@ -3746,7 +3746,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { "010", "010100", "010100011", @@ -3792,7 +3792,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { "0101", "01010001", "010100011100", @@ -3827,7 +3827,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -3846,7 +3846,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -3862,7 +3862,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -3877,7 +3877,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -3888,7 +3888,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -3896,14 +3896,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { "0", "01", "010", @@ -4034,7 +4034,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { "01", "0101", "010100", @@ -4101,7 +4101,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { "010", "010100", "010100011", @@ -4147,7 +4147,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { "0101", "01010001", "010100011100", @@ -4182,7 +4182,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -4201,7 +4201,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -4217,7 +4217,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -4232,7 +4232,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -4243,7 +4243,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -4251,14 +4251,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { "0", "01", "010", @@ -4389,7 +4389,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { "01", "0101", "010100", @@ -4456,7 +4456,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { "010", "010100", "010100011", @@ -4502,7 +4502,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { "0101", "01010001", "010100011100", @@ -4537,7 +4537,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -4556,7 +4556,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -4572,7 +4572,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -4587,7 +4587,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -4598,7 +4598,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -4606,14 +4606,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, { "0", "01", "010", @@ -4744,7 +4744,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, { "01", "0101", "010100", @@ -4811,7 +4811,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, { "010", "010100", "010100011", @@ -4857,7 +4857,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, { "0101", "01010001", "010100011100", @@ -4892,7 +4892,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -4911,7 +4911,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -4927,7 +4927,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -4942,7 +4942,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -4953,7 +4953,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -4961,14 +4961,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, { "0", "01", "010", @@ -5099,7 +5099,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, { "01", "0101", "010100", @@ -5166,7 +5166,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, { "010", "010100", "010100011", @@ -5212,7 +5212,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, { "0101", "01010001", "010100011100", @@ -5247,7 +5247,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, { "01010001", "0101000111001101", "010100011100110101110001", @@ -5266,7 +5266,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, { "0101000111", "01010001110011010111", "010100011100110101110001001001", @@ -5282,7 +5282,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, { "01010001110", "0101000111001101011100", "010100011100110101110001001001100", @@ -5297,7 +5297,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, { "0101000111001101", "01010001110011010111000100100110", "010100011100110101110001001001100100101000011100", @@ -5308,7 +5308,7 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, { "0101000111001101011100010010011", "01010001110011010111000100100110010010100001110000111010110001", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", @@ -5316,14 +5316,14 @@ "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, { "01010001110011010111000100100110", "0101000111001101011100010010011001001010000111000011101011000101", "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 1, { "1", "10", "101", @@ -5454,7 +5454,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 2, { "10", "1010", "101011", @@ -5521,7 +5521,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 3, { "101", "101011", "101011100", @@ -5567,7 +5567,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 4, { "1010", "10101110", "101011100011", @@ -5602,7 +5602,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -5621,7 +5621,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -5637,7 +5637,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -5652,7 +5652,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -5663,7 +5663,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -5671,14 +5671,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, { "1", "10", "101", @@ -5809,7 +5809,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, { "10", "1010", "101011", @@ -5876,7 +5876,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, { "101", "101011", "101011100", @@ -5922,7 +5922,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, { "1010", "10101110", "101011100011", @@ -5957,7 +5957,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -5976,7 +5976,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -5992,7 +5992,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -6007,7 +6007,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -6018,7 +6018,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -6026,14 +6026,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { "1", "10", "101", @@ -6164,7 +6164,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { "10", "1010", "101011", @@ -6231,7 +6231,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { "101", "101011", "101011100", @@ -6277,7 +6277,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { "1010", "10101110", "101011100011", @@ -6312,7 +6312,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -6331,7 +6331,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -6347,7 +6347,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -6362,7 +6362,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -6373,7 +6373,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -6381,14 +6381,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { "1", "10", "101", @@ -6519,7 +6519,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { "10", "1010", "101011", @@ -6586,7 +6586,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { "101", "101011", "101011100", @@ -6632,7 +6632,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { "1010", "10101110", "101011100011", @@ -6667,7 +6667,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -6686,7 +6686,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -6702,7 +6702,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -6717,7 +6717,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -6728,7 +6728,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -6736,14 +6736,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, { "1", "10", "101", @@ -6874,7 +6874,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, { "10", "1010", "101011", @@ -6941,7 +6941,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, { "101", "101011", "101011100", @@ -6987,7 +6987,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, { "1010", "10101110", "101011100011", @@ -7022,7 +7022,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -7041,7 +7041,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -7057,7 +7057,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -7072,7 +7072,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -7083,7 +7083,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -7091,14 +7091,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, { "1", "10", "101", @@ -7229,7 +7229,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, { "10", "1010", "101011", @@ -7296,7 +7296,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, { "101", "101011", "101011100", @@ -7342,7 +7342,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, { "1010", "10101110", "101011100011", @@ -7377,7 +7377,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -7396,7 +7396,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -7412,7 +7412,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -7427,7 +7427,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -7438,7 +7438,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -7446,14 +7446,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, { "1", "10", "101", @@ -7584,7 +7584,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, { "10", "1010", "101011", @@ -7651,7 +7651,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, { "101", "101011", "101011100", @@ -7697,7 +7697,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, { "1010", "10101110", "101011100011", @@ -7732,7 +7732,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -7751,7 +7751,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -7767,7 +7767,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -7782,7 +7782,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -7793,7 +7793,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -7801,14 +7801,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, { "1", "10", "101", @@ -7939,7 +7939,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, { "10", "1010", "101011", @@ -8006,7 +8006,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, { "101", "101011", "101011100", @@ -8052,7 +8052,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, { "1010", "10101110", "101011100011", @@ -8087,7 +8087,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, { "10101110", "1010111000111001", "101011100011100110001011", @@ -8106,7 +8106,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, { "1010111000", "10101110001110011000", "101011100011100110001011011110", @@ -8122,7 +8122,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, { "10101110001", "1010111000111001100010", "101011100011100110001011011110101", @@ -8137,7 +8137,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, { "1010111000111001", "10101110001110011000101101111010", "101011100011100110001011011110101010100010011111", @@ -8148,7 +8148,7 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, { "1010111000111001100010110111101", "10101110001110011000101101111010101010001001111111001001000100", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", @@ -8156,14 +8156,14 @@ "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, { "10101110001110011000101101111010", "1010111000111001100010110111101010101000100111111100100100010000", "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 1, { "1", "11", "110", @@ -8294,7 +8294,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 2, { "11", "1101", "110111", @@ -8361,7 +8361,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 3, { "110", "110111", "110111000", @@ -8407,7 +8407,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 4, { "1101", "11011100", "110111000111", @@ -8442,7 +8442,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -8461,7 +8461,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -8477,7 +8477,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -8492,7 +8492,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -8503,7 +8503,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -8511,14 +8511,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, { "1", "11", "110", @@ -8649,7 +8649,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, { "11", "1101", "110111", @@ -8716,7 +8716,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, { "110", "110111", "110111000", @@ -8762,7 +8762,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, { "1101", "11011100", "110111000111", @@ -8797,7 +8797,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -8816,7 +8816,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -8832,7 +8832,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -8847,7 +8847,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -8858,7 +8858,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -8866,14 +8866,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, { "1", "11", "110", @@ -9004,7 +9004,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, { "11", "1101", "110111", @@ -9071,7 +9071,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, { "110", "110111", "110111000", @@ -9117,7 +9117,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, { "1101", "11011100", "110111000111", @@ -9152,7 +9152,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -9171,7 +9171,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -9187,7 +9187,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -9202,7 +9202,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -9213,7 +9213,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -9221,14 +9221,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { "1", "11", "110", @@ -9359,7 +9359,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { "11", "1101", "110111", @@ -9426,7 +9426,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { "110", "110111", "110111000", @@ -9472,7 +9472,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { "1101", "11011100", "110111000111", @@ -9507,7 +9507,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -9526,7 +9526,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -9542,7 +9542,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -9557,7 +9557,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -9568,7 +9568,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -9576,14 +9576,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, { "1", "11", "110", @@ -9714,7 +9714,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, { "11", "1101", "110111", @@ -9781,7 +9781,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, { "110", "110111", "110111000", @@ -9827,7 +9827,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, { "1101", "11011100", "110111000111", @@ -9862,7 +9862,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -9881,7 +9881,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -9897,7 +9897,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -9912,7 +9912,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -9923,7 +9923,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -9931,14 +9931,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, { "1", "11", "110", @@ -10069,7 +10069,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, { "11", "1101", "110111", @@ -10136,7 +10136,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, { "110", "110111", "110111000", @@ -10182,7 +10182,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, { "1101", "11011100", "110111000111", @@ -10217,7 +10217,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -10236,7 +10236,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -10252,7 +10252,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -10267,7 +10267,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -10278,7 +10278,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -10286,14 +10286,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, { "1", "11", "110", @@ -10424,7 +10424,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, { "11", "1101", "110111", @@ -10491,7 +10491,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, { "110", "110111", "110111000", @@ -10537,7 +10537,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, { "1101", "11011100", "110111000111", @@ -10572,7 +10572,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -10591,7 +10591,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -10607,7 +10607,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -10622,7 +10622,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -10633,7 +10633,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -10641,14 +10641,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, { "1", "11", "110", @@ -10779,7 +10779,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, { "11", "1101", "110111", @@ -10846,7 +10846,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, { "110", "110111", "110111000", @@ -10892,7 +10892,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, { "1101", "11011100", "110111000111", @@ -10927,7 +10927,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, { "11011100", "1101110001110001", "110111000111000111010011", @@ -10946,7 +10946,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, { "1101110001", "11011100011100011101", "110111000111000111010011110000", @@ -10962,7 +10962,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, { "11011100011", "1101110001110001110100", "110111000111000111010011110000001", @@ -10977,7 +10977,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, { "1101110001110001", "11011100011100011101001111000000", "110111000111000111010011110000001000100101110100", @@ -10988,7 +10988,7 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, { "1101110001110001110100111100000", "11011100011100011101001111000000100010010111010000001010011010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", @@ -10996,14 +10996,14 @@ "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, { "11011100011100011101001111000000", "1101110001110001110100111100000010001001011101000000101001101010", "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, { "0", "00", "001", @@ -11134,7 +11134,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, { "00", "0010", "001000", @@ -11201,7 +11201,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, { "001", "001000", "001000111", @@ -11247,7 +11247,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, { "0010", "00100011", "001000111000", @@ -11282,7 +11282,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, { "00100011", "0010001110001110", "001000111000111000101100", @@ -11301,7 +11301,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, { "0010001110", "00100011100011100010", "001000111000111000101100001111", @@ -11317,7 +11317,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, { "00100011100", "0010001110001110001011", "001000111000111000101100001111110", @@ -11332,7 +11332,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, { "0010001110001110", "00100011100011100010110000111111", "001000111000111000101100001111110111011010001011", @@ -11343,7 +11343,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, { "0010001110001110001011000011111", "00100011100011100010110000111111011101101000101111110101100101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", @@ -11351,14 +11351,14 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, { "00100011100011100010110000111111", "0010001110001110001011000011111101110110100010111111010110010101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 1, { "0", "00", "001", @@ -11489,7 +11489,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 2, { "00", "0010", "001000", @@ -11556,7 +11556,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 3, { "001", "001000", "001000111", @@ -11602,7 +11602,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 4, { "0010", "00100011", "001000111000", @@ -11637,7 +11637,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 8, { "00100011", "0010001110001110", "001000111000111000101100", @@ -11656,7 +11656,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 10, { "0010001110", "00100011100011100010", "001000111000111000101100001111", @@ -11672,7 +11672,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 11, { "00100011100", "0010001110001110001011", "001000111000111000101100001111110", @@ -11687,7 +11687,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 16, { "0010001110001110", "00100011100011100010110000111111", "001000111000111000101100001111110111011010001011", @@ -11698,7 +11698,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 31, { "0010001110001110001011000011111", "00100011100011100010110000111111011101101000101111110101100101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", @@ -11706,14 +11706,14 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 32, { "00100011100011100010110000111111", "0010001110001110001011000011111101110110100010111111010110010101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, { "0", "00", "001", @@ -11844,7 +11844,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, { "00", "0010", "001000", @@ -11911,7 +11911,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, { "001", "001000", "001000111", @@ -11957,7 +11957,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, { "0010", "00100011", "001000111000", @@ -11992,7 +11992,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, { "00100011", "0010001110001110", "001000111000111000101100", @@ -12011,7 +12011,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, { "0010001110", "00100011100011100010", "001000111000111000101100001111", @@ -12027,7 +12027,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, { "00100011100", "0010001110001110001011", "001000111000111000101100001111110", @@ -12042,7 +12042,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, { "0010001110001110", "00100011100011100010110000111111", "001000111000111000101100001111110111011010001011", @@ -12053,7 +12053,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, { "0010001110001110001011000011111", "00100011100011100010110000111111011101101000101111110101100101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", @@ -12061,14 +12061,14 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, { "00100011100011100010110000111111", "0010001110001110001011000011111101110110100010111111010110010101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 1, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 1, { "0", "00", "001", @@ -12199,7 +12199,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 2, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 2, { "00", "0010", "001000", @@ -12266,7 +12266,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 3, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 3, { "001", "001000", "001000111", @@ -12312,7 +12312,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 4, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 4, { "0010", "00100011", "001000111000", @@ -12347,7 +12347,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 8, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 8, { "00100011", "0010001110001110", "001000111000111000101100", @@ -12366,7 +12366,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 10, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 10, { "0010001110", "00100011100011100010", "001000111000111000101100001111", @@ -12382,7 +12382,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 11, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 11, { "00100011100", "0010001110001110001011", "001000111000111000101100001111110", @@ -12397,7 +12397,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 16, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 16, { "0010001110001110", "00100011100011100010110000111111", "001000111000111000101100001111110111011010001011", @@ -12408,7 +12408,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 31, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 31, { "0010001110001110001011000011111", "00100011100011100010110000111111011101101000101111110101100101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", @@ -12416,7 +12416,7 @@ "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", "root", }}, - {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 32, { + {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 32, { "00100011100011100010110000111111", "0010001110001110001011000011111101110110100010111111010110010101", "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", diff --git a/src/mongo/crypto/test_vectors/edges_double.cstruct b/src/mongo/crypto/test_vectors/edges_double.cstruct index fafec401630..e7ec1198df6 100644 --- a/src/mongo/crypto/test_vectors/edges_double.cstruct +++ b/src/mongo/crypto/test_vectors/edges_double.cstruct @@ -1,4 +1,4 @@ - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 1, { "1", "10", "100", @@ -65,7 +65,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 2, { "10", "1000", "100000", @@ -100,7 +100,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 3, { "100", "100000", "100000000", @@ -125,7 +125,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 4, { "1000", "10000000", "100000000000", @@ -144,7 +144,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -155,7 +155,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -165,7 +165,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -174,25 +174,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 1, { "1", "10", "100", @@ -259,7 +259,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 2, { "10", "1000", "100000", @@ -294,7 +294,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 3, { "100", "100000", "100000000", @@ -319,7 +319,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 4, { "1000", "10000000", "100000000000", @@ -338,7 +338,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -349,7 +349,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -359,7 +359,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -368,25 +368,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "10", "100", @@ -453,7 +453,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "10", "1000", "100000", @@ -488,7 +488,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "100", "100000", "100000000", @@ -513,7 +513,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1000", "10000000", "100000000000", @@ -532,7 +532,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -543,7 +543,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -553,7 +553,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -562,25 +562,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "10", "100", @@ -647,7 +647,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "10", "1000", "100000", @@ -682,7 +682,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "100", "100000", "100000000", @@ -707,7 +707,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1000", "10000000", "100000000000", @@ -726,7 +726,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -737,7 +737,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -747,7 +747,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -756,25 +756,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 1, { "1", "10", "100", @@ -841,7 +841,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 2, { "10", "1000", "100000", @@ -876,7 +876,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -901,7 +901,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 4, { "1000", "10000000", "100000000000", @@ -920,7 +920,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -931,7 +931,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -941,7 +941,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -950,25 +950,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 1, { "1", "10", "100", @@ -1035,7 +1035,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 2, { "10", "1000", "100000", @@ -1070,7 +1070,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -1095,7 +1095,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 4, { "1000", "10000000", "100000000000", @@ -1114,7 +1114,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 8, { "10000000", "1000000000000000", "100000000000000000000000", @@ -1125,7 +1125,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 10, { "1000000000", "10000000000000000000", "100000000000000000000000000000", @@ -1135,7 +1135,7 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 11, { "10000000000", "1000000000000000000000", "100000000000000000000000000000000", @@ -1144,25 +1144,25 @@ "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 16, { "1000000000000000", "10000000000000000000000000000000", "100000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 31, { "1000000000000000000000000000000", "10000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 32, { "10000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 1, { "0", "01", "010", @@ -1229,7 +1229,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 2, { "01", "0100", "010000", @@ -1264,7 +1264,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 3, { "010", "010000", "010000001", @@ -1289,7 +1289,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 4, { "0100", "01000000", "010000001000", @@ -1308,7 +1308,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 8, { "01000000", "0100000010000011", "010000001000001101010011", @@ -1319,7 +1319,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 10, { "0100000010", "01000000100000110101", "010000001000001101010011111101", @@ -1329,7 +1329,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 11, { "01000000100", "0100000010000011010100", "010000001000001101010011111101111", @@ -1338,25 +1338,25 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 16, { "0100000010000011", "01000000100000110101001111110111", "010000001000001101010011111101111100111011011001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 31, { "0100000010000011010100111111011", "01000000100000110101001111110111110011101101100100010110100001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 32, { "01000000100000110101001111110111", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "0", "01", "010", @@ -1423,7 +1423,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "01", "0100", "010000", @@ -1458,7 +1458,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "010", "010000", "010000001", @@ -1483,7 +1483,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "0100", "01000000", "010000001000", @@ -1502,7 +1502,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "01000000", "0100000010000011", "010000001000001101010011", @@ -1513,7 +1513,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "0100000010", "01000000100000110101", "010000001000001101010011111101", @@ -1523,7 +1523,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "01000000100", "0100000010000011010100", "010000001000001101010011111101111", @@ -1532,25 +1532,25 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "0100000010000011", "01000000100000110101001111110111", "010000001000001101010011111101111100111011011001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "0100000010000011010100111111011", "01000000100000110101001111110111110011101101100100010110100001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "01000000100000110101001111110111", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 1, { "0", "01", "010", @@ -1617,7 +1617,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 2, { "01", "0100", "010000", @@ -1652,7 +1652,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 3, { "010", "010000", "010000001", @@ -1677,7 +1677,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 4, { "0100", "01000000", "010000001000", @@ -1696,7 +1696,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 8, { "01000000", "0100000010000011", "010000001000001101010011", @@ -1707,7 +1707,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 10, { "0100000010", "01000000100000110101", "010000001000001101010011111101", @@ -1717,7 +1717,7 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 11, { "01000000100", "0100000010000011010100", "010000001000001101010011111101111", @@ -1726,25 +1726,25 @@ "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 16, { "0100000010000011", "01000000100000110101001111110111", "010000001000001101010011111101111100111011011001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 31, { "0100000010000011010100111111011", "01000000100000110101001111110111110011101101100100010110100001", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 32, { "01000000100000110101001111110111", "0100000010000011010100111111011111001110110110010001011010000111", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "110", @@ -1811,7 +1811,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1100", "110000", @@ -1846,7 +1846,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "110", "110000", "110000000", @@ -1871,7 +1871,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1100", "11000000", "110000000100", @@ -1890,7 +1890,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -1901,7 +1901,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -1911,7 +1911,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -1920,25 +1920,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "110", @@ -2005,7 +2005,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1100", "110000", @@ -2040,7 +2040,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "110", "110000", "110000000", @@ -2065,7 +2065,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1100", "11000000", "110000000100", @@ -2084,7 +2084,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -2095,7 +2095,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -2105,7 +2105,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -2114,25 +2114,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "110", @@ -2199,7 +2199,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1100", "110000", @@ -2234,7 +2234,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "110", "110000", "110000000", @@ -2259,7 +2259,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1100", "11000000", "110000000100", @@ -2278,7 +2278,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -2289,7 +2289,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -2299,7 +2299,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -2308,25 +2308,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "110", @@ -2393,7 +2393,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1100", "110000", @@ -2428,7 +2428,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "110", "110000", "110000000", @@ -2453,7 +2453,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1100", "11000000", "110000000100", @@ -2472,7 +2472,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -2483,7 +2483,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -2493,7 +2493,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -2502,25 +2502,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, { "1", "11", "110", @@ -2587,7 +2587,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, { "11", "1100", "110000", @@ -2622,7 +2622,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, { "110", "110000", "110000000", @@ -2647,7 +2647,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, { "1100", "11000000", "110000000100", @@ -2666,7 +2666,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -2677,7 +2677,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -2687,7 +2687,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -2696,25 +2696,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, { "1", "11", "110", @@ -2781,7 +2781,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, { "11", "1100", "110000", @@ -2816,7 +2816,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, { "110", "110000", "110000000", @@ -2841,7 +2841,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, { "1100", "11000000", "110000000100", @@ -2860,7 +2860,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -2871,7 +2871,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -2881,7 +2881,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -2890,25 +2890,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, { "1", "11", "110", @@ -2975,7 +2975,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, { "11", "1100", "110000", @@ -3010,7 +3010,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, { "110", "110000", "110000000", @@ -3035,7 +3035,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, { "1100", "11000000", "110000000100", @@ -3054,7 +3054,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -3065,7 +3065,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -3075,7 +3075,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -3084,25 +3084,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, { "1", "11", "110", @@ -3169,7 +3169,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, { "11", "1100", "110000", @@ -3204,7 +3204,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, { "110", "110000", "110000000", @@ -3229,7 +3229,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, { "1100", "11000000", "110000000100", @@ -3248,7 +3248,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, { "11000000", "1100000001000000", "110000000100000001100011", @@ -3259,7 +3259,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, { "1100000001", "11000000010000000110", "110000000100000001100011011101", @@ -3269,7 +3269,7 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, { "11000000010", "1100000001000000011000", "110000000100000001100011011101001", @@ -3278,25 +3278,25 @@ "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, { "1100000001000000", "11000000010000000110001101110100", "110000000100000001100011011101001011110001101010", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, { "1100000001000000011000110111010", "11000000010000000110001101110100101111000110101001111110111110", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, { "11000000010000000110001101110100", "1100000001000000011000110111010010111100011010100111111011111010", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "111", @@ -3363,7 +3363,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1111", "111111", @@ -3398,7 +3398,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "111", "111111", "111111111", @@ -3423,7 +3423,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1111", "11111111", "111111111110", @@ -3442,7 +3442,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -3453,7 +3453,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -3463,7 +3463,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -3472,25 +3472,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "111", @@ -3557,7 +3557,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1111", "111111", @@ -3592,7 +3592,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "111", "111111", "111111111", @@ -3617,7 +3617,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1111", "11111111", "111111111110", @@ -3636,7 +3636,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -3647,7 +3647,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -3657,7 +3657,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -3666,25 +3666,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "111", @@ -3751,7 +3751,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1111", "111111", @@ -3786,7 +3786,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "111", "111111", "111111111", @@ -3811,7 +3811,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1111", "11111111", "111111111110", @@ -3830,7 +3830,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -3841,7 +3841,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -3851,7 +3851,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -3860,25 +3860,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "11", "111", @@ -3945,7 +3945,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "11", "1111", "111111", @@ -3980,7 +3980,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "111", "111111", "111111111", @@ -4005,7 +4005,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1111", "11111111", "111111111110", @@ -4024,7 +4024,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -4035,7 +4035,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -4045,7 +4045,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -4054,25 +4054,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { "1", "11", "111", @@ -4139,7 +4139,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { "11", "1111", "111111", @@ -4174,7 +4174,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { "111", "111111", "111111111", @@ -4199,7 +4199,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { "1111", "11111111", "111111111110", @@ -4218,7 +4218,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -4229,7 +4229,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -4239,7 +4239,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -4248,25 +4248,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { "1", "11", "111", @@ -4333,7 +4333,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { "11", "1111", "111111", @@ -4368,7 +4368,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { "111", "111111", "111111111", @@ -4393,7 +4393,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { "1111", "11111111", "111111111110", @@ -4412,7 +4412,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -4423,7 +4423,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -4433,7 +4433,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -4442,25 +4442,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { "1", "11", "111", @@ -4527,7 +4527,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { "11", "1111", "111111", @@ -4562,7 +4562,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { "111", "111111", "111111111", @@ -4587,7 +4587,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { "1111", "11111111", "111111111110", @@ -4606,7 +4606,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -4617,7 +4617,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -4627,7 +4627,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -4636,25 +4636,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, { "1", "11", "111", @@ -4721,7 +4721,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, { "11", "1111", "111111", @@ -4756,7 +4756,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, { "111", "111111", "111111111", @@ -4781,7 +4781,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, { "1111", "11111111", "111111111110", @@ -4800,7 +4800,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, { "11111111", "1111111111101111", "111111111110111111111111", @@ -4811,7 +4811,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, { "1111111111", "11111111111011111111", "111111111110111111111111111111", @@ -4821,7 +4821,7 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, { "11111111111", "1111111111101111111111", "111111111110111111111111111111111", @@ -4830,25 +4830,25 @@ "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, { "1111111111101111", "11111111111011111111111111111111", "111111111110111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, { "1111111111101111111111111111111", "11111111111011111111111111111111111111111111111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, { "11111111111011111111111111111111", "1111111111101111111111111111111111111111111111111111111111111111", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 1, { "1", "10", "100", @@ -4915,7 +4915,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 2, { "10", "1000", "100000", @@ -4950,7 +4950,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 3, { "100", "100000", "100000000", @@ -4975,7 +4975,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 4, { "1000", "10000000", "100000000001", @@ -4994,7 +4994,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5005,7 +5005,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5015,7 +5015,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5024,25 +5024,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 12.33999999999999986, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 1, { "1", "10", "100", @@ -5109,7 +5109,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 2, { "10", "1000", "100000", @@ -5144,7 +5144,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 3, { "100", "100000", "100000000", @@ -5169,7 +5169,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 4, { "1000", "10000000", "100000000001", @@ -5188,7 +5188,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5199,7 +5199,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5209,7 +5209,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5218,25 +5218,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 12.33999999999999986, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 1, { "1", "10", "100", @@ -5303,7 +5303,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 2, { "10", "1000", "100000", @@ -5338,7 +5338,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 3, { "100", "100000", "100000000", @@ -5363,7 +5363,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 4, { "1000", "10000000", "100000000001", @@ -5382,7 +5382,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5393,7 +5393,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5403,7 +5403,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5412,25 +5412,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 12.33999999999999986, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "10", "100", @@ -5497,7 +5497,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "10", "1000", "100000", @@ -5532,7 +5532,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "100", "100000", "100000000", @@ -5557,7 +5557,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1000", "10000000", "100000000001", @@ -5576,7 +5576,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5587,7 +5587,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5597,7 +5597,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5606,25 +5606,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "10", "100", @@ -5691,7 +5691,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "10", "1000", "100000", @@ -5726,7 +5726,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "100", "100000", "100000000", @@ -5751,7 +5751,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1000", "10000000", "100000000001", @@ -5770,7 +5770,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5781,7 +5781,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5791,7 +5791,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5800,25 +5800,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, { "1", "10", "100", @@ -5885,7 +5885,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, { "10", "1000", "100000", @@ -5920,7 +5920,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, { "100", "100000", "100000000", @@ -5945,7 +5945,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, { "1000", "10000000", "100000000001", @@ -5964,7 +5964,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -5975,7 +5975,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -5985,7 +5985,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -5994,25 +5994,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), std::numeric_limits::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 1, { "1", "10", "100", @@ -6079,7 +6079,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -6114,7 +6114,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -6139,7 +6139,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 4, { "1000", "10000000", "100000000001", @@ -6158,7 +6158,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -6169,7 +6169,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -6179,7 +6179,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -6188,25 +6188,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 1, { "1", "10", "100", @@ -6273,7 +6273,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -6308,7 +6308,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -6333,7 +6333,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 4, { "1000", "10000000", "100000000001", @@ -6352,7 +6352,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -6363,7 +6363,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -6373,7 +6373,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -6382,25 +6382,25 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 1, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 1, { "1", "10", "100", @@ -6467,7 +6467,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 2, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 2, { "10", "1000", "100000", @@ -6502,7 +6502,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 3, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 3, { "100", "100000", "100000000", @@ -6527,7 +6527,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 4, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 4, { "1000", "10000000", "100000000001", @@ -6546,7 +6546,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 8, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 8, { "10000000", "1000000000010000", "100000000001000000000000", @@ -6557,7 +6557,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 10, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 10, { "1000000000", "10000000000100000000", "100000000001000000000000000000", @@ -6567,7 +6567,7 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 11, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 11, { "10000000000", "1000000000010000000000", "100000000001000000000000000000000", @@ -6576,20 +6576,20 @@ "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 16, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 16, { "1000000000010000", "10000000000100000000000000000000", "100000000001000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 31, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 31, { "1000000000010000000000000000000", "10000000000100000000000000000000000000000000000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", }}, - {&getEdgesDouble, std::numeric_limits::min(), boost::none, boost::none, 32, { + {&getEdgesDoubleForTest, std::numeric_limits::min(), boost::none, boost::none, 32, { "10000000000100000000000000000000", "1000000000010000000000000000000000000000000000000000000000000000", "root", diff --git a/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct b/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct new file mode 100644 index 00000000000..a3955ea49ce --- /dev/null +++ b/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct @@ -0,0 +1,394 @@ +// this file was generated using code in +// https://github.com/10gen/ost1-misc/tree/master/my-app +// + +{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.500000"), 1, 1, +R"(000 +0010000 +)"}, + +{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.550000"), 1, 2, +R"(000 +00100 +00101000 +)"}, + +{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.553000"), 1, 3, +R"(000 +0010 +0011000 +00110010 +00110011000 +001100110010 +0011001100110 +)"}, + +{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.553600"), 1, 4, +R"(000 +00100000000000000 +)"}, + +{ Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("788545.000000"), Decimal128("340282366920938463463374607431769000000.000000"), 1, 0, +R"(10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011 +101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111 +101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111 +1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100001 +1010111001000010101111000101111011000100011000100011100110001001100100111101111010001 +101011100100001010111100010111101100010001100010001110011000100110010011110111101001 +10101110010000101011110001011110110001000110001000111001100010011001001111011110101 +1010111001000010101111000101111011000100011000100011100110001001100100111101111011 +10101110010000101011110001011110110001000110001000111001100010011001001111011111 +101011100100001010111100010111101100010001100010001110011000100110010011111 +1010111001000010101111000101111011000100011000100011100110001001100101 +101011100100001010111100010111101100010001100010001110011000100110011 +1010111001000010101111000101111011000100011000100011100110001001101 +101011100100001010111100010111101100010001100010001110011000100111 +101011100100001010111100010111101100010001100010001110011000101 +10101110010000101011110001011110110001000110001000111001100011 +101011100100001010111100010111101100010001100010001110011001 +10101110010000101011110001011110110001000110001000111001101 +1010111001000010101111000101111011000100011000100011100111 +1010111001000010101111000101111011000100011000100011101 +101011100100001010111100010111101100010001100010001111 +10101110010000101011110001011110110001000110001001 +1010111001000010101111000101111011000100011000101 +101011100100001010111100010111101100010001100011 +1010111001000010101111000101111011000100011001 +101011100100001010111100010111101100010001101 +10101110010000101011110001011110110001000111 +10101110010000101011110001011110110001001 +1010111001000010101111000101111011000101 +101011100100001010111100010111101100011 +1010111001000010101111000101111011001 +101011100100001010111100010111101101 +10101110010000101011110001011110111 +10101110010000101011110001011111 +101011100100001010111100011 +1010111001000010101111001 +101011100100001010111101 +10101110010000101011111 +101011100100001011 +1010111001000011 +10101110010001000 +101011100100010010 +10101110010001001100 +101011100100010011010 +10101110010001001101100 +1010111001000100110110100 +101011100100010011011010100 +1010111001000100110110101010 +101011100100010011011010101100 +1010111001000100110110101011010 +1010111001000100110110101011011000 +1010111001000100110110101011011001000 +1010111001000100110110101011011001001000 +101011100100010011011010101101100100100100 +10101110010001001101101010110110010010010100 +1010111001000100110110101011011001001001010100 +10101110010001001101101010110110010010010101010000 +10101110010001001101101010110110010010010101010001000 +101011100100010011011010101101100100100101010100010010 +1010111001000100110110101011011001001001010101000100110 +101011100100010011011010101101100100100101010100010011100 +1010111001000100110110101011011001001001010101000100111010 +101011100100010011011010101101100100100101010100010011101100 +1010111001000100110110101011011001001001010101000100111011010 +10101110010001001101101010110110010010010101010001001110110110 +1010111001000100110110101011011001001001010101000100111011011100 +1010111001000100110110101011011001001001010101000100111011011101000000 +101011100100010011011010101101100100100101010100010011101101110100000100000 +10101110010001001101101010110110010010010101010001001110110111010000010000100 +101011100100010011011010101101100100100101010100010011101101110100000100001010 +10101110010001001101101010110110010010010101010001001110110111010000010000101100 +1010111001000100110110101011011001001001010101000100111011011101000001000010110100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101010 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010 +)"}, + +{ Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("788544.000000"), Decimal128("340282366920938463463374607431769000000.000000"), 1, 0, +R"(10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011 +101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111 +101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111 +1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011 +10101110010000101011110001011110110001000110001000111001100010011001001111011110100001 +1010111001000010101111000101111011000100011000100011100110001001100100111101111010001 +101011100100001010111100010111101100010001100010001110011000100110010011110111101001 +10101110010000101011110001011110110001000110001000111001100010011001001111011110101 +1010111001000010101111000101111011000100011000100011100110001001100100111101111011 +10101110010000101011110001011110110001000110001000111001100010011001001111011111 +101011100100001010111100010111101100010001100010001110011000100110010011111 +1010111001000010101111000101111011000100011000100011100110001001100101 +101011100100001010111100010111101100010001100010001110011000100110011 +1010111001000010101111000101111011000100011000100011100110001001101 +101011100100001010111100010111101100010001100010001110011000100111 +101011100100001010111100010111101100010001100010001110011000101 +10101110010000101011110001011110110001000110001000111001100011 +101011100100001010111100010111101100010001100010001110011001 +10101110010000101011110001011110110001000110001000111001101 +1010111001000010101111000101111011000100011000100011100111 +1010111001000010101111000101111011000100011000100011101 +101011100100001010111100010111101100010001100010001111 +10101110010000101011110001011110110001000110001001 +1010111001000010101111000101111011000100011000101 +101011100100001010111100010111101100010001100011 +1010111001000010101111000101111011000100011001 +101011100100001010111100010111101100010001101 +10101110010000101011110001011110110001000111 +10101110010000101011110001011110110001001 +1010111001000010101111000101111011000101 +101011100100001010111100010111101100011 +1010111001000010101111000101111011001 +101011100100001010111100010111101101 +10101110010000101011110001011110111 +10101110010000101011110001011111 +101011100100001010111100011 +1010111001000010101111001 +101011100100001010111101 +10101110010000101011111 +101011100100001011 +1010111001000011 +10101110010001000 +101011100100010010 +10101110010001001100 +101011100100010011010 +10101110010001001101100 +1010111001000100110110100 +101011100100010011011010100 +1010111001000100110110101010 +101011100100010011011010101100 +1010111001000100110110101011010 +1010111001000100110110101011011000 +1010111001000100110110101011011001000 +1010111001000100110110101011011001001000 +101011100100010011011010101101100100100100 +10101110010001001101101010110110010010010100 +1010111001000100110110101011011001001001010100 +10101110010001001101101010110110010010010101010000 +10101110010001001101101010110110010010010101010001000 +101011100100010011011010101101100100100101010100010010 +1010111001000100110110101011011001001001010101000100110 +101011100100010011011010101101100100100101010100010011100 +1010111001000100110110101011011001001001010101000100111010 +101011100100010011011010101101100100100101010100010011101100 +1010111001000100110110101011011001001001010101000100111011010 +10101110010001001101101010110110010010010101010001001110110110 +1010111001000100110110101011011001001001010101000100111011011100 +1010111001000100110110101011011001001001010101000100111011011101000000 +101011100100010011011010101101100100100101010100010011101101110100000100000 +10101110010001001101101010110110010010010101010001001110110111010000010000100 +101011100100010011011010101101100100100101010100010011101101110100000100001010 +10101110010001001101101010110110010010010101010001001110110111010000010000101100 +1010111001000100110110101011011001001001010101000100111011011101000001000010110100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101010 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110 +101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110 +1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100 +10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010 +)"}, + +// WRONG - this triggers 128 bits for the range calculation which does not use the precision code path therefore +// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 10, +// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001111 +// 000000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000000001 +// 0000000000000000000000000000000000000000000000000000000000000000000000001 +// 000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000001000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010 +// )"}, + +// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 10, +// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001111 +// 000000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000000001 +// 0000000000000000000000000000000000000000000000000000000000000000000000001 +// 000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000001000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010 +// )"}, + +// WRONG bits calculation in Java code +// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 9, +// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111 +// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101 +// 000000000000000000000000000000000000000000000000000000000000000000000000000111011 +// 0000000000000000000000000000000000000000000000000000000000000000000000000001111 +// 000000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000000001 +// 0000000000000000000000000000000000000000000000000000000000000000000000001 +// 000000000000000000000000000000000000000000000000000000000000000000000001 +// 00000000000000000000000000000000000000000000000000000000000000000000001000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110 +// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100 +// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100 +// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010 +// )"}, + diff --git a/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct b/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct new file mode 100644 index 00000000000..374a3e44497 --- /dev/null +++ b/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct @@ -0,0 +1,705 @@ +// this file was generated using code in +// https://github.com/10gen/ost1-misc/tree/master/my-app +// + +{ 0.000000, 1.638400, 0.000000, 6.500000, 1, 1, +R"(000 +0010000 +)"}, + +{ 0.000000, 1.638400, 0.000000, 6.550000, 1, 2, +R"(000 +00100 +00101000 +)"}, + +{ 0.000000, 1.638400, 0.000000, 6.553000, 1, 3, +R"(000 +0010 +0011000 +00110010 +00110011000 +001100110010 +0011001100110 +)"}, + +{ 0.000000, 1.638400, 0.000000, 6.553600, 1, 4, +R"(000 +00100000000000000 +)"}, + +{ 10000.000000, 20000.000000, 383.000000, 18446744073709552000.000000, 1, 0, +R"(110000001100001110001 +11000000110000111001 +1100000011000011101 +110000001100001111 +11000000110001 +1100000011001 +110000001101000 +1100000011010010 +11000000110100110 +110000001101001110000 +1100000011010011100010000000000000000000000000000000000000000000 +)"}, + +{ 10000.000000, 20000.000000, 384.000000, 18446744073709552000.000000, 1, 0, +R"(110000001100001110001 +11000000110000111001 +1100000011000011101 +110000001100001111 +11000000110001 +1100000011001 +110000001101000 +1100000011010010 +11000000110100110 +110000001101001110000 +1100000011010011100010000000000000000000000000000000000000000000 +)"}, + +// WRONG from Java code - too many zeros are used as a prefix, too many results +// { 10000.000000, 20000.000000, 1.384000, 184467440737095.530000, 1, 5, +// R"(0000000000000000000000000000000000100110001001000100011 +// 00000000000000000000000000000000001001100010010001001 +// 0000000000000000000000000000000000100110001001000101 +// 000000000000000000000000000000000010011000100100011 +// 0000000000000000000000000000000000100110001001001 +// 000000000000000000000000000000000010011000100101 +// 00000000000000000000000000000000001001100010011 +// 000000000000000000000000000000000010011000101 +// 00000000000000000000000000000000001001100011 +// 000000000000000000000000000000000010011001 +// 00000000000000000000000000000000001001101 +// 0000000000000000000000000000000000100111 +// 0000000000000000000000000000000000101 +// 000000000000000000000000000000000011 +// 0000000000000000000000000000000001000 +// 00000000000000000000000000000000010010 +// 000000000000000000000000000000000100110000 +// 000000000000000000000000000000000100110001000 +// 000000000000000000000000000000000100110001001000 +// 0000000000000000000000000000000001001100010010010 +// 00000000000000000000000000000000010011000100100110 +// 000000000000000000000000000000000100110001001001110 +// 000000000000000000000000000000000100110001001001111000 +// 0000000000000000000000000000000001001100010010011110010 +// 0000000000000000000000000000000001001100010010011110011000 +// )"}, + +// { 10000.000000, 20000.000000, 0.384000, 184467440737095.530000, 1, 5, +// R"(00000000000000000000000000000000001001100010010101 +// 0000000000000000000000000000000000100110001001011 +// 00000000000000000000000000000000001001100010011 +// 000000000000000000000000000000000010011000101 +// 00000000000000000000000000000000001001100011 +// 000000000000000000000000000000000010011001 +// 00000000000000000000000000000000001001101 +// 0000000000000000000000000000000000100111 +// 0000000000000000000000000000000000101 +// 000000000000000000000000000000000011 +// 0000000000000000000000000000000001000 +// 00000000000000000000000000000000010010 +// 000000000000000000000000000000000100110000 +// 000000000000000000000000000000000100110001000 +// 00000000000000000000000000000000010011000100100 +// 0000000000000000000000000000000001001100010010100 +// 00000000000000000000000000000000010011000100101010 +// 000000000000000000000000000000000100110001001010110 +// 0000000000000000000000000000000001001100010010101110000000 +// )"}, + +// { 10000.000000, 20000.000000, 0.384000, 184467440737095.530000, 1, 4, +// R"(00000000000000000000000000000000001001100010010101 +// 0000000000000000000000000000000000100110001001011 +// 00000000000000000000000000000000001001100010011 +// 000000000000000000000000000000000010011000101 +// 00000000000000000000000000000000001001100011 +// 000000000000000000000000000000000010011001 +// 00000000000000000000000000000000001001101 +// 0000000000000000000000000000000000100111 +// 0000000000000000000000000000000000101 +// 000000000000000000000000000000000011 +// 0000000000000000000000000000000001000 +// 00000000000000000000000000000000010010 +// 000000000000000000000000000000000100110000 +// 000000000000000000000000000000000100110001000 +// 00000000000000000000000000000000010011000100100 +// 0000000000000000000000000000000001001100010010100 +// 00000000000000000000000000000000010011000100101010 +// 000000000000000000000000000000000100110001001010110 +// 0000000000000000000000000000000001001100010010101110000000 +// )"}, + +{ 13.000000, 192.000000, 2.000000, 314.000000, 1, 0, +R"(000001011 +0000011 +00001 +0001 +001 +0100 +01010 +010110 +0101110 +01011110 +010111110 +)"}, + +{ 13.000000, 192.000000, 2.700000, 314.100000, 1, 1, +R"(000001100111 +000001101 +00000111 +00001 +0001 +001 +010 +0110 +011100 +0111010 +0111011000 +01110110010 +)"}, + +{ 13.000000, 192.000000, 2.710000, 314.150000, 1, 2, +R"(000010000000101 +00001000000011 +000010000001 +00001000001 +0000100001 +000010001 +00001001 +0000101 +000011 +0001 +001 +01 +1000 +1001000 +10010010 +100100110 +1001001110 +10010011110 +10010011111000 +)"}, + +{ 13.000000, 192.000000, 2.718000, 314.159000, 1, 3, +R"(000001010000010101 +00000101000001011 +000001010000011 +0000010100001 +000001010001 +00000101001 +0000010101 +000001011 +0000011 +00001 +0001 +001 +0100 +01010 +010110 +0101110000 +01011100010 +0101110001100 +01011100011010 +010111000110110000 +0101110001101100010 +)"}, + +{ 13.000000, 192.000000, 2.718200, 314.159200, 1, 4, +R"(000001100100011010001 +00000110010001101001 +0000011001000110101 +000001100100011011 +0000011001000111 +0000011001001 +000001100101 +00000110011 +000001101 +00000111 +00001 +0001 +001 +010 +0110 +0111000 +01110010 +011100110 +01110011100000 +011100111000010 +0111001110000110 +011100111000011100 +011100111000011101000 +0111001110000111010010 +)"}, + +{ 13.000000, 192.000000, 2.718280, 314.159260, 1, 5, +R"(00000111110110000010011 +000001111101100000101 +00000111110110000011 +000001111101100001 +00000111110110001 +0000011111011001 +000001111101101 +00000111110111 +00000111111 +00001 +0001 +001 +01 +1000 +1001000000 +10010000010 +1001000001100 +1001000001101000 +10010000011010010000 +1001000001101001000100 +10010000011010010001010 +1001000001101001000101100 +)"}, + +{ 13.000000, 192.000000, 2.718281, 314.159265, 1, 6, +R"(0000010011100111000101111011 +00000100111001110001011111 +000001001110011100011 +0000010011100111001 +000001001110011101 +00000100111001111 +0000010011101 +000001001111 +00000101 +0000011 +00001 +0001 +001 +0100 +01010 +0101100 +0101101000 +0101101001000000 +01011010010000010 +0101101001000001100 +010110100100000110100 +0101101001000001101010 +010110100100000110101100 +0101101001000001101011010 +01011010010000011010110110 +)"}, + +{ 13.000000, 192.000000, 2.718282, 314.159265, 1, 7, +R"(000001100010000011011101100111 +000001100010000011011101101 +00000110001000001101110111 +00000110001000001101111 +0000011000100000111 +0000011000100001 +000001100010001 +00000110001001 +0000011000101 +000001100011 +0000011001 +000001101 +00000111 +00001 +0001 +001 +010 +0110 +011100000 +0111000010 +011100001100 +011100001101000 +01110000110100100000 +011100001101001000010 +011100001101001000011000 +0111000011010010000110010000 +01110000110100100001100100010 +011100001101001000011001000110 +01110000110100100001100100011100 +)"}, + +// Numerical imprecision - the constant "e" as 2.718282 is not a precise double +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 8, +// R"(0000011110101001000101010000010101 +// 000001111010100100010101000001011 +// 0000011110101001000101010000011 +// 00000111101010010001010100001 +// 0000011110101001000101010001 +// 000001111010100100010101001 +// 00000111101010010001010101 +// 0000011110101001000101011 +// 00000111101010010001011 +// 000001111010100100011 +// 0000011110101001001 +// 000001111010100101 +// 00000111101010011 +// 000001111010101 +// 00000111101011 +// 000001111011 +// 0000011111 +// 00001 +// 0001 +// 001 +// 01 +// 10000 +// 100010 +// 10001100 +// 10001101000000 +// 100011010000010 +// 10001101000001100 +// 10001101000001101000 +// 100011010000011010010 +// 1000110100000110100110 +// 10001101000001101001110 +// 100011010000011010011110 +// 10001101000001101001111100 +// 100011010000011010011111010 +// 100011010000011010011111011000 +// 10001101000001101001111101100100 +// 1000110100000110100111110110010100 +// 10001101000001101001111101100101010 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 9, +// R"(0000010011001001101011010010001100111 +// 0000010011001001101011010010001101 +// 000001001100100110101101001000111 +// 000001001100100110101101001001 +// 00000100110010011010110100101 +// 0000010011001001101011010011 +// 00000100110010011010110101 +// 0000010011001001101011011 +// 00000100110010011010111 +// 00000100110010011011 +// 000001001100100111 +// 000001001100101 +// 00000100110011 +// 000001001101 +// 00000100111 +// 00000101 +// 0000011 +// 00001 +// 0001 +// 001 +// 0100 +// 01010 +// 01011000000 +// 01011000001000 +// 0101100000100100000 +// 01011000001001000010000 +// 010110000010010000100010 +// 0101100000100100001000110 +// 0101100000100100001000111000 +// 01011000001001000010001110010 +// 010110000010010000100011100110 +// 0101100000100100001000111001110 +// 01011000001001000010001110011110 +// 01011000001001000010001110011111000 +// 010110000010010000100011100111110010 +// 0101100000100100001000111001111100110 +// 010110000010010000100011100111110011100 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 10, +// R"(0000010111111100000110000110110000000101 +// 000001011111110000011000011011000000011 +// 0000010111111100000110000110110000001 +// 000001011111110000011000011011000001 +// 00000101111111000001100001101100001 +// 0000010111111100000110000110110001 +// 000001011111110000011000011011001 +// 00000101111111000001100001101101 +// 0000010111111100000110000110111 +// 0000010111111100000110000111 +// 0000010111111100000110001 +// 000001011111110000011001 +// 00000101111111000001101 +// 0000010111111100000111 +// 0000010111111100001 +// 000001011111110001 +// 00000101111111001 +// 0000010111111101 +// 000001011111111 +// 0000011 +// 00001 +// 0001 +// 001 +// 010 +// 01100 +// 011010 +// 0110110 +// 01101110000 +// 0110111000100 +// 01101110001010 +// 0110111000101100 +// 0110111000101101000 +// 011011100010110100100 +// 0110111000101101001010 +// 0110111000101101001011000 +// 011011100010110100101100100000 +// 0110111000101101001011001000010 +// 01101110001011010010110010000110 +// 01101110001011010010110010000111000000 +// 0110111000101101001011001000011100000100 +// 011011100010110100101100100001110000010100 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 11, +// R"(000001110111101100011110100001110000011000011 +// 0000011101111011000111101000011100000110001 +// 000001110111101100011110100001110000011001 +// 00000111011110110001111010000111000001101 +// 0000011101111011000111101000011100000111 +// 0000011101111011000111101000011100001 +// 000001110111101100011110100001110001 +// 00000111011110110001111010000111001 +// 0000011101111011000111101000011101 +// 000001110111101100011110100001111 +// 00000111011110110001111010001 +// 0000011101111011000111101001 +// 000001110111101100011110101 +// 00000111011110110001111011 +// 000001110111101100011111 +// 0000011101111011001 +// 000001110111101101 +// 00000111011110111 +// 00000111011111 +// 000001111 +// 00001 +// 0001 +// 001 +// 01 +// 10000 +// 10001000 +// 100010010 +// 10001001100 +// 100010011010 +// 1000100110110 +// 100010011011100000 +// 1000100110111000010 +// 10001001101110000110 +// 1000100110111000011100 +// 10001001101110000111010 +// 100010011011100001110110 +// 1000100110111000011101110 +// 100010011011100001110111100 +// 10001001101110000111011110100 +// 100010011011100001110111101010000 +// 1000100110111000011101111010100010 +// 10001001101110000111011110101000110000 +// 100010011011100001110111101010001100010 +// 1000100110111000011101111010100011000110000 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 12, +// R"(0000010010101100111100110001010001100011110010101 +// 000001001010110011110011000101000110001111001011 +// 0000010010101100111100110001010001100011110011 +// 00000100101011001111001100010100011000111101 +// 0000010010101100111100110001010001100011111 +// 00000100101011001111001100010100011001 +// 0000010010101100111100110001010001101 +// 000001001010110011110011000101000111 +// 000001001010110011110011000101001 +// 00000100101011001111001100010101 +// 0000010010101100111100110001011 +// 00000100101011001111001100011 +// 000001001010110011110011001 +// 00000100101011001111001101 +// 0000010010101100111100111 +// 0000010010101100111101 +// 000001001010110011111 +// 0000010010101101 +// 000001001010111 +// 000001001011 +// 0000010011 +// 00000101 +// 0000011 +// 00001 +// 0001 +// 001 +// 0100 +// 010100 +// 0101010 +// 010101100000 +// 010101100001000 +// 0101011000010010 +// 010101100001001100 +// 010101100001001101000 +// 01010110000100110100100 +// 0101011000010011010010100 +// 01010110000100110100101010 +// 01010110000100110100101011000 +// 01010110000100110100101011001000 +// 0101011000010011010010101100100100 +// 01010110000100110100101011001001010 +// 010101100001001101001010110010010110 +// 0101011000010011010010101100100101110 +// 010101100001001101001010110010010111100 +// 0101011000010011010010101100100101111010 +// 01010110000100110100101011001001011110110 +// 010101100001001101001010110010010111101110 +// 010101100001001101001010110010010111101111000 +// 01010110000100110100101011001001011110111100100 +// 010101100001001101001010110010010111101111001010 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 13, +// R"(0000000010010101100111100110001010001100011110010101 +// 000000001001010110011110011000101000110001111001011 +// 0000000010010101100111100110001010001100011110011 +// 00000000100101011001111001100010100011000111101 +// 0000000010010101100111100110001010001100011111 +// 00000000100101011001111001100010100011001 +// 0000000010010101100111100110001010001101 +// 000000001001010110011110011000101000111 +// 000000001001010110011110011000101001 +// 00000000100101011001111001100010101 +// 0000000010010101100111100110001011 +// 00000000100101011001111001100011 +// 000000001001010110011110011001 +// 00000000100101011001111001101 +// 0000000010010101100111100111 +// 0000000010010101100111101 +// 000000001001010110011111 +// 0000000010010101101 +// 000000001001010111 +// 000000001001011 +// 0000000010011 +// 00000000101 +// 0000000011 +// 00000001 +// 0000001 +// 000001 +// 0000100 +// 000010100 +// 0000101010 +// 000010101100000 +// 000010101100001000 +// 0000101011000010010 +// 000010101100001001100 +// 000010101100001001101000 +// 00001010110000100110100100 +// 0000101011000010011010010100 +// 00001010110000100110100101010 +// 00001010110000100110100101011000 +// 00001010110000100110100101011001000 +// 0000101011000010011010010101100100100 +// 00001010110000100110100101011001001010 +// 000010101100001001101001010110010010110 +// 0000101011000010011010010101100100101110 +// 000010101100001001101001010110010010111100 +// 0000101011000010011010010101100100101111010 +// 00001010110000100110100101011001001011110110 +// 000010101100001001101001010110010010111101110 +// 000010101100001001101001010110010010111101111000 +// 00001010110000100110100101011001001011110111100100 +// 000010101100001001101001010110010010111101111001010 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 14, +// R"(000001110100111000111011110011111101101111101100011 +// 0000011101001110001110111100111111011011111011001 +// 000001110100111000111011110011111101101111101101 +// 00000111010011100011101111001111110110111110111 +// 00000111010011100011101111001111110110111111 +// 00000111010011100011101111001111110111 +// 00000111010011100011101111001111111 +// 0000011101001110001110111101 +// 000001110100111000111011111 +// 0000011101001110001111 +// 000001110100111001 +// 00000111010011101 +// 0000011101001111 +// 000001110101 +// 00000111011 +// 000001111 +// 00001 +// 0001 +// 001 +// 01 +// 100000 +// 1000010 +// 1000011000 +// 10000110010 +// 100001100110 +// 1000011001110 +// 10000110011110 +// 100001100111110 +// 1000011001111110000 +// 1000011001111110001000 +// 1000011001111110001001000 +// 10000110011111100010010010 +// 1000011001111110001001001100 +// 10000110011111100010010011010 +// 1000011001111110001001001101100 +// 100001100111111000100100110110100 +// 1000011001111110001001001101101010 +// 100001100111111000100100110110101100 +// 1000011001111110001001001101101011010000 +// 100001100111111000100100110110101101000100 +// 1000011001111110001001001101101011010001010 +// 100001100111111000100100110110101101000101100 +// 1000011001111110001001001101101011010001011010 +// 10000110011111100010010011011010110100010110110000 +// 100001100111111000100100110110101101000101101100010 +// 1000011001111110001001001101101011010001011011000110000 +// )"}, + +// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 15, +// R"(00000100100100001110010101100001111010010111001110111011011 +// 000001001001000011100101011000011110100101110011101110111 +// 000001001001000011100101011000011110100101110011101111 +// 00000100100100001110010101100001111010010111001111 +// 0000010010010000111001010110000111101001011101 +// 000001001001000011100101011000011110100101111 +// 00000100100100001110010101100001111010011 +// 000001001001000011100101011000011110101 +// 00000100100100001110010101100001111011 +// 000001001001000011100101011000011111 +// 0000010010010000111001010110001 +// 000001001001000011100101011001 +// 00000100100100001110010101101 +// 0000010010010000111001010111 +// 0000010010010000111001011 +// 00000100100100001110011 +// 000001001001000011101 +// 00000100100100001111 +// 0000010010010001 +// 000001001001001 +// 00000100100101 +// 0000010010011 +// 00000100101 +// 0000010011 +// 00000101 +// 0000011 +// 00001 +// 0001 +// 001 +// 0100 +// 010100 +// 0101010000000 +// 01010100000010 +// 010101000000110 +// 01010100000011100 +// 010101000000111010 +// 01010100000011101100 +// 0101010000001110110100 +// 01010100000011101101010 +// 010101000000111011010110 +// 01010100000011101101011100000 +// 010101000000111011010111000010000 +// 0101010000001110110101110000100010 +// 010101000000111011010111000010001100000 +// 01010100000011101101011100001000110000100 +// 010101000000111011010111000010001100001010 +// 0101010000001110110101110000100011000010110 +// 01010100000011101101011100001000110000101110000 +// 010101000000111011010111000010001100001011100010 +// 0101010000001110110101110000100011000010111000110 +// 010101000000111011010111000010001100001011100011100 +// 0101010000001110110101110000100011000010111000111010 +// 01010100000011101101011100001000110000101110001110110 +// 0101010000001110110101110000100011000010111000111011100 +// 01010100000011101101011100001000110000101110001110111010 +// 010101000000111011010111000010001100001011100011101110110 +// )"}, + diff --git a/src/mongo/platform/decimal128.cpp b/src/mongo/platform/decimal128.cpp index 630d2037b50..04d18f2d211 100644 --- a/src/mongo/platform/decimal128.cpp +++ b/src/mongo/platform/decimal128.cpp @@ -893,6 +893,15 @@ Decimal128 Decimal128::power(const Decimal128& other, return Decimal128{libraryTypeToValue(result)}.add(kLargestNegativeExponentZero); } +Decimal128 Decimal128::scale(int n, RoundingMode roundMode) const { + std::uint32_t throwAwayFlag = 0; + BID_UINT128 x = decimal128ToLibraryType(_value); + + BID_UINT128 result = bid128_scalbn(x, n, roundMode, &throwAwayFlag); + return Decimal128{libraryTypeToValue(result)}; + ; +} + Decimal128 Decimal128::nonNormalizingQuantize(const Decimal128& other, RoundingMode roundMode) const { std::uint32_t throwAwayFlag = 0; diff --git a/src/mongo/platform/decimal128.h b/src/mongo/platform/decimal128.h index 34002337786..6e788f75d8b 100644 --- a/src/mongo/platform/decimal128.h +++ b/src/mongo/platform/decimal128.h @@ -487,6 +487,8 @@ public: Decimal128 squareRoot(std::uint32_t* signalingFlags, RoundingMode roundMode = kRoundTiesToEven) const; + Decimal128 scale(int n, RoundingMode roundMode = kRoundTiesToEven) const; + /** * This function quantizes the current decimal given a quantum reference */ -- cgit v1.2.1