pax_global_header00006660000000000000000000000064145002232500014503gustar00rootroot0000000000000052 comment=cb6ebb8e161b24c7a21963bb05a275146ae4eaeb apd-3.2.1/000077500000000000000000000000001450022325000122525ustar00rootroot00000000000000apd-3.2.1/.github/000077500000000000000000000000001450022325000136125ustar00rootroot00000000000000apd-3.2.1/.github/workflows/000077500000000000000000000000001450022325000156475ustar00rootroot00000000000000apd-3.2.1/.github/workflows/go.yml000066400000000000000000000053661450022325000170110ustar00rootroot00000000000000name: Go on: push: branches: - master pull_request: branches: - master jobs: build: runs-on: ubuntu-latest strategy: matrix: arch: - x64 - armv7 - aarch64 go: - '1.13' - '1.14' - '1.15' - '1.16' - '1.17' - '1.18' - '1.19' - '1.20' steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: '${{ matrix.go }}' - name: 'Build' if: ${{ matrix.arch == 'x64' }} run: go build -v ./... - name: 'Test' if: ${{ matrix.arch == 'x64' }} run: go test -v ./... - name: 'TestRace' if: ${{ matrix.arch == 'x64' }} run: go test -race -v ./... - name: 'Bench' if: ${{ matrix.arch == 'x64' }} run: go test -run=- -bench=. -benchtime=1x -v ./... - name: 'BenchRace' if: ${{ matrix.arch == 'x64' }} run: go test -run=- -bench=. -benchtime=1x -race -v ./... - name: 'Vet' if: ${{ matrix.arch == 'x64' }} # -unsafeptr=false is needed because of the noescape function in bigint.go. run: go vet -unsafeptr=false ./... - name: 'Staticcheck' # staticcheck requires go1.19. if: ${{ matrix.arch == 'x64' && matrix.go >= '1.19' }} run: | go install honnef.co/go/tools/cmd/staticcheck@v0.4.3 staticcheck ./... - name: 'GCAssert' # Only run gcassert on the latest versions of Go. Inlining heuristics # change from version to version. if: ${{ matrix.arch == 'x64' && matrix.go >= '1.17' }} run: | go install github.com/jordanlewis/gcassert/cmd/gcassert@latest gcassert ./... - name: 'BuildTest for armv7' if: ${{ matrix.arch == 'armv7' }} env: GOARCH: arm GOARM: 7 run: go test -c ./... - name: 'BuildTest for aarch64' if: ${{ matrix.arch == 'aarch64' }} env: GOARCH: arm64 run: go test -c ./... - name: 'Test and Bench on ${{ matrix.arch }}' # arch != 'x64': we already tested on x86 above. # go != '1.13': go1.13 + arm is significantly slower, so don't run test suite. if: ${{ matrix.arch != 'x64' && matrix.go != '1.13' }} uses: uraimo/run-on-arch-action@v2.1.1 with: arch: ${{ matrix.arch }} distro: ubuntu20.04 dockerRunArgs: --mount type=bind,source="$(pwd)",target=/checkout,readonly run: | find /checkout -name '*.test' -type f -executable -print0 | xargs -0 -I '{}' sh -c '{} -test.run=. -test.bench=. -test.benchtime=1x -test.v' apd-3.2.1/LICENSE000066400000000000000000000260371450022325000132670ustar00rootroot00000000000000Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. apd-3.2.1/README.md000066400000000000000000000066311450022325000135370ustar00rootroot00000000000000# apd apd is an arbitrary-precision decimal package for Go. `apd` implements much of the decimal specification from the [General Decimal Arithmetic](http://speleotrove.com/decimal/) description. This is the same specification implemented by [python’s decimal module](https://docs.python.org/2/library/decimal.html) and GCC’s decimal extension. ## Features - **Panic-free operation**. The `math/big` types don’t return errors, and instead panic under some conditions that are documented. This requires users to validate the inputs before using them. Meanwhile, we’d like our decimal operations to have more failure modes and more input requirements than the `math/big` types, so using that API would be difficult. `apd` instead returns errors when needed. - **Support for standard functions**. `sqrt`, `ln`, `pow`, etc. - **Accurate and configurable precision**. Operations will use enough internal precision to produce a correct result at the requested precision. Precision is set by a "context" structure that accompanies the function arguments, as discussed in the next section. - **Good performance**. Operations will either be fast enough or will produce an error if they will be slow. This prevents edge-case operations from consuming lots of CPU or memory. - **Condition flags and traps**. All operations will report whether their result is exact, is rounded, is over- or under-flowed, is [subnormal](https://en.wikipedia.org/wiki/Denormal_number), or is some other condition. `apd` supports traps which will trigger an error on any of these conditions. This makes it possible to guarantee exactness in computations, if needed. `apd` has three main types. The first is [`BigInt`](https://godoc.org/github.com/cockroachdb/apd#BigInt) which is a wrapper around `big.Int` that exposes an identical API while reducing memory allocations. `BigInt` does so by using an inline array to back the `big.Int`'s variable-length value when the integer's absolute value is sufficiently small. `BigInt` also contains fast-paths that allow it to perform basic arithmetic directly on this inline array, only falling back to `big.Int` when the arithmetic gets complex or takes place on large values. The second is [`Decimal`](https://godoc.org/github.com/cockroachdb/apd#Decimal) which holds the values of decimals. It is simple and uses a `BigInt` with an exponent to describe values. Most operations on `Decimal`s can’t produce errors as they work directly on the underlying `big.Int`. Notably, however, there are no arithmetic operations on `Decimal`s. The third main type is [`Context`](https://godoc.org/github.com/cockroachdb/apd#Context), which is where all arithmetic operations are defined. A `Context` describes the precision, range, and some other restrictions during operations. These operations can all produce failures, and so return errors. `Context` operations, in addition to errors, return a [`Condition`](https://godoc.org/github.com/cockroachdb/apd#Condition), which is a bitfield of flags that occurred during an operation. These include overflow, underflow, inexact, rounded, and others. The `Traps` field of a `Context` can be set which will produce an error if the corresponding flag occurs. An example of this is given below. See the [examples](https://godoc.org/github.com/cockroachdb/apd#pkg-examples) for some operations that were previously difficult to perform in Go. ## Documentation https://pkg.go.dev/github.com/cockroachdb/apd/v3?tab=doc apd-3.2.1/bench_test.go000066400000000000000000000071561450022325000147300ustar00rootroot00000000000000// Copyright 2017 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "bytes" "fmt" "math/rand" "testing" ) // runBenches benchmarks a given function on random decimals on combinations of // three parameters: // // precision: desired output precision // inScale: the scale of the input decimal: the absolute value will be between // 10^inScale and 10^(inScale+1) // inNumDigits: number of digits in the input decimal; if negative the number // will be negative and the number of digits are the absolute value. func runBenches( b *testing.B, precision, inScale, inNumDigits []int, fn func(*testing.B, *Context, *Decimal), ) { for _, p := range precision { ctx := BaseContext.WithPrecision(uint32(p)) for _, s := range inScale { for _, d := range inNumDigits { numDigits := d negative := false if d < 0 { numDigits = -d negative = true } if numDigits > p { // Skip cases where we have more digits than the desired precision. continue } // Generate some random numbers with the given number of digits. nums := make([]Decimal, 20) for i := range nums { var buf bytes.Buffer if negative { buf.WriteByte('-') } buf.WriteByte('1' + byte(rand.Intn(9))) for j := 1; j < numDigits; j++ { buf.WriteByte('0' + byte(rand.Intn(10))) } if _, _, err := nums[i].SetString(buf.String()); err != nil { b.Fatal(err) } nums[i].Exponent = int32(s - numDigits) } b.Run( fmt.Sprintf("P%d/S%d/D%d", p, s, d), func(b *testing.B) { for i := 0; i <= b.N; i++ { fn(b, ctx, &nums[i%len(nums)]) } }, ) } } } } func BenchmarkExp(b *testing.B) { precision := []int{5, 10, 100} scale := []int{-4, -1, 2} digits := []int{-100, -10, -2, 2, 10, 100} runBenches( b, precision, scale, digits, func(b *testing.B, ctx *Context, x *Decimal) { if _, err := ctx.Exp(&Decimal{}, x); err != nil { b.Fatal(err) } }, ) } func BenchmarkLn(b *testing.B) { precision := []int{2, 10, 100} scale := []int{-100, -10, -2, 2, 10, 100} digits := []int{2, 10, 100} runBenches( b, precision, scale, digits, func(b *testing.B, ctx *Context, x *Decimal) { if _, err := ctx.Ln(&Decimal{}, x); err != nil { b.Fatal(err) } }, ) } func BenchmarkDecimalString(b *testing.B) { rng := rand.New(rand.NewSource(461210934723948)) corpus := func() []Decimal { res := make([]Decimal, 8192) for i := range res { _, err := res[i].SetFloat64(rng.Float64()) if err != nil { b.Fatal(err) } } return res }() b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { _ = corpus[rng.Intn(len(corpus))].String() } } func BenchmarkDecimalSetFloat(b *testing.B) { rng := rand.New(rand.NewSource(461210934723948)) corpus := func() []float64 { res := make([]float64, 8192) for i := range res { res[i] = rng.ExpFloat64() } return res }() b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { var d Decimal _, err := d.SetFloat64(corpus[rng.Intn(len(corpus))]) if err != nil { b.Fatal(err) } } } apd-3.2.1/bigint.go000066400000000000000000000672651450022325000140750ustar00rootroot00000000000000// Copyright 2022 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "fmt" "math/big" "math/bits" "math/rand" "strconv" "unsafe" ) // The inlineWords capacity is set to accommodate any value that would fit in a // 128-bit integer (i.e. values with an absolute value up to 2^128 - 1). const inlineWords = 128 / bits.UintSize // BigInt is a wrapper around big.Int. It minimizes memory allocation by using // an inline array to back the big.Int's variable-length "nat" slice when the // integer's value is sufficiently small. // The zero value is ready to use. type BigInt struct { // A wrapped big.Int. Only set to the BigInt's value when the value exceeds // what is representable in the _inline array. // // When the BigInt's value is still small enough to use the _inline array, // this field doubles as integer's negative flag. See negSentinel. // // Methods should access this field through inner. _inner *big.Int // The inlined backing array use for short-lived, stack-allocated big.Int // structs during arithmetic when the value is small. // // Each BigInt maintains (through big.Int) an internal reference to a // variable-length integer value, which is represented by a []big.Word. The // _inline field and the inner and updateInner methods combine to allow // BigInt to inline this variable-length integer array within the BigInt // struct when its value is sufficiently small. In the inner method, we // point a temporary big.Int's nat slice at this _inline array. big.Int will // avoid re-allocating this array until it is provided with a value that // exceeds the initial capacity. Later in updateInner, we detect whether the // array has been re-allocated. If so, we switch to using the _inner. If // not, we continue to use this array. _inline [inlineWords]big.Word } // NewBigInt allocates and returns a new BigInt set to x. // // NOTE: BigInt jumps through hoops to avoid escaping to the heap. As such, most // users of BigInt should not need this function. They should instead declare a // zero-valued BigInt directly on the stack and interact with references to this // stack-allocated value. Recall that the zero-valued BigInt is ready to use. func NewBigInt(x int64) *BigInt { return new(BigInt).SetInt64(x) } // Set as the value of BigInt._inner as a "sentinel" flag to indicate that a // BigInt is negative ((big.Int).Sign() < 0) but the absolute value is still // small enough to represent in the _inline array. var negSentinel = new(big.Int) // isInline returns whether the BigInt stores its value in its _inline array. //gcassert:inline func (z *BigInt) isInline() bool { return z._inner == nil || z._inner == negSentinel } // The memory representation of big.Int. Used for unsafe modification below. type intStruct struct { neg bool abs []big.Word } // noescape hides a pointer from escape analysis. noescape is the identity // function but escape analysis doesn't think the output depends on the input. // noescape is inlined and currently compiles down to zero instructions. // // USE CAREFULLY! // // This was copied from strings.Builder, which has identical code which was // itself copied from the runtime. // For more, see issues #23382 and #7921 in github.com/golang/go. //go:nosplit //go:nocheckptr func noescape(p unsafe.Pointer) unsafe.Pointer { x := uintptr(p) //lint:ignore SA4016 intentional no-op to hide pointer from escape analysis. return unsafe.Pointer(x ^ 0) } // inner returns the BigInt's current value as a *big.Int. // // NOTE: this was carefully written to permit function inlining. Modify with // care. //gcassert:inline func (z *BigInt) inner(tmp *big.Int) *big.Int { // Point the big.Int at the inline array. When doing so, use noescape to // avoid forcing the BigInt to escape to the heap. Go's escape analysis // struggles with self-referential pointers, and it can't prove that we // only assign _inner to a heap-allocated object (which must not contain // pointers that reference the stack or the GC explodes) if the big.Int's // backing array has been re-allocated onto the heap first. // // NOTE: SetBits sets the neg field to false, so this must come before the // negSentinel handling. tmp.SetBits((*[inlineWords]big.Word)(noescape(unsafe.Pointer(&z._inline[0])))[:]) if z._inner != nil { if z._inner != negSentinel { // The variable-length big.Int reference is set. return z._inner } // This is the negative sentinel, which indicates that the integer is // negative but still stored inline. Update the big.Int accordingly. We // use unsafe because (*big.Int).Neg is too complex and prevents this // method from being inlined. (*intStruct)(unsafe.Pointer(tmp)).neg = true } return tmp } // innerOrNil is like inner, but returns a nil *big.Int if the receiver is nil. // NOTE: this is not inlined. func (z *BigInt) innerOrNil(tmp *big.Int) *big.Int { if z == nil { return nil } return z.inner(tmp) } // innerOrAlias is like inner, but returns the provided *big.Int if the receiver // and the other *BigInt argument reference the same object. // NOTE: this is not inlined. func (z *BigInt) innerOrAlias(tmp *big.Int, a *BigInt, ai *big.Int) *big.Int { if a == z { return ai } return z.inner(tmp) } // innerOrNilOrAlias is like inner, but with the added semantics specified for // both innerOrNil and innerOrAlias. // NOTE: this is not inlined. func (z *BigInt) innerOrNilOrAlias(tmp *big.Int, a *BigInt, ai *big.Int) *big.Int { if z == nil { return nil } else if z == a { return ai } return z.inner(tmp) } // updateInner updates the BigInt's current value with the provided *big.Int. // // NOTE: this was carefully written to permit function inlining. Modify with // care. //gcassert:inline func (z *BigInt) updateInner(src *big.Int) { if z._inner == src { return } bits := src.Bits() bitsLen := len(bits) if bitsLen > 0 && &z._inline[0] != &bits[0] { // The big.Int re-allocated its backing array during arithmetic because // the value grew beyond what could fit in the _inline array. Switch to // a heap-allocated, variable-length big.Int and store that in _inner. // From now on, all arithmetic will use this big.Int directly. // // Allocate a new big.Int and perform a shallow-copy of the argument to // prevent it from escaping off the stack. z._inner = new(big.Int) *z._inner = *src } else { // Zero out all words beyond the end of the big.Int's current Word // slice. big.Int arithmetic can sometimes leave these words "dirty". // They would cause issues when the _inline array is injected into the // next big.Int if not cleared. for bitsLen < len(z._inline) { z._inline[bitsLen] = 0 bitsLen++ } // Set or unset the negative sentinel, according to the argument's sign. // We use unsafe because (*big.Int).Sign is too complex and prevents // this method from being inlined. if (*intStruct)(unsafe.Pointer(src)).neg { z._inner = negSentinel } else { z._inner = nil } } } const wordsInUint64 = 64 / bits.UintSize func init() { if inlineWords < wordsInUint64 { panic("inline array must be at least 64 bits large") } } // innerAsUint64 returns the BigInt's current absolute value as a uint64 and a // flag indicating whether the value is negative. If the value is not stored // inline or if it can not fit in a uint64, false is returned. // // NOTE: this was carefully written to permit function inlining. Modify with // care. //gcassert:inline func (z *BigInt) innerAsUint64() (val uint64, neg bool, ok bool) { if !z.isInline() { // The value is not stored inline. return 0, false, false } if wordsInUint64 == 1 && inlineWords == 2 { // Manually unrolled loop for current inlineWords setting. if z._inline[1] != 0 { // The value can not fit in a uint64. return 0, false, false } } else { // Fallback for other values of inlineWords. for i := wordsInUint64; i < len(z._inline); i++ { if z._inline[i] != 0 { // The value can not fit in a uint64. return 0, false, false } } } val = uint64(z._inline[0]) if wordsInUint64 == 2 { // From big.low64. val = uint64(z._inline[1])<<32 | val } neg = z._inner == negSentinel return val, neg, true } // updateInnerFromUint64 updates the BigInt's current value with the provided // absolute value and sign. // // NOTE: this was carefully written to permit function inlining. Modify with // care. //gcassert:inline func (z *BigInt) updateInnerFromUint64(val uint64, neg bool) { // Set the inline value. z._inline[0] = big.Word(val) if wordsInUint64 == 2 { // From (big.nat).setUint64. z._inline[1] = big.Word(val >> 32) } // Clear out all other words in the inline array. if wordsInUint64 == 1 && inlineWords == 2 { // Manually unrolled loop for current inlineWords setting. z._inline[1] = 0 } else { // Fallback for other values of inlineWords. for i := wordsInUint64; i < len(z._inline); i++ { z._inline[i] = 0 } } // Set or unset the negative sentinel. if neg { z._inner = negSentinel } else { z._inner = nil } } const ( bigIntSize = unsafe.Sizeof(BigInt{}) mathBigIntSize = unsafe.Sizeof(big.Int{}) mathWordSize = unsafe.Sizeof(big.Word(0)) ) // Size returns the total memory footprint of z in bytes. func (z *BigInt) Size() uintptr { if z.isInline() { return bigIntSize } return bigIntSize + mathBigIntSize + uintptr(cap(z._inner.Bits()))*mathWordSize } /////////////////////////////////////////////////////////////////////////////// // inline arithmetic for small values // /////////////////////////////////////////////////////////////////////////////// //gcassert:inline func addInline(xVal, yVal uint64, xNeg, yNeg bool) (zVal uint64, zNeg, ok bool) { if xNeg == yNeg { sum, carry := bits.Add64(xVal, yVal, 0) overflow := carry != 0 return sum, xNeg, !overflow } diff, borrow := bits.Sub64(xVal, yVal, 0) if borrow != 0 { // underflow xNeg = !xNeg diff = yVal - xVal } if diff == 0 { xNeg = false } return diff, xNeg, true } //gcassert:inline func mulInline(xVal, yVal uint64, xNeg, yNeg bool) (zVal uint64, zNeg, ok bool) { hi, lo := bits.Mul64(xVal, yVal) neg := xNeg != yNeg overflow := hi != 0 return lo, neg, !overflow } //gcassert:inline func quoInline(xVal, yVal uint64, xNeg, yNeg bool) (quoVal uint64, quoNeg, ok bool) { if yVal == 0 { // divide by 0 return 0, false, false } quo := xVal / yVal neg := xNeg != yNeg return quo, neg, true } //gcassert:inline func remInline(xVal, yVal uint64, xNeg, yNeg bool) (remVal uint64, remNeg, ok bool) { if yVal == 0 { // divide by 0 return 0, false, false } rem := xVal % yVal return rem, xNeg, true } /////////////////////////////////////////////////////////////////////////////// // big.Int API wrapper methods // /////////////////////////////////////////////////////////////////////////////// // Abs calls (big.Int).Abs. func (z *BigInt) Abs(x *BigInt) *BigInt { if x.isInline() { z._inline = x._inline z._inner = nil // !negSentinel return z } var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Abs(x.inner(&tmp2)) z.updateInner(zi) return z } // Add calls (big.Int).Add. func (z *BigInt) Add(x, y *BigInt) *BigInt { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if zVal, zNeg, ok := addInline(xVal, yVal, xNeg, yNeg); ok { z.updateInnerFromUint64(zVal, zNeg) return z } } } var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Add(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // And calls (big.Int).And. func (z *BigInt) And(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.And(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // AndNot calls (big.Int).AndNot. func (z *BigInt) AndNot(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.AndNot(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // Append calls (big.Int).Append. func (z *BigInt) Append(buf []byte, base int) []byte { if z == nil { // Fast-path that avoids innerOrNil, allowing inner to be inlined. return append(buf, ""...) } if zVal, zNeg, ok := z.innerAsUint64(); ok { // Check if the base is supported by strconv.AppendUint. if base >= 2 && base <= 36 { if zNeg { buf = append(buf, '-') } return strconv.AppendUint(buf, zVal, base) } } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Append(buf, base) } // Binomial calls (big.Int).Binomial. func (z *BigInt) Binomial(n, k int64) *BigInt { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Binomial(n, k) z.updateInner(zi) return z } // Bit calls (big.Int).Bit. func (z *BigInt) Bit(i int) uint { if i == 0 && z.isInline() { // Optimization for common case: odd/even test of z. return uint(z._inline[0] & 1) } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Bit(i) } // BitLen calls (big.Int).BitLen. func (z *BigInt) BitLen() int { if z.isInline() { // Find largest non-zero inline word. for i := len(z._inline) - 1; i >= 0; i-- { if z._inline[i] != 0 { return i*bits.UintSize + bits.Len(uint(z._inline[i])) } } return 0 } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).BitLen() } // Bits calls (big.Int).Bits. func (z *BigInt) Bits() []big.Word { var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Bits() } // Bytes calls (big.Int).Bytes. func (z *BigInt) Bytes() []byte { var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Bytes() } // Cmp calls (big.Int).Cmp. func (z *BigInt) Cmp(y *BigInt) (r int) { if zVal, zNeg, ok := z.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { switch { case zNeg == yNeg: switch { case zVal < yVal: r = -1 case zVal > yVal: r = 1 } if zNeg { r = -r } case zNeg: r = -1 default: r = 1 } return r } } var tmp1, tmp2 big.Int //gcassert:noescape return z.inner(&tmp1).Cmp(y.inner(&tmp2)) } // CmpAbs calls (big.Int).CmpAbs. func (z *BigInt) CmpAbs(y *BigInt) (r int) { if zVal, _, ok := z.innerAsUint64(); ok { if yVal, _, ok := y.innerAsUint64(); ok { switch { case zVal < yVal: r = -1 case zVal > yVal: r = 1 } return r } } var tmp1, tmp2 big.Int //gcassert:noescape return z.inner(&tmp1).CmpAbs(y.inner(&tmp2)) } // Div calls (big.Int).Div. func (z *BigInt) Div(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Div(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // DivMod calls (big.Int).DivMod. func (z *BigInt) DivMod(x, y, m *BigInt) (*BigInt, *BigInt) { var tmp1, tmp2, tmp3, tmp4 big.Int //gcassert:noescape zi := z.inner(&tmp1) mi := m.inner(&tmp2) // NOTE: innerOrAlias for the y param because (big.Int).DivMod needs to // detect when y is aliased to the receiver. zi.DivMod(x.inner(&tmp3), y.innerOrAlias(&tmp4, z, zi), mi) z.updateInner(zi) m.updateInner(mi) return z, m } // Exp calls (big.Int).Exp. func (z *BigInt) Exp(x, y, m *BigInt) *BigInt { var tmp1, tmp2, tmp3, tmp4 big.Int //gcassert:noescape zi := z.inner(&tmp1) if zi.Exp(x.inner(&tmp2), y.inner(&tmp3), m.innerOrNil(&tmp4)) == nil { return nil } z.updateInner(zi) return z } // Format calls (big.Int).Format. func (z *BigInt) Format(s fmt.State, ch rune) { var tmp1 big.Int //gcassert:noescape z.innerOrNil(&tmp1).Format(s, ch) } // GCD calls (big.Int).GCD. func (z *BigInt) GCD(x, y, a, b *BigInt) *BigInt { var tmp1, tmp2, tmp3, tmp4, tmp5 big.Int //gcassert:noescape zi := z.inner(&tmp1) ai := a.inner(&tmp2) bi := b.inner(&tmp3) xi := x.innerOrNil(&tmp4) // NOTE: innerOrNilOrAlias for the y param because (big.Int).GCD needs to // detect when y is aliased to b. See "avoid aliasing b" in lehmerGCD. yi := y.innerOrNilOrAlias(&tmp5, b, bi) zi.GCD(xi, yi, ai, bi) z.updateInner(zi) if xi != nil { x.updateInner(xi) } if yi != nil { y.updateInner(yi) } return z } // GobEncode calls (big.Int).GobEncode. func (z *BigInt) GobEncode() ([]byte, error) { var tmp1 big.Int //gcassert:noescape return z.innerOrNil(&tmp1).GobEncode() } // GobDecode calls (big.Int).GobDecode. func (z *BigInt) GobDecode(buf []byte) error { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) if err := zi.GobDecode(buf); err != nil { return err } z.updateInner(zi) return nil } // Int64 calls (big.Int).Int64. func (z *BigInt) Int64() int64 { if zVal, zNeg, ok := z.innerAsUint64(); ok { // The unchecked cast from uint64 to int64 looks unsafe, but it is // allowed and is identical to the logic in (big.Int).Int64. Per the // method's contract: // > If z cannot be represented in an int64, the result is undefined. zi := int64(zVal) if zNeg { zi = -zi } return zi } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Int64() } // IsInt64 calls (big.Int).IsInt64. func (z *BigInt) IsInt64() bool { if zVal, zNeg, ok := z.innerAsUint64(); ok { // From (big.Int).IsInt64. zi := int64(zVal) return zi >= 0 || zNeg && zi == -zi } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).IsInt64() } // IsUint64 calls (big.Int).IsUint64. func (z *BigInt) IsUint64() bool { if _, zNeg, ok := z.innerAsUint64(); ok { return !zNeg } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).IsUint64() } // Lsh calls (big.Int).Lsh. func (z *BigInt) Lsh(x *BigInt, n uint) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Lsh(x.inner(&tmp2), n) z.updateInner(zi) return z } // MarshalJSON calls (big.Int).MarshalJSON. func (z *BigInt) MarshalJSON() ([]byte, error) { var tmp1 big.Int //gcassert:noescape return z.innerOrNil(&tmp1).MarshalJSON() } // MarshalText calls (big.Int).MarshalText. func (z *BigInt) MarshalText() (text []byte, err error) { var tmp1 big.Int //gcassert:noescape return z.innerOrNil(&tmp1).MarshalText() } // Mod calls (big.Int).Mod. func (z *BigInt) Mod(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) // NOTE: innerOrAlias for the y param because (big.Int).Mod needs to detect // when y is aliased to the receiver. zi.Mod(x.inner(&tmp2), y.innerOrAlias(&tmp3, z, zi)) z.updateInner(zi) return z } // ModInverse calls (big.Int).ModInverse. func (z *BigInt) ModInverse(g, n *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) if zi.ModInverse(g.inner(&tmp2), n.inner(&tmp3)) == nil { return nil } z.updateInner(zi) return z } // ModSqrt calls (big.Int).ModSqrt. func (z *BigInt) ModSqrt(x, p *BigInt) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape var tmp3 big.Int // escapes because of https://github.com/golang/go/pull/50527. zi := z.inner(&tmp1) if zi.ModSqrt(x.inner(&tmp2), p.inner(&tmp3)) == nil { return nil } z.updateInner(zi) return z } // Mul calls (big.Int).Mul. func (z *BigInt) Mul(x, y *BigInt) *BigInt { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if zVal, zNeg, ok := mulInline(xVal, yVal, xNeg, yNeg); ok { z.updateInnerFromUint64(zVal, zNeg) return z } } } var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Mul(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // MulRange calls (big.Int).MulRange. func (z *BigInt) MulRange(x, y int64) *BigInt { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.MulRange(x, y) z.updateInner(zi) return z } // Neg calls (big.Int).Neg. func (z *BigInt) Neg(x *BigInt) *BigInt { if x.isInline() { z._inline = x._inline if x._inner == negSentinel { z._inner = nil } else { z._inner = negSentinel } return z } var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Neg(x.inner(&tmp2)) z.updateInner(zi) return z } // Not calls (big.Int).Not. func (z *BigInt) Not(x *BigInt) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Not(x.inner(&tmp2)) z.updateInner(zi) return z } // Or calls (big.Int).Or. func (z *BigInt) Or(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Or(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // ProbablyPrime calls (big.Int).ProbablyPrime. func (z *BigInt) ProbablyPrime(n int) bool { var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).ProbablyPrime(n) } // Quo calls (big.Int).Quo. func (z *BigInt) Quo(x, y *BigInt) *BigInt { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if quoVal, quoNeg, ok := quoInline(xVal, yVal, xNeg, yNeg); ok { z.updateInnerFromUint64(quoVal, quoNeg) return z } } } var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Quo(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // QuoRem calls (big.Int).QuoRem. func (z *BigInt) QuoRem(x, y, r *BigInt) (*BigInt, *BigInt) { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if quoVal, quoNeg, ok := quoInline(xVal, yVal, xNeg, yNeg); ok { if remVal, remNeg, ok := remInline(xVal, yVal, xNeg, yNeg); ok { z.updateInnerFromUint64(quoVal, quoNeg) r.updateInnerFromUint64(remVal, remNeg) return z, r } } } } var tmp1, tmp2, tmp3, tmp4 big.Int //gcassert:noescape zi := z.inner(&tmp1) ri := r.inner(&tmp2) zi.QuoRem(x.inner(&tmp3), y.inner(&tmp4), ri) z.updateInner(zi) r.updateInner(ri) return z, r } // Rand calls (big.Int).Rand. func (z *BigInt) Rand(rnd *rand.Rand, n *BigInt) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Rand(rnd, n.inner(&tmp2)) z.updateInner(zi) return z } // Rem calls (big.Int).Rem. func (z *BigInt) Rem(x, y *BigInt) *BigInt { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if remVal, remNeg, ok := remInline(xVal, yVal, xNeg, yNeg); ok { z.updateInnerFromUint64(remVal, remNeg) return z } } } var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Rem(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // Rsh calls (big.Int).Rsh. func (z *BigInt) Rsh(x *BigInt, n uint) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Rsh(x.inner(&tmp2), n) z.updateInner(zi) return z } // Scan calls (big.Int).Scan. func (z *BigInt) Scan(s fmt.ScanState, ch rune) error { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) if err := zi.Scan(s, ch); err != nil { return err } z.updateInner(zi) return nil } // Set calls (big.Int).Set. func (z *BigInt) Set(x *BigInt) *BigInt { if x.isInline() { *z = *x return z } var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Set(x.inner(&tmp2)) z.updateInner(zi) return z } // SetBit calls (big.Int).SetBit. func (z *BigInt) SetBit(x *BigInt, i int, b uint) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.SetBit(x.inner(&tmp2), i, b) z.updateInner(zi) return z } // SetBits calls (big.Int).SetBits. func (z *BigInt) SetBits(abs []big.Word) *BigInt { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.SetBits(abs) z.updateInner(zi) return z } // SetBytes calls (big.Int).SetBytes. func (z *BigInt) SetBytes(buf []byte) *BigInt { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.SetBytes(buf) z.updateInner(zi) return z } // SetInt64 calls (big.Int).SetInt64. func (z *BigInt) SetInt64(x int64) *BigInt { neg := false if x < 0 { neg = true x = -x } z.updateInnerFromUint64(uint64(x), neg) return z } // SetString calls (big.Int).SetString. func (z *BigInt) SetString(s string, base int) (*BigInt, bool) { if i, err := strconv.ParseInt(s, base, 64); err == nil { z.SetInt64(i) return z, true } var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) if _, ok := zi.SetString(s, base); !ok { return nil, false } z.updateInner(zi) return z, true } // SetUint64 calls (big.Int).SetUint64. func (z *BigInt) SetUint64(x uint64) *BigInt { z.updateInnerFromUint64(x, false) return z } // Sign calls (big.Int).Sign. func (z *BigInt) Sign() int { if z._inner == nil { if z._inline == [inlineWords]big.Word{} { return 0 } return 1 } else if z._inner == negSentinel { return -1 } return z._inner.Sign() } // Sqrt calls (big.Int).Sqrt. func (z *BigInt) Sqrt(x *BigInt) *BigInt { var tmp1, tmp2 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Sqrt(x.inner(&tmp2)) z.updateInner(zi) return z } // String calls (big.Int).String. func (z *BigInt) String() string { if z == nil { // Fast-path that avoids innerOrNil, allowing inner to be inlined. return "" } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).String() } // Sub calls (big.Int).Sub. func (z *BigInt) Sub(x, y *BigInt) *BigInt { if xVal, xNeg, ok := x.innerAsUint64(); ok { if yVal, yNeg, ok := y.innerAsUint64(); ok { if zVal, zNeg, ok := addInline(xVal, yVal, xNeg, !yNeg); ok { z.updateInnerFromUint64(zVal, zNeg) return z } } } var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Sub(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } // Text calls (big.Int).Text. func (z *BigInt) Text(base int) string { if z == nil { // Fast-path that avoids innerOrNil, allowing inner to be inlined. return "" } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Text(base) } // TrailingZeroBits calls (big.Int).TrailingZeroBits. func (z *BigInt) TrailingZeroBits() uint { var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).TrailingZeroBits() } // Uint64 calls (big.Int).Uint64. func (z *BigInt) Uint64() uint64 { if zVal, _, ok := z.innerAsUint64(); ok { return zVal } var tmp1 big.Int //gcassert:noescape return z.inner(&tmp1).Uint64() } // UnmarshalJSON calls (big.Int).UnmarshalJSON. func (z *BigInt) UnmarshalJSON(text []byte) error { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) if err := zi.UnmarshalJSON(text); err != nil { return err } z.updateInner(zi) return nil } // UnmarshalText calls (big.Int).UnmarshalText. func (z *BigInt) UnmarshalText(text []byte) error { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) if err := zi.UnmarshalText(text); err != nil { return err } z.updateInner(zi) return nil } // Xor calls (big.Int).Xor. func (z *BigInt) Xor(x, y *BigInt) *BigInt { var tmp1, tmp2, tmp3 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Xor(x.inner(&tmp2), y.inner(&tmp3)) z.updateInner(zi) return z } /////////////////////////////////////////////////////////////////////////////// // apd.BigInt / math/big.Int interop // /////////////////////////////////////////////////////////////////////////////// // MathBigInt returns the math/big.Int representation of z. func (z *BigInt) MathBigInt() *big.Int { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) // NOTE: We can't return zi directly, because it may be pointing into z's // _inline array. We have disabled escape analysis for such aliasing, so // this would be unsafe as it would not force the receiver to escape and // could leave the return value pointing into stack memory. return new(big.Int).Set(zi) } // SetMathBigInt sets z to x and returns z. func (z *BigInt) SetMathBigInt(x *big.Int) *BigInt { var tmp1 big.Int //gcassert:noescape zi := z.inner(&tmp1) zi.Set(x) z.updateInner(zi) return z } apd-3.2.1/bigint_go1.14_test.go000066400000000000000000000115701450022325000161110ustar00rootroot00000000000000// Copyright 2022 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. //go:build go1.14 // +build go1.14 package apd import ( "testing" "testing/quick" ) ////////////////////////////////////////////////////////////////////////////////// // The following tests were copied from the standard library's math/big package // ////////////////////////////////////////////////////////////////////////////////// func checkGcd(aBytes, bBytes []byte) bool { x := new(BigInt) y := new(BigInt) a := new(BigInt).SetBytes(aBytes) b := new(BigInt).SetBytes(bBytes) d := new(BigInt).GCD(x, y, a, b) x.Mul(x, a) y.Mul(y, b) x.Add(x, y) return x.Cmp(d) == 0 } var gcdTests = []struct { d, x, y, a, b string }{ // a <= 0 || b <= 0 {"0", "0", "0", "0", "0"}, {"7", "0", "1", "0", "7"}, {"7", "0", "-1", "0", "-7"}, {"11", "1", "0", "11", "0"}, {"7", "-1", "-2", "-77", "35"}, {"935", "-3", "8", "64515", "24310"}, {"935", "-3", "-8", "64515", "-24310"}, {"935", "3", "-8", "-64515", "-24310"}, {"1", "-9", "47", "120", "23"}, {"7", "1", "-2", "77", "35"}, {"935", "-3", "8", "64515", "24310"}, {"935000000000000000", "-3", "8", "64515000000000000000", "24310000000000000000"}, {"1", "-221", "22059940471369027483332068679400581064239780177629666810348940098015901108344", "98920366548084643601728869055592650835572950932266967461790948584315647051443", "991"}, } func testGcd(t *testing.T, d, x, y, a, b *BigInt) { var X *BigInt if x != nil { X = new(BigInt) } var Y *BigInt if y != nil { Y = new(BigInt) } D := new(BigInt).GCD(X, Y, a, b) if D.Cmp(d) != 0 { t.Errorf("GCD(%s, %s, %s, %s): got d = %s, want %s", x, y, a, b, D, d) } if x != nil && X.Cmp(x) != 0 { t.Errorf("GCD(%s, %s, %s, %s): got x = %s, want %s", x, y, a, b, X, x) } if y != nil && Y.Cmp(y) != 0 { t.Errorf("GCD(%s, %s, %s, %s): got y = %s, want %s", x, y, a, b, Y, y) } // check results in presence of aliasing (issue #11284) a2 := new(BigInt).Set(a) b2 := new(BigInt).Set(b) a2.GCD(X, Y, a2, b2) // result is same as 1st argument if a2.Cmp(d) != 0 { t.Errorf("aliased z = a GCD(%s, %s, %s, %s): got d = %s, want %s", x, y, a, b, a2, d) } if x != nil && X.Cmp(x) != 0 { t.Errorf("aliased z = a GCD(%s, %s, %s, %s): got x = %s, want %s", x, y, a, b, X, x) } if y != nil && Y.Cmp(y) != 0 { t.Errorf("aliased z = a GCD(%s, %s, %s, %s): got y = %s, want %s", x, y, a, b, Y, y) } a2 = new(BigInt).Set(a) b2 = new(BigInt).Set(b) b2.GCD(X, Y, a2, b2) // result is same as 2nd argument if b2.Cmp(d) != 0 { t.Errorf("aliased z = b GCD(%s, %s, %s, %s): got d = %s, want %s", x, y, a, b, b2, d) } if x != nil && X.Cmp(x) != 0 { t.Errorf("aliased z = b GCD(%s, %s, %s, %s): got x = %s, want %s", x, y, a, b, X, x) } if y != nil && Y.Cmp(y) != 0 { t.Errorf("aliased z = b GCD(%s, %s, %s, %s): got y = %s, want %s", x, y, a, b, Y, y) } a2 = new(BigInt).Set(a) b2 = new(BigInt).Set(b) D = new(BigInt).GCD(a2, b2, a2, b2) // x = a, y = b if D.Cmp(d) != 0 { t.Errorf("aliased x = a, y = b GCD(%s, %s, %s, %s): got d = %s, want %s", x, y, a, b, D, d) } if x != nil && a2.Cmp(x) != 0 { t.Errorf("aliased x = a, y = b GCD(%s, %s, %s, %s): got x = %s, want %s", x, y, a, b, a2, x) } if y != nil && b2.Cmp(y) != 0 { t.Errorf("aliased x = a, y = b GCD(%s, %s, %s, %s): got y = %s, want %s", x, y, a, b, b2, y) } a2 = new(BigInt).Set(a) b2 = new(BigInt).Set(b) D = new(BigInt).GCD(b2, a2, a2, b2) // x = b, y = a if D.Cmp(d) != 0 { t.Errorf("aliased x = b, y = a GCD(%s, %s, %s, %s): got d = %s, want %s", x, y, a, b, D, d) } if x != nil && b2.Cmp(x) != 0 { t.Errorf("aliased x = b, y = a GCD(%s, %s, %s, %s): got x = %s, want %s", x, y, a, b, b2, x) } if y != nil && a2.Cmp(y) != 0 { t.Errorf("aliased x = b, y = a GCD(%s, %s, %s, %s): got y = %s, want %s", x, y, a, b, a2, y) } } // This was not supported in go1.13. See https://go.dev/doc/go1.14: // > The GCD method now allows the inputs a and b to be zero or negative. func TestBigIntGcd(t *testing.T) { for _, test := range gcdTests { d, _ := new(BigInt).SetString(test.d, 0) x, _ := new(BigInt).SetString(test.x, 0) y, _ := new(BigInt).SetString(test.y, 0) a, _ := new(BigInt).SetString(test.a, 0) b, _ := new(BigInt).SetString(test.b, 0) testGcd(t, d, nil, nil, a, b) testGcd(t, d, x, nil, a, b) testGcd(t, d, nil, y, a, b) testGcd(t, d, x, y, a, b) } if err := quick.Check(checkGcd, nil); err != nil { t.Error(err) } } apd-3.2.1/bigint_go1.15.go000066400000000000000000000014561450022325000150550ustar00rootroot00000000000000// Copyright 2022 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. //go:build go1.15 // +build go1.15 package apd import "math/big" // FillBytes calls (big.Int).FillBytes. func (z *BigInt) FillBytes(buf []byte) []byte { var tmp1 big.Int return z.inner(&tmp1).FillBytes(buf) } apd-3.2.1/bigint_go1.15_test.go000066400000000000000000000051561450022325000161150ustar00rootroot00000000000000// Copyright 2022 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. //go:build go1.15 // +build go1.15 package apd import ( "testing" "testing/quick" ) // TestBigIntMatchesMathBigInt15 is like TestBigIntMatchesMathBigInt, but for // parts of the shared BigInt/big.Int API that were introduced in go1.15. func TestBigIntMatchesMathBigInt15(t *testing.T) { t.Run("FillBytes", func(t *testing.T) { apd := func(z number) []byte { return z.toApd(t).FillBytes(make([]byte, len(z))) } math := func(z number) []byte { return z.toMath(t).FillBytes(make([]byte, len(z))) } require(t, quick.CheckEqual(apd, math, nil)) }) } ////////////////////////////////////////////////////////////////////////////////// // The following tests were copied from the standard library's math/big package // ////////////////////////////////////////////////////////////////////////////////// func TestBigIntFillBytes(t *testing.T) { checkResult := func(t *testing.T, buf []byte, want *BigInt) { t.Helper() got := new(BigInt).SetBytes(buf) if got.CmpAbs(want) != 0 { t.Errorf("got 0x%x, want 0x%x: %x", got, want, buf) } } panics := func(f func()) (panic bool) { defer func() { panic = recover() != nil }() f() return } for _, n := range []string{ "0", "1000", "0xffffffff", "-0xffffffff", "0xffffffffffffffff", "0x10000000000000000", "0xabababababababababababababababababababababababababa", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", } { t.Run(n, func(t *testing.T) { t.Logf(n) x, ok := new(BigInt).SetString(n, 0) if !ok { panic("invalid test entry") } // Perfectly sized buffer. byteLen := (x.BitLen() + 7) / 8 buf := make([]byte, byteLen) checkResult(t, x.FillBytes(buf), x) // Way larger, checking all bytes get zeroed. buf = make([]byte, 100) for i := range buf { buf[i] = 0xff } checkResult(t, x.FillBytes(buf), x) // Too small. if byteLen > 0 { buf = make([]byte, byteLen-1) if !panics(func() { x.FillBytes(buf) }) { t.Errorf("expected panic for small buffer and value %x", x) } } }) } } apd-3.2.1/bigint_test.go000066400000000000000000002420701450022325000151210ustar00rootroot00000000000000// Copyright 2022 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "bytes" "encoding/gob" "encoding/hex" "encoding/json" "encoding/xml" "fmt" "math" "math/big" "math/rand" "reflect" "strconv" "strings" "testing" "testing/quick" ) // TestBigIntMatchesMathBigInt uses testing/quick to verify that all methods on // apd.BigInt and math/big.Int have identical behavior for all inputs. func TestBigIntMatchesMathBigInt(t *testing.T) { // Catch specific panics and map to strings. const ( panicDivisionByZero = "division by zero" panicJacobi = "invalid 2nd argument to Int.Jacobi: need odd integer" panicNegativeBit = "negative bit index" panicSquareRootOfNegativeNum = "square root of negative number" ) catchPanic := func(fn func() string, catches ...string) (res string) { defer func() { if r := recover(); r != nil { if rs, ok := r.(string); ok { for _, catch := range catches { if strings.Contains(rs, catch) { res = fmt.Sprintf("caught: %s", r) } } } if res == "" { // not caught panic(r) } } }() return fn() } t.Run("Abs", func(t *testing.T) { apd := func(z, x number) string { return z.toApd(t).Abs(x.toApd(t)).String() } math := func(z, x number) string { return z.toMath(t).Abs(x.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Add", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).Add(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).Add(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("And", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).And(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).And(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("AndNot", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).AndNot(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).AndNot(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Append", func(t *testing.T) { apd := func(z numberOrNil) []byte { return z.toApd(t).Append(nil, 10) } math := func(z numberOrNil) []byte { return z.toMath(t).Append(nil, 10) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Binomial", func(t *testing.T) { t.Skip("too slow") apd := func(z number, n, k int64) string { return z.toApd(t).Binomial(n, k).String() } math := func(z number, n, k int64) string { return z.toMath(t).Binomial(n, k).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Bit", func(t *testing.T) { apd := func(z number, i int) string { return catchPanic(func() string { return strconv.FormatUint(uint64(z.toApd(t).Bit(i)), 10) }, panicNegativeBit) } math := func(z number, i int) string { return catchPanic(func() string { return strconv.FormatUint(uint64(z.toMath(t).Bit(i)), 10) }, panicNegativeBit) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("BitLen", func(t *testing.T) { apd := func(z number) int { return z.toApd(t).BitLen() } math := func(z number) int { return z.toMath(t).BitLen() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Bits", func(t *testing.T) { emptyToNil := func(w []big.Word) []big.Word { if len(w) == 0 { return nil } return w } apd := func(z number) []big.Word { return emptyToNil(z.toApd(t).Bits()) } math := func(z number) []big.Word { return emptyToNil(z.toMath(t).Bits()) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Bytes", func(t *testing.T) { apd := func(z number) []byte { return z.toApd(t).Bytes() } math := func(z number) []byte { return z.toMath(t).Bytes() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Cmp", func(t *testing.T) { apd := func(z, y number) int { return z.toApd(t).Cmp(y.toApd(t)) } math := func(z, y number) int { return z.toMath(t).Cmp(y.toMath(t)) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("CmpAbs", func(t *testing.T) { apd := func(z, y number) int { return z.toApd(t).CmpAbs(y.toApd(t)) } math := func(z, y number) int { return z.toMath(t).CmpAbs(y.toMath(t)) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Div", func(t *testing.T) { apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).Div(x.toApd(t), y.toApd(t)).String() }, panicDivisionByZero) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).Div(x.toMath(t), y.toMath(t)).String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("DivMod", func(t *testing.T) { apd := func(z, x, y, m number) string { return catchPanic(func() string { zi, mi := z.toApd(t), m.toApd(t) zi.DivMod(x.toApd(t), y.toApd(t), mi) return zi.String() + " | " + mi.String() }, panicDivisionByZero) } math := func(z, x, y, m number) string { return catchPanic(func() string { zi, mi := z.toMath(t), m.toMath(t) zi.DivMod(x.toMath(t), y.toMath(t), mi) return zi.String() + " | " + mi.String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Exp", func(t *testing.T) { t.Skip("too slow") apd := func(z, x, y, m number) string { return z.toApd(t).Exp(x.toApd(t), y.toApd(t), m.toApd(t)).String() } math := func(z, x, y, m number) string { return z.toMath(t).Exp(x.toMath(t), y.toMath(t), m.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Format", func(t *testing.T) { // Call indirectly through fmt.Sprint. apd := func(z numberOrNil) string { return fmt.Sprint(z.toApd(t)) } math := func(z numberOrNil) string { return fmt.Sprint(z.toMath(t)) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("GCD", func(t *testing.T) { apd := func(z number, x, y numberOrNil, a, b number) string { return z.toApd(t).GCD(x.toApd(t), y.toApd(t), a.toApd(t), b.toApd(t)).String() } math := func(z number, x, y numberOrNil, a, b number) string { return z.toMath(t).GCD(x.toMath(t), y.toMath(t), a.toMath(t), b.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("GobEncode", func(t *testing.T) { apd := func(z numberOrNil) ([]byte, error) { return z.toApd(t).GobEncode() } math := func(z numberOrNil) ([]byte, error) { return z.toMath(t).GobEncode() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("GobDecode", func(t *testing.T) { apd := func(z number, buf []byte) (string, error) { zi := z.toApd(t) err := zi.GobDecode(buf) return zi.String(), err } math := func(z number, buf []byte) (string, error) { zi := z.toMath(t) err := zi.GobDecode(buf) return zi.String(), err } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Int64", func(t *testing.T) { apd := func(z number) int64 { return z.toApd(t).Int64() } math := func(z number) int64 { return z.toMath(t).Int64() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("IsInt64", func(t *testing.T) { apd := func(z number) bool { return z.toApd(t).IsInt64() } math := func(z number) bool { return z.toMath(t).IsInt64() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("IsUint64", func(t *testing.T) { apd := func(z number) bool { return z.toApd(t).IsUint64() } math := func(z number) bool { return z.toMath(t).IsUint64() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Lsh", func(t *testing.T) { const maxShift = 1000 // avoid makeslice: len out of range apd := func(z, x number, n uint) string { if n > maxShift { n = maxShift } return z.toApd(t).Lsh(x.toApd(t), n).String() } math := func(z, x number, n uint) string { if n > maxShift { n = maxShift } return z.toMath(t).Lsh(x.toMath(t), n).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("MarshalJSON", func(t *testing.T) { apd := func(z numberOrNil) ([]byte, error) { return z.toApd(t).MarshalJSON() } math := func(z numberOrNil) ([]byte, error) { return z.toMath(t).MarshalJSON() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("MarshalText", func(t *testing.T) { apd := func(z numberOrNil) ([]byte, error) { return z.toApd(t).MarshalText() } math := func(z numberOrNil) ([]byte, error) { return z.toMath(t).MarshalText() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Mod", func(t *testing.T) { apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).Mod(x.toApd(t), y.toApd(t)).String() }, panicDivisionByZero, panicJacobi) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).Mod(x.toMath(t), y.toMath(t)).String() }, panicDivisionByZero, panicJacobi) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("ModInverse", func(t *testing.T) { apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).ModInverse(x.toApd(t), y.toApd(t)).String() }, panicDivisionByZero) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).ModInverse(x.toMath(t), y.toMath(t)).String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("ModSqrt", func(t *testing.T) { t.Skip("too slow") apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).ModSqrt(x.toApd(t), y.toApd(t)).String() }, panicJacobi) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).ModSqrt(x.toMath(t), y.toMath(t)).String() }, panicJacobi) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Mul", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).Mul(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).Mul(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("MulRange", func(t *testing.T) { t.Skip("too slow") apd := func(z number, x, y int64) string { return z.toApd(t).MulRange(x, y).String() } math := func(z number, x, y int64) string { return z.toMath(t).MulRange(x, y).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Neg", func(t *testing.T) { apd := func(z, x number) string { return z.toApd(t).Neg(x.toApd(t)).String() } math := func(z, x number) string { return z.toMath(t).Neg(x.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Not", func(t *testing.T) { apd := func(z, x number) string { return z.toApd(t).Not(x.toApd(t)).String() } math := func(z, x number) string { return z.toMath(t).Not(x.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Or", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).Or(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).Or(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("ProbablyPrime", func(t *testing.T) { apd := func(z number) bool { return z.toApd(t).ProbablyPrime(64) } math := func(z number) bool { return z.toMath(t).ProbablyPrime(64) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Quo", func(t *testing.T) { apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).Quo(x.toApd(t), y.toApd(t)).String() }, panicDivisionByZero) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).Quo(x.toMath(t), y.toMath(t)).String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("QuoRem", func(t *testing.T) { apd := func(z, x, y, r number) string { return catchPanic(func() string { zi, ri := z.toApd(t), r.toApd(t) zi.QuoRem(x.toApd(t), y.toApd(t), ri) return zi.String() + " | " + ri.String() }, panicDivisionByZero) } math := func(z, x, y, r number) string { return catchPanic(func() string { zi, ri := z.toMath(t), r.toMath(t) zi.QuoRem(x.toMath(t), y.toMath(t), ri) return zi.String() + " | " + ri.String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Rand", func(t *testing.T) { apd := func(z, n number, seed int64) string { rng := rand.New(rand.NewSource(seed)) return z.toApd(t).Rand(rng, n.toApd(t)).String() } math := func(z, n number, seed int64) string { rng := rand.New(rand.NewSource(seed)) return z.toMath(t).Rand(rng, n.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Rem", func(t *testing.T) { apd := func(z, x, y number) string { return catchPanic(func() string { return z.toApd(t).Rem(x.toApd(t), y.toApd(t)).String() }, panicDivisionByZero) } math := func(z, x, y number) string { return catchPanic(func() string { return z.toMath(t).Rem(x.toMath(t), y.toMath(t)).String() }, panicDivisionByZero) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Rsh", func(t *testing.T) { const maxShift = 1000 // avoid makeslice: len out of range apd := func(z, x number, n uint) string { if n > maxShift { n = maxShift } return z.toApd(t).Rsh(x.toApd(t), n).String() } math := func(z, x number, n uint) string { if n > maxShift { n = maxShift } return z.toMath(t).Rsh(x.toMath(t), n).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Scan", func(t *testing.T) { // Call indirectly through fmt.Sscan. apd := func(z, src number) (string, error) { zi := z.toApd(t) _, err := fmt.Sscan(string(src), zi) return zi.String(), err } math := func(z, src number) (string, error) { zi := z.toMath(t) _, err := fmt.Sscan(string(src), zi) return zi.String(), err } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Set", func(t *testing.T) { apd := func(z, x number) string { return z.toApd(t).Set(x.toApd(t)).String() } math := func(z, x number) string { return z.toMath(t).Set(x.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetBit", func(t *testing.T) { const maxBit = 1000 // avoid makeslice: len out of range apd := func(z, x number, i int, b bool) string { if i > maxBit { i = maxBit } bi := uint(0) if b { bi = 1 } return catchPanic(func() string { return z.toApd(t).SetBit(x.toApd(t), i, bi).String() }, panicNegativeBit) } math := func(z, x number, i int, b bool) string { if i > maxBit { i = maxBit } bi := uint(0) if b { bi = 1 } return catchPanic(func() string { return z.toMath(t).SetBit(x.toMath(t), i, bi).String() }, panicNegativeBit) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetBits", func(t *testing.T) { apd := func(z number, abs []big.Word) string { return z.toApd(t).SetBits(abs).String() } math := func(z number, abs []big.Word) string { return z.toMath(t).SetBits(abs).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetBytes", func(t *testing.T) { apd := func(z number, buf []byte) string { return z.toApd(t).SetBytes(buf).String() } math := func(z number, buf []byte) string { return z.toMath(t).SetBytes(buf).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetInt64", func(t *testing.T) { apd := func(z number, x int64) string { return z.toApd(t).SetInt64(x).String() } math := func(z number, x int64) string { return z.toMath(t).SetInt64(x).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetString", func(t *testing.T) { apd := func(z, x number) (string, bool) { zi, ok := z.toApd(t).SetString(string(x), 10) return zi.String(), ok } math := func(z, x number) (string, bool) { zi, ok := z.toMath(t).SetString(string(x), 10) return zi.String(), ok } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("SetUint64", func(t *testing.T) { apd := func(z number, x uint64) string { return z.toApd(t).SetUint64(x).String() } math := func(z number, x uint64) string { return z.toMath(t).SetUint64(x).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Sign", func(t *testing.T) { apd := func(z number) int { return z.toApd(t).Sign() } math := func(z number) int { return z.toMath(t).Sign() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Sqrt", func(t *testing.T) { apd := func(z, x number) string { return catchPanic(func() string { return z.toApd(t).Sqrt(x.toApd(t)).String() }, panicSquareRootOfNegativeNum) } math := func(z, x number) string { return catchPanic(func() string { return z.toMath(t).Sqrt(x.toMath(t)).String() }, panicSquareRootOfNegativeNum) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("String", func(t *testing.T) { apd := func(z numberOrNil) string { return z.toApd(t).String() } math := func(z numberOrNil) string { return z.toMath(t).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Sub", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).Sub(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).Sub(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Text", func(t *testing.T) { apd := func(z numberOrNil) string { return z.toApd(t).Text(10) } math := func(z numberOrNil) string { return z.toMath(t).Text(10) } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("TrailingZeroBits", func(t *testing.T) { apd := func(z number) uint { return z.toApd(t).TrailingZeroBits() } math := func(z number) uint { return z.toMath(t).TrailingZeroBits() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Uint64", func(t *testing.T) { apd := func(z number) uint64 { return z.toApd(t).Uint64() } math := func(z number) uint64 { return z.toMath(t).Uint64() } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("UnmarshalJSON", func(t *testing.T) { apd := func(z number, text []byte) (string, error) { zi := z.toApd(t) if err := zi.UnmarshalJSON(text); err != nil { return "", err } return zi.String(), nil } math := func(z number, text []byte) (string, error) { zi := z.toMath(t) if err := zi.UnmarshalJSON(text); err != nil { return "", err } return zi.String(), nil } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("UnmarshalText", func(t *testing.T) { apd := func(z number, text []byte) (string, error) { zi := z.toApd(t) if err := zi.UnmarshalText(text); err != nil { return "", err } return zi.String(), nil } math := func(z number, text []byte) (string, error) { zi := z.toMath(t) if err := zi.UnmarshalText(text); err != nil { return "", err } return zi.String(), nil } require(t, quick.CheckEqual(apd, math, nil)) }) t.Run("Xor", func(t *testing.T) { apd := func(z, x, y number) string { return z.toApd(t).Xor(x.toApd(t), y.toApd(t)).String() } math := func(z, x, y number) string { return z.toMath(t).Xor(x.toMath(t), y.toMath(t)).String() } require(t, quick.CheckEqual(apd, math, nil)) }) } // TestBigIntMathBigIntRoundTrip uses testing/quick to verify that the // apd.BigInt / math/big.Int interoperation methods each round-trip. func TestBigIntMathBigIntRoundTrip(t *testing.T) { t.Run("apd->math->apd", func(t *testing.T) { base := func(z number) string { return z.toApd(t).String() } roundtrip := func(z number) string { bi := z.toApd(t).MathBigInt() return new(BigInt).SetMathBigInt(bi).String() } require(t, quick.CheckEqual(base, roundtrip, nil)) }) t.Run("math->apd->math", func(t *testing.T) { base := func(z number) string { return z.toMath(t).String() } roundtrip := func(z number) string { bi := new(BigInt).SetMathBigInt(z.toMath(t)) return bi.MathBigInt().String() } require(t, quick.CheckEqual(base, roundtrip, nil)) }) } // number is a quick.Generator for large integer numbers. type number string func (n number) Generate(r *rand.Rand, size int) reflect.Value { var s string if r.Intn(2) != 0 { s = n.generateInterestingNumber(r) } else { s = n.generateRandomNumber(r, size) } return reflect.ValueOf(number(s)) } func (z *BigInt) incr() *BigInt { return z.Add(z, bigOne) } func (z *BigInt) decr() *BigInt { return z.Sub(z, bigOne) } var interestingNumbers = [...]*BigInt{ new(BigInt).SetInt64(math.MinInt64).decr(), new(BigInt).SetInt64(math.MinInt64), new(BigInt).SetInt64(math.MinInt64).incr(), new(BigInt).SetInt64(math.MinInt32), new(BigInt).SetInt64(math.MinInt16), new(BigInt).SetInt64(math.MinInt8), new(BigInt).SetInt64(0), new(BigInt).SetInt64(math.MaxInt8), new(BigInt).SetInt64(math.MaxUint8), new(BigInt).SetInt64(math.MaxInt16), new(BigInt).SetInt64(math.MaxUint16), new(BigInt).SetInt64(math.MaxInt32), new(BigInt).SetInt64(math.MaxUint32), new(BigInt).SetInt64(math.MaxInt64).decr(), new(BigInt).SetInt64(math.MaxInt64), new(BigInt).SetInt64(math.MaxInt64).incr(), new(BigInt).SetUint64(math.MaxUint64).decr(), new(BigInt).SetUint64(math.MaxUint64), new(BigInt).SetUint64(math.MaxUint64).incr(), } func (number) generateInterestingNumber(r *rand.Rand) string { return interestingNumbers[r.Intn(len(interestingNumbers))].String() } var numbers = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'} func (number) generateRandomNumber(r *rand.Rand, size int) string { var s strings.Builder if r.Intn(2) != 0 { s.WriteByte('-') // neg } digits := r.Intn(size) + 1 for i := 0; i < digits; i++ { s.WriteByte(numbers[r.Intn(len(numbers))]) } return s.String() } func (n number) toApd(t *testing.T) *BigInt { var x BigInt if _, ok := x.SetString(string(n), 10); !ok { t.Fatalf("failed to SetString(%q)", n) } return &x } func (n number) toMath(t *testing.T) *big.Int { var x big.Int if _, ok := x.SetString(string(n), 10); !ok { t.Fatalf("failed to SetString(%q)", n) } return &x } type numberOrNil struct { Num number Nil bool } func (n numberOrNil) toApd(t *testing.T) *BigInt { if n.Nil { return nil } return n.Num.toApd(t) } func (n numberOrNil) toMath(t *testing.T) *big.Int { if n.Nil { return nil } return n.Num.toMath(t) } // Until we import github.com/stretchr/testify/require. func require(t *testing.T, err error) { if err != nil { t.Error(err) } } ////////////////////////////////////////////////////////////////////////////////// // The following tests were copied from the standard library's math/big package // ////////////////////////////////////////////////////////////////////////////////// // // Tests from src/math/big/int_test.go // type funZZ func(z, x, y *BigInt) *BigInt type argZZ struct { z, x, y *BigInt } var sumZZ = []argZZ{ {NewBigInt(0), NewBigInt(0), NewBigInt(0)}, {NewBigInt(1), NewBigInt(1), NewBigInt(0)}, {NewBigInt(1111111110), NewBigInt(123456789), NewBigInt(987654321)}, {NewBigInt(-1), NewBigInt(-1), NewBigInt(0)}, {NewBigInt(864197532), NewBigInt(-123456789), NewBigInt(987654321)}, {NewBigInt(-1111111110), NewBigInt(-123456789), NewBigInt(-987654321)}, } var prodZZ = []argZZ{ {NewBigInt(0), NewBigInt(0), NewBigInt(0)}, {NewBigInt(0), NewBigInt(1), NewBigInt(0)}, {NewBigInt(1), NewBigInt(1), NewBigInt(1)}, {NewBigInt(-991 * 991), NewBigInt(991), NewBigInt(-991)}, // TODO(gri) add larger products } func TestBigIntSignZ(t *testing.T) { var zero BigInt for _, a := range sumZZ { s := a.z.Sign() e := a.z.Cmp(&zero) if s != e { t.Errorf("got %d; want %d for z = %v", s, e, a.z) } } } func TestBigIntSetZ(t *testing.T) { for _, a := range sumZZ { var z BigInt z.Set(a.z) if (&z).Cmp(a.z) != 0 { t.Errorf("got z = %v; want %v", &z, a.z) } } } func TestBigIntAbsZ(t *testing.T) { var zero BigInt for _, a := range sumZZ { var z BigInt z.Abs(a.z) var e BigInt e.Set(a.z) if e.Cmp(&zero) < 0 { e.Sub(&zero, &e) } if z.Cmp(&e) != 0 { t.Errorf("got z = %v; want %v", &z, &e) } } } func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) { var z BigInt f(&z, a.x, a.y) if (&z).Cmp(a.z) != 0 { t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, &z, a.z) } } func TestBigIntSumZZ(t *testing.T) { AddZZ := func(z, x, y *BigInt) *BigInt { return z.Add(x, y) } SubZZ := func(z, x, y *BigInt) *BigInt { return z.Sub(x, y) } for _, a := range sumZZ { arg := a testFunZZ(t, "AddZZ", AddZZ, arg) arg = argZZ{a.z, a.y, a.x} testFunZZ(t, "AddZZ symmetric", AddZZ, arg) arg = argZZ{a.x, a.z, a.y} testFunZZ(t, "SubZZ", SubZZ, arg) arg = argZZ{a.y, a.z, a.x} testFunZZ(t, "SubZZ symmetric", SubZZ, arg) } } func TestBigIntProdZZ(t *testing.T) { MulZZ := func(z, x, y *BigInt) *BigInt { return z.Mul(x, y) } for _, a := range prodZZ { arg := a testFunZZ(t, "MulZZ", MulZZ, arg) arg = argZZ{a.z, a.y, a.x} testFunZZ(t, "MulZZ symmetric", MulZZ, arg) } } // mulBytes returns x*y via grade school multiplication. Both inputs // and the result are assumed to be in big-endian representation (to // match the semantics of BigInt.Bytes and BigInt.SetBytes). func mulBytes(x, y []byte) []byte { z := make([]byte, len(x)+len(y)) // multiply k0 := len(z) - 1 for j := len(y) - 1; j >= 0; j-- { d := int(y[j]) if d != 0 { k := k0 carry := 0 for i := len(x) - 1; i >= 0; i-- { t := int(z[k]) + int(x[i])*d + carry z[k], carry = byte(t), t>>8 k-- } z[k] = byte(carry) } k0-- } // normalize (remove leading 0's) i := 0 for i < len(z) && z[i] == 0 { i++ } return z[i:] } func checkMul(a, b []byte) bool { var x, y, z1 BigInt x.SetBytes(a) y.SetBytes(b) z1.Mul(&x, &y) var z2 BigInt z2.SetBytes(mulBytes(a, b)) return z1.Cmp(&z2) == 0 } func TestBigIntMul(t *testing.T) { if err := quick.Check(checkMul, nil); err != nil { t.Error(err) } } var mulRangesN = []struct { a, b uint64 prod string }{ {0, 0, "0"}, {1, 1, "1"}, {1, 2, "2"}, {1, 3, "6"}, {10, 10, "10"}, {0, 100, "0"}, {0, 1e9, "0"}, {1, 0, "1"}, // empty range {100, 1, "1"}, // empty range {1, 10, "3628800"}, // 10! {1, 20, "2432902008176640000"}, // 20! {1, 100, "933262154439441526816992388562667004907159682643816214685929" + "638952175999932299156089414639761565182862536979208272237582" + "51185210916864000000000000000000000000", // 100! }, } var mulRangesZ = []struct { a, b int64 prod string }{ // entirely positive ranges are covered by mulRangesN {-1, 1, "0"}, {-2, -1, "2"}, {-3, -2, "6"}, {-3, -1, "-6"}, {1, 3, "6"}, {-10, -10, "-10"}, {0, -1, "1"}, // empty range {-1, -100, "1"}, // empty range {-1, 1, "0"}, // range includes 0 {-1e9, 0, "0"}, // range includes 0 {-1e9, 1e9, "0"}, // range includes 0 {-10, -1, "3628800"}, // 10! {-20, -2, "-2432902008176640000"}, // -20! {-99, -1, "-933262154439441526816992388562667004907159682643816214685929" + "638952175999932299156089414639761565182862536979208272237582" + "511852109168640000000000000000000000", // -99! }, } func TestBigIntMulRangeZ(t *testing.T) { var tmp BigInt // test entirely positive ranges for i, r := range mulRangesN { prod := tmp.MulRange(int64(r.a), int64(r.b)).String() if prod != r.prod { t.Errorf("#%da: got %s; want %s", i, prod, r.prod) } } // test other ranges for i, r := range mulRangesZ { prod := tmp.MulRange(r.a, r.b).String() if prod != r.prod { t.Errorf("#%db: got %s; want %s", i, prod, r.prod) } } } func TestBigIntBinomial(t *testing.T) { var z BigInt for _, test := range []struct { n, k int64 want string }{ {0, 0, "1"}, {0, 1, "0"}, {1, 0, "1"}, {1, 1, "1"}, {1, 10, "0"}, {4, 0, "1"}, {4, 1, "4"}, {4, 2, "6"}, {4, 3, "4"}, {4, 4, "1"}, {10, 1, "10"}, {10, 9, "10"}, {10, 5, "252"}, {11, 5, "462"}, {11, 6, "462"}, {100, 10, "17310309456440"}, {100, 90, "17310309456440"}, {1000, 10, "263409560461970212832400"}, {1000, 990, "263409560461970212832400"}, } { if got := z.Binomial(test.n, test.k).String(); got != test.want { t.Errorf("Binomial(%d, %d) = %s; want %s", test.n, test.k, got, test.want) } } } // Examples from the Go Language Spec, section "Arithmetic operators" var divisionSignsTests = []struct { x, y int64 q, r int64 // T-division d, m int64 // Euclidean division }{ {5, 3, 1, 2, 1, 2}, {-5, 3, -1, -2, -2, 1}, {5, -3, -1, 2, -1, 2}, {-5, -3, 1, -2, 2, 1}, {1, 2, 0, 1, 0, 1}, {8, 4, 2, 0, 2, 0}, } func TestBigIntDivisionSigns(t *testing.T) { for i, test := range divisionSignsTests { x := NewBigInt(test.x) y := NewBigInt(test.y) q := NewBigInt(test.q) r := NewBigInt(test.r) d := NewBigInt(test.d) m := NewBigInt(test.m) q1 := new(BigInt).Quo(x, y) r1 := new(BigInt).Rem(x, y) if q1.Cmp(q) != 0 || r1.Cmp(r) != 0 { t.Errorf("#%d QuoRem: got (%s, %s), want (%s, %s)", i, q1, r1, q, r) } q2, r2 := new(BigInt).QuoRem(x, y, new(BigInt)) if q2.Cmp(q) != 0 || r2.Cmp(r) != 0 { t.Errorf("#%d QuoRem: got (%s, %s), want (%s, %s)", i, q2, r2, q, r) } d1 := new(BigInt).Div(x, y) m1 := new(BigInt).Mod(x, y) if d1.Cmp(d) != 0 || m1.Cmp(m) != 0 { t.Errorf("#%d DivMod: got (%s, %s), want (%s, %s)", i, d1, m1, d, m) } d2, m2 := new(BigInt).DivMod(x, y, new(BigInt)) if d2.Cmp(d) != 0 || m2.Cmp(m) != 0 { t.Errorf("#%d DivMod: got (%s, %s), want (%s, %s)", i, d2, m2, d, m) } } } func checkSetBytes(b []byte) bool { hex1 := hex.EncodeToString(new(BigInt).SetBytes(b).Bytes()) hex2 := hex.EncodeToString(b) for len(hex1) < len(hex2) { hex1 = "0" + hex1 } for len(hex1) > len(hex2) { hex2 = "0" + hex2 } return hex1 == hex2 } func TestBigIntSetBytes(t *testing.T) { if err := quick.Check(checkSetBytes, nil); err != nil { t.Error(err) } } func checkBytes(b []byte) bool { // trim leading zero bytes since Bytes() won't return them // (was issue 12231) for len(b) > 0 && b[0] == 0 { b = b[1:] } b2 := new(BigInt).SetBytes(b).Bytes() return bytes.Equal(b, b2) } func TestBigIntBytes(t *testing.T) { if err := quick.Check(checkBytes, nil); err != nil { t.Error(err) } } func checkQuo(x, y []byte) bool { u := new(BigInt).SetBytes(x) v := new(BigInt).SetBytes(y) var tmp1 big.Int if len(v.inner(&tmp1).Bits()) == 0 { return true } r := new(BigInt) q, r := new(BigInt).QuoRem(u, v, r) if r.Cmp(v) >= 0 { return false } uprime := new(BigInt).Set(q) uprime.Mul(uprime, v) uprime.Add(uprime, r) return uprime.Cmp(u) == 0 } var quoTests = []struct { x, y string q, r string }{ { "476217953993950760840509444250624797097991362735329973741718102894495832294430498335824897858659711275234906400899559094370964723884706254265559534144986498357", "9353930466774385905609975137998169297361893554149986716853295022578535724979483772383667534691121982974895531435241089241440253066816724367338287092081996", "50911", "1", }, { "11510768301994997771168", "1328165573307167369775", "8", "885443715537658812968", }, } func TestBigIntQuo(t *testing.T) { if err := quick.Check(checkQuo, nil); err != nil { t.Error(err) } for i, test := range quoTests { x, _ := new(BigInt).SetString(test.x, 10) y, _ := new(BigInt).SetString(test.y, 10) expectedQ, _ := new(BigInt).SetString(test.q, 10) expectedR, _ := new(BigInt).SetString(test.r, 10) r := new(BigInt) q, r := new(BigInt).QuoRem(x, y, r) if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 { t.Errorf("#%d got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR) } } } var bitLenTests = []struct { in string out int }{ {"-1", 1}, {"0", 0}, {"1", 1}, {"2", 2}, {"4", 3}, {"0xabc", 12}, {"0x8000", 16}, {"0x80000000", 32}, {"0x800000000000", 48}, {"0x8000000000000000", 64}, {"0x80000000000000000000", 80}, {"-0x4000000000000000000000", 87}, } func TestBigIntBitLen(t *testing.T) { for i, test := range bitLenTests { x, ok := new(BigInt).SetString(test.in, 0) if !ok { t.Errorf("#%d test input invalid: %s", i, test.in) continue } if n := x.BitLen(); n != test.out { t.Errorf("#%d got %d want %d", i, n, test.out) } } } var expTests = []struct { x, y, m string out string }{ // y <= 0 {"0", "0", "", "1"}, {"1", "0", "", "1"}, {"-10", "0", "", "1"}, {"1234", "-1", "", "1"}, {"1234", "-1", "0", "1"}, {"17", "-100", "1234", "865"}, {"2", "-100", "1234", ""}, // m == 1 {"0", "0", "1", "0"}, {"1", "0", "1", "0"}, {"-10", "0", "1", "0"}, {"1234", "-1", "1", "0"}, // misc {"5", "1", "3", "2"}, {"5", "-7", "", "1"}, {"-5", "-7", "", "1"}, {"5", "0", "", "1"}, {"-5", "0", "", "1"}, {"5", "1", "", "5"}, {"-5", "1", "", "-5"}, {"-5", "1", "7", "2"}, {"-2", "3", "2", "0"}, {"5", "2", "", "25"}, {"1", "65537", "2", "1"}, {"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"}, {"0x8000000000000000", "2", "6719", "4944"}, {"0x8000000000000000", "3", "6719", "5447"}, {"0x8000000000000000", "1000", "6719", "1603"}, {"0x8000000000000000", "1000000", "6719", "3199"}, {"0x8000000000000000", "-1000000", "6719", "3663"}, // 3663 = ModInverse(3199, 6719) Issue #25865 {"0xffffffffffffffffffffffffffffffff", "0x12345678123456781234567812345678123456789", "0x01112222333344445555666677778889", "0x36168FA1DB3AAE6C8CE647E137F97A"}, { "2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347", "298472983472983471903246121093472394872319615612417471234712061", "29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464", "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291", }, // test case for issue 8822 { "11001289118363089646017359372117963499250546375269047542777928006103246876688756735760905680604646624353196869572752623285140408755420374049317646428185270079555372763503115646054602867593662923894140940837479507194934267532831694565516466765025434902348314525627418515646588160955862839022051353653052947073136084780742729727874803457643848197499548297570026926927502505634297079527299004267769780768565695459945235586892627059178884998772989397505061206395455591503771677500931269477503508150175717121828518985901959919560700853226255420793148986854391552859459511723547532575574664944815966793196961286234040892865", "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD", "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73", "21484252197776302499639938883777710321993113097987201050501182909581359357618579566746556372589385361683610524730509041328855066514963385522570894839035884713051640171474186548713546686476761306436434146475140156284389181808675016576845833340494848283681088886584219750554408060556769486628029028720727393293111678826356480455433909233520504112074401376133077150471237549474149190242010469539006449596611576612573955754349042329130631128234637924786466585703488460540228477440853493392086251021228087076124706778899179648655221663765993962724699135217212118535057766739392069738618682722216712319320435674779146070442", }, { "-0x1BCE04427D8032319A89E5C4136456671AC620883F2C4139E57F91307C485AD2D6204F4F87A58262652DB5DBBAC72B0613E51B835E7153BEC6068F5C8D696B74DBD18FEC316AEF73985CF0475663208EB46B4F17DD9DA55367B03323E5491A70997B90C059FB34809E6EE55BCFBD5F2F52233BFE62E6AA9E4E26A1D4C2439883D14F2633D55D8AA66A1ACD5595E778AC3A280517F1157989E70C1A437B849F1877B779CC3CDDEDE2DAA6594A6C66D181A00A5F777EE60596D8773998F6E988DEAE4CCA60E4DDCF9590543C89F74F603259FCAD71660D30294FBBE6490300F78A9D63FA660DC9417B8B9DDA28BEB3977B621B988E23D4D954F322C3540541BC649ABD504C50FADFD9F0987D58A2BF689313A285E773FF02899A6EF887D1D4A0D2", "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD", "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73", "21484252197776302499639938883777710321993113097987201050501182909581359357618579566746556372589385361683610524730509041328855066514963385522570894839035884713051640171474186548713546686476761306436434146475140156284389181808675016576845833340494848283681088886584219750554408060556769486628029028720727393293111678826356480455433909233520504112074401376133077150471237549474149190242010469539006449596611576612573955754349042329130631128234637924786466585703488460540228477440853493392086251021228087076124706778899179648655221663765993962724699135217212118535057766739392069738618682722216712319320435674779146070442", }, // test cases for issue 13907 {"0xffffffff00000001", "0xffffffff00000001", "0xffffffff00000001", "0"}, {"0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0"}, {"0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0"}, {"0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0"}, { "2", "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD", "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73", // odd "0x6AADD3E3E424D5B713FCAA8D8945B1E055166132038C57BBD2D51C833F0C5EA2007A2324CE514F8E8C2F008A2F36F44005A4039CB55830986F734C93DAF0EB4BAB54A6A8C7081864F44346E9BC6F0A3EB9F2C0146A00C6A05187D0C101E1F2D038CDB70CB5E9E05A2D188AB6CBB46286624D4415E7D4DBFAD3BCC6009D915C406EED38F468B940F41E6BEDC0430DD78E6F19A7DA3A27498A4181E24D738B0072D8F6ADB8C9809A5B033A09785814FD9919F6EF9F83EEA519BEC593855C4C10CBEEC582D4AE0792158823B0275E6AEC35242740468FAF3D5C60FD1E376362B6322F78B7ED0CA1C5BBCD2B49734A56C0967A1D01A100932C837B91D592CE08ABFF", }, { "2", "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD", "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF72", // even "0x7858794B5897C29F4ED0B40913416AB6C48588484E6A45F2ED3E26C941D878E923575AAC434EE2750E6439A6976F9BB4D64CEDB2A53CE8D04DD48CADCDF8E46F22747C6B81C6CEA86C0D873FBF7CEF262BAAC43A522BD7F32F3CDAC52B9337C77B3DCFB3DB3EDD80476331E82F4B1DF8EFDC1220C92656DFC9197BDC1877804E28D928A2A284B8DED506CBA304435C9D0133C246C98A7D890D1DE60CBC53A024361DA83A9B8775019083D22AC6820ED7C3C68F8E801DD4EC779EE0A05C6EB682EF9840D285B838369BA7E148FA27691D524FAEAF7C6ECE2A4B99A294B9F2C241857B5B90CC8BFFCFCF18DFA7D676131D5CD3855A5A3E8EBFA0CDFADB4D198B4A", }, } func TestBigIntExp(t *testing.T) { for i, test := range expTests { x, ok1 := new(BigInt).SetString(test.x, 0) y, ok2 := new(BigInt).SetString(test.y, 0) var ok3, ok4 bool var out, m *BigInt if len(test.out) == 0 { out, ok3 = nil, true } else { out, ok3 = new(BigInt).SetString(test.out, 0) } if len(test.m) == 0 { m, ok4 = nil, true } else { m, ok4 = new(BigInt).SetString(test.m, 0) } if !ok1 || !ok2 || !ok3 || !ok4 { t.Errorf("#%d: error in input", i) continue } z1 := new(BigInt).Exp(x, y, m) if !(z1 == nil && out == nil || z1.Cmp(out) == 0) { t.Errorf("#%d: got %x want %x", i, z1, out) } if m == nil { // The result should be the same as for m == 0; // specifically, there should be no div-zero panic. m = new(BigInt) // m != nil && len(m.abs) == 0 z2 := new(BigInt).Exp(x, y, m) if z2.Cmp(z1) != 0 { t.Errorf("#%d: got %x want %x", i, z2, z1) } } } } type intShiftTest struct { in string shift uint out string } var rshTests = []intShiftTest{ {"0", 0, "0"}, {"-0", 0, "0"}, {"0", 1, "0"}, {"0", 2, "0"}, {"1", 0, "1"}, {"1", 1, "0"}, {"1", 2, "0"}, {"2", 0, "2"}, {"2", 1, "1"}, {"-1", 0, "-1"}, {"-1", 1, "-1"}, {"-1", 10, "-1"}, {"-100", 2, "-25"}, {"-100", 3, "-13"}, {"-100", 100, "-1"}, {"4294967296", 0, "4294967296"}, {"4294967296", 1, "2147483648"}, {"4294967296", 2, "1073741824"}, {"18446744073709551616", 0, "18446744073709551616"}, {"18446744073709551616", 1, "9223372036854775808"}, {"18446744073709551616", 2, "4611686018427387904"}, {"18446744073709551616", 64, "1"}, {"340282366920938463463374607431768211456", 64, "18446744073709551616"}, {"340282366920938463463374607431768211456", 128, "1"}, } func TestBigIntRsh(t *testing.T) { for i, test := range rshTests { in, _ := new(BigInt).SetString(test.in, 10) expected, _ := new(BigInt).SetString(test.out, 10) out := new(BigInt).Rsh(in, test.shift) if out.Cmp(expected) != 0 { t.Errorf("#%d: got %s want %s", i, out, expected) } } } func TestBigIntRshSelf(t *testing.T) { for i, test := range rshTests { z, _ := new(BigInt).SetString(test.in, 10) expected, _ := new(BigInt).SetString(test.out, 10) z.Rsh(z, test.shift) if z.Cmp(expected) != 0 { t.Errorf("#%d: got %s want %s", i, z, expected) } } } var lshTests = []intShiftTest{ {"0", 0, "0"}, {"0", 1, "0"}, {"0", 2, "0"}, {"1", 0, "1"}, {"1", 1, "2"}, {"1", 2, "4"}, {"2", 0, "2"}, {"2", 1, "4"}, {"2", 2, "8"}, {"-87", 1, "-174"}, {"4294967296", 0, "4294967296"}, {"4294967296", 1, "8589934592"}, {"4294967296", 2, "17179869184"}, {"18446744073709551616", 0, "18446744073709551616"}, {"9223372036854775808", 1, "18446744073709551616"}, {"4611686018427387904", 2, "18446744073709551616"}, {"1", 64, "18446744073709551616"}, {"18446744073709551616", 64, "340282366920938463463374607431768211456"}, {"1", 128, "340282366920938463463374607431768211456"}, } func TestBigIntLsh(t *testing.T) { for i, test := range lshTests { in, _ := new(BigInt).SetString(test.in, 10) expected, _ := new(BigInt).SetString(test.out, 10) out := new(BigInt).Lsh(in, test.shift) if out.Cmp(expected) != 0 { t.Errorf("#%d: got %s want %s", i, out, expected) } } } func TestBigIntLshSelf(t *testing.T) { for i, test := range lshTests { z, _ := new(BigInt).SetString(test.in, 10) expected, _ := new(BigInt).SetString(test.out, 10) z.Lsh(z, test.shift) if z.Cmp(expected) != 0 { t.Errorf("#%d: got %s want %s", i, z, expected) } } } func TestBigIntLshRsh(t *testing.T) { for i, test := range rshTests { in, _ := new(BigInt).SetString(test.in, 10) out := new(BigInt).Lsh(in, test.shift) out = out.Rsh(out, test.shift) if in.Cmp(out) != 0 { t.Errorf("#%d: got %s want %s", i, out, in) } } for i, test := range lshTests { in, _ := new(BigInt).SetString(test.in, 10) out := new(BigInt).Lsh(in, test.shift) out.Rsh(out, test.shift) if in.Cmp(out) != 0 { t.Errorf("#%d: got %s want %s", i, out, in) } } } // Entries must be sorted by value in ascending order. var cmpAbsTests = []string{ "0", "1", "2", "10", "10000000", "2783678367462374683678456387645876387564783686583485", "2783678367462374683678456387645876387564783686583486", "32957394867987420967976567076075976570670947609750670956097509670576075067076027578341538", } func TestBigIntCmpAbs(t *testing.T) { values := make([]*BigInt, len(cmpAbsTests)) var prev *BigInt for i, s := range cmpAbsTests { x, ok := new(BigInt).SetString(s, 0) if !ok { t.Fatalf("SetString(%s, 0) failed", s) } if prev != nil && prev.Cmp(x) >= 0 { t.Fatal("cmpAbsTests entries not sorted in ascending order") } values[i] = x prev = x } for i, x := range values { for j, y := range values { // try all combinations of signs for x, y for k := 0; k < 4; k++ { var a, b BigInt a.Set(x) b.Set(y) if k&1 != 0 { a.Neg(&a) } if k&2 != 0 { b.Neg(&b) } got := a.CmpAbs(&b) want := 0 switch { case i > j: want = 1 case i < j: want = -1 } if got != want { t.Errorf("absCmp |%s|, |%s|: got %d; want %d", &a, &b, got, want) } } } } } func TestBigIntCmpSelf(t *testing.T) { for _, s := range cmpAbsTests { x, ok := new(BigInt).SetString(s, 0) if !ok { t.Fatalf("SetString(%s, 0) failed", s) } got := x.Cmp(x) want := 0 if got != want { t.Errorf("x = %s: x.Cmp(x): got %d; want %d", x, got, want) } } } var int64Tests = []string{ // int64 "0", "1", "-1", "4294967295", "-4294967295", "4294967296", "-4294967296", "9223372036854775807", "-9223372036854775807", "-9223372036854775808", // not int64 "0x8000000000000000", "-0x8000000000000001", "38579843757496759476987459679745", "-38579843757496759476987459679745", } func TestBigInt64(t *testing.T) { for _, s := range int64Tests { var x BigInt _, ok := x.SetString(s, 0) if !ok { t.Errorf("SetString(%s, 0) failed", s) continue } want, err := strconv.ParseInt(s, 0, 64) if err != nil { if err.(*strconv.NumError).Err == strconv.ErrRange { if x.IsInt64() { t.Errorf("IsInt64(%s) succeeded unexpectedly", s) } } else { t.Errorf("ParseInt(%s) failed", s) } continue } if !x.IsInt64() { t.Errorf("IsInt64(%s) failed unexpectedly", s) } got := x.Int64() if got != want { t.Errorf("Int64(%s) = %d; want %d", s, got, want) } } } var uint64Tests = []string{ // uint64 "0", "1", "4294967295", "4294967296", "8589934591", "8589934592", "9223372036854775807", "9223372036854775808", "0x08000000000000000", // not uint64 "0x10000000000000000", "-0x08000000000000000", "-1", } func TestBigIntUint64(t *testing.T) { for _, s := range uint64Tests { var x BigInt _, ok := x.SetString(s, 0) if !ok { t.Errorf("SetString(%s, 0) failed", s) continue } want, err := strconv.ParseUint(s, 0, 64) if err != nil { // check for sign explicitly (ErrRange doesn't cover signed input) if s[0] == '-' || err.(*strconv.NumError).Err == strconv.ErrRange { if x.IsUint64() { t.Errorf("IsUint64(%s) succeeded unexpectedly", s) } } else { t.Errorf("ParseUint(%s) failed", s) } continue } if !x.IsUint64() { t.Errorf("IsUint64(%s) failed unexpectedly", s) } got := x.Uint64() if got != want { t.Errorf("Uint64(%s) = %d; want %d", s, got, want) } } } var bitwiseTests = []struct { x, y string and, or, xor, andNot string }{ {"0x00", "0x00", "0x00", "0x00", "0x00", "0x00"}, {"0x00", "0x01", "0x00", "0x01", "0x01", "0x00"}, {"0x01", "0x00", "0x00", "0x01", "0x01", "0x01"}, {"-0x01", "0x00", "0x00", "-0x01", "-0x01", "-0x01"}, {"-0xaf", "-0x50", "-0xf0", "-0x0f", "0xe1", "0x41"}, {"0x00", "-0x01", "0x00", "-0x01", "-0x01", "0x00"}, {"0x01", "0x01", "0x01", "0x01", "0x00", "0x00"}, {"-0x01", "-0x01", "-0x01", "-0x01", "0x00", "0x00"}, {"0x07", "0x08", "0x00", "0x0f", "0x0f", "0x07"}, {"0x05", "0x0f", "0x05", "0x0f", "0x0a", "0x00"}, {"0xff", "-0x0a", "0xf6", "-0x01", "-0xf7", "0x09"}, {"0x013ff6", "0x9a4e", "0x1a46", "0x01bffe", "0x01a5b8", "0x0125b0"}, {"-0x013ff6", "0x9a4e", "0x800a", "-0x0125b2", "-0x01a5bc", "-0x01c000"}, {"-0x013ff6", "-0x9a4e", "-0x01bffe", "-0x1a46", "0x01a5b8", "0x8008"}, { "0x1000009dc6e3d9822cba04129bcbe3401", "0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd", "0x1000001186210100001000009048c2001", "0xb9bd7d543685789d57cb918e8bfeff7fddb2ebe87dfbbdfe35fd", "0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fc", "0x8c40c2d8822caa04120b8321400", }, { "0x1000009dc6e3d9822cba04129bcbe3401", "-0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd", "0x8c40c2d8822caa04120b8321401", "-0xb9bd7d543685789d57ca918e82229142459020483cd2014001fd", "-0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fe", "0x1000001186210100001000009048c2000", }, { "-0x1000009dc6e3d9822cba04129bcbe3401", "-0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd", "-0xb9bd7d543685789d57cb918e8bfeff7fddb2ebe87dfbbdfe35fd", "-0x1000001186210100001000009048c2001", "0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fc", "0xb9bd7d543685789d57ca918e82229142459020483cd2014001fc", }, } type bitFun func(z, x, y *BigInt) *BigInt func testBitFun(t *testing.T, msg string, f bitFun, x, y *BigInt, exp string) { expected := new(BigInt) expected.SetString(exp, 0) out := f(new(BigInt), x, y) if out.Cmp(expected) != 0 { t.Errorf("%s: got %s want %s", msg, out, expected) } } func testBitFunSelf(t *testing.T, msg string, f bitFun, x, y *BigInt, exp string) { self := new(BigInt) self.Set(x) expected := new(BigInt) expected.SetString(exp, 0) self = f(self, self, y) if self.Cmp(expected) != 0 { t.Errorf("%s: got %s want %s", msg, self, expected) } } func altBit(x *BigInt, i int) uint { z := new(BigInt).Rsh(x, uint(i)) z = z.And(z, NewBigInt(1)) if z.Cmp(new(BigInt)) != 0 { return 1 } return 0 } func altSetBit(z *BigInt, x *BigInt, i int, b uint) *BigInt { one := NewBigInt(1) m := one.Lsh(one, uint(i)) switch b { case 1: return z.Or(x, m) case 0: return z.AndNot(x, m) } panic("set bit is not 0 or 1") } func testBitset(t *testing.T, x *BigInt) { n := x.BitLen() z := new(BigInt).Set(x) z1 := new(BigInt).Set(x) for i := 0; i < n+10; i++ { old := z.Bit(i) old1 := altBit(z1, i) if old != old1 { t.Errorf("bitset: inconsistent value for Bit(%s, %d), got %v want %v", z1, i, old, old1) } z := new(BigInt).SetBit(z, i, 1) z1 := altSetBit(new(BigInt), z1, i, 1) if z.Bit(i) == 0 { t.Errorf("bitset: bit %d of %s got 0 want 1", i, x) } if z.Cmp(z1) != 0 { t.Errorf("bitset: inconsistent value after SetBit 1, got %s want %s", z, z1) } z.SetBit(z, i, 0) altSetBit(z1, z1, i, 0) if z.Bit(i) != 0 { t.Errorf("bitset: bit %d of %s got 1 want 0", i, x) } if z.Cmp(z1) != 0 { t.Errorf("bitset: inconsistent value after SetBit 0, got %s want %s", z, z1) } altSetBit(z1, z1, i, old) z.SetBit(z, i, old) if z.Cmp(z1) != 0 { t.Errorf("bitset: inconsistent value after SetBit old, got %s want %s", z, z1) } } if z.Cmp(x) != 0 { t.Errorf("bitset: got %s want %s", z, x) } } var bitsetTests = []struct { x string i int b uint }{ {"0", 0, 0}, {"0", 200, 0}, {"1", 0, 1}, {"1", 1, 0}, {"-1", 0, 1}, {"-1", 200, 1}, {"0x2000000000000000000000000000", 108, 0}, {"0x2000000000000000000000000000", 109, 1}, {"0x2000000000000000000000000000", 110, 0}, {"-0x2000000000000000000000000001", 108, 1}, {"-0x2000000000000000000000000001", 109, 0}, {"-0x2000000000000000000000000001", 110, 1}, } func TestBigIntBitSet(t *testing.T) { for _, test := range bitwiseTests { x := new(BigInt) x.SetString(test.x, 0) testBitset(t, x) x = new(BigInt) x.SetString(test.y, 0) testBitset(t, x) } for i, test := range bitsetTests { x := new(BigInt) x.SetString(test.x, 0) b := x.Bit(test.i) if b != test.b { t.Errorf("#%d got %v want %v", i, b, test.b) } } z := NewBigInt(1) z.SetBit(NewBigInt(0), 2, 1) if z.Cmp(NewBigInt(4)) != 0 { t.Errorf("destination leaked into result; got %s want 4", z) } } var tzbTests = []struct { in string out uint }{ {"0", 0}, {"1", 0}, {"-1", 0}, {"4", 2}, {"-8", 3}, {"0x4000000000000000000", 74}, {"-0x8000000000000000000", 75}, } func TestBigIntTrailingZeroBits(t *testing.T) { for i, test := range tzbTests { in, _ := new(BigInt).SetString(test.in, 0) want := test.out got := in.TrailingZeroBits() if got != want { t.Errorf("#%d: got %v want %v", i, got, want) } } } func TestBigIntBitwise(t *testing.T) { x := new(BigInt) y := new(BigInt) for _, test := range bitwiseTests { x.SetString(test.x, 0) y.SetString(test.y, 0) testBitFun(t, "and", (*BigInt).And, x, y, test.and) testBitFunSelf(t, "and", (*BigInt).And, x, y, test.and) testBitFun(t, "andNot", (*BigInt).AndNot, x, y, test.andNot) testBitFunSelf(t, "andNot", (*BigInt).AndNot, x, y, test.andNot) testBitFun(t, "or", (*BigInt).Or, x, y, test.or) testBitFunSelf(t, "or", (*BigInt).Or, x, y, test.or) testBitFun(t, "xor", (*BigInt).Xor, x, y, test.xor) testBitFunSelf(t, "xor", (*BigInt).Xor, x, y, test.xor) } } var notTests = []struct { in string out string }{ {"0", "-1"}, {"1", "-2"}, {"7", "-8"}, {"0", "-1"}, {"-81910", "81909"}, { "298472983472983471903246121093472394872319615612417471234712061", "-298472983472983471903246121093472394872319615612417471234712062", }, } func TestBigIntNot(t *testing.T) { in := new(BigInt) out := new(BigInt) expected := new(BigInt) for i, test := range notTests { in.SetString(test.in, 10) expected.SetString(test.out, 10) out = out.Not(in) if out.Cmp(expected) != 0 { t.Errorf("#%d: got %s want %s", i, out, expected) } out = out.Not(out) if out.Cmp(in) != 0 { t.Errorf("#%d: got %s want %s", i, out, in) } } } var modInverseTests = []struct { element string modulus string }{ {"1234567", "458948883992"}, {"239487239847", "2410312426921032588552076022197566074856950548502459942654116941958108831682612228890093858261341614673227141477904012196503648957050582631942730706805009223062734745341073406696246014589361659774041027169249453200378729434170325843778659198143763193776859869524088940195577346119843545301547043747207749969763750084308926339295559968882457872412993810129130294592999947926365264059284647209730384947211681434464714438488520940127459844288859336526896320919633919"}, {"-10", "13"}, // issue #16984 {"10", "-13"}, {"-17", "-13"}, } func TestBigIntModInverse(t *testing.T) { var element, modulus, gcd, inverse BigInt one := NewBigInt(1) for _, test := range modInverseTests { (&element).SetString(test.element, 10) (&modulus).SetString(test.modulus, 10) (&inverse).ModInverse(&element, &modulus) (&inverse).Mul(&inverse, &element) (&inverse).Mod(&inverse, &modulus) if (&inverse).Cmp(one) != 0 { t.Errorf("ModInverse(%d,%d)*%d%%%d=%d, not 1", &element, &modulus, &element, &modulus, &inverse) } } // exhaustive test for small values for n := 2; n < 100; n++ { (&modulus).SetInt64(int64(n)) for x := 1; x < n; x++ { (&element).SetInt64(int64(x)) (&gcd).GCD(nil, nil, &element, &modulus) if (&gcd).Cmp(one) != 0 { continue } (&inverse).ModInverse(&element, &modulus) (&inverse).Mul(&inverse, &element) (&inverse).Mod(&inverse, &modulus) if (&inverse).Cmp(one) != 0 { t.Errorf("ModInverse(%d,%d)*%d%%%d=%d, not 1", &element, &modulus, &element, &modulus, &inverse) } } } } // testModSqrt is a helper for TestModSqrt, // which checks that ModSqrt can compute a square-root of elt^2. func testModSqrt(t *testing.T, elt, mod, sq, sqrt *BigInt) bool { var sqChk, sqrtChk, sqrtsq BigInt sq.Mul(elt, elt) sq.Mod(sq, mod) z := sqrt.ModSqrt(sq, mod) if z != sqrt { t.Errorf("ModSqrt returned wrong value %s", z) } // test ModSqrt arguments outside the range [0,mod) sqChk.Add(sq, mod) z = sqrtChk.ModSqrt(&sqChk, mod) if z != &sqrtChk || z.Cmp(sqrt) != 0 { t.Errorf("ModSqrt returned inconsistent value %s", z) } sqChk.Sub(sq, mod) z = sqrtChk.ModSqrt(&sqChk, mod) if z != &sqrtChk || z.Cmp(sqrt) != 0 { t.Errorf("ModSqrt returned inconsistent value %s", z) } // test x aliasing z z = sqrtChk.ModSqrt(sqrtChk.Set(sq), mod) if z != &sqrtChk || z.Cmp(sqrt) != 0 { t.Errorf("ModSqrt returned inconsistent value %s", z) } // make sure we actually got a square root if sqrt.Cmp(elt) == 0 { return true // we found the "desired" square root } sqrtsq.Mul(sqrt, sqrt) // make sure we found the "other" one sqrtsq.Mod(&sqrtsq, mod) return sq.Cmp(&sqrtsq) == 0 } var primes = []string{ "2", "3", "5", "7", "11", "13756265695458089029", "13496181268022124907", "10953742525620032441", "17908251027575790097", // https://golang.org/issue/638 "18699199384836356663", "98920366548084643601728869055592650835572950932266967461790948584315647051443", "94560208308847015747498523884063394671606671904944666360068158221458669711639", // https://primes.utm.edu/lists/small/small3.html "449417999055441493994709297093108513015373787049558499205492347871729927573118262811508386655998299074566974373711472560655026288668094291699357843464363003144674940345912431129144354948751003607115263071543163", "230975859993204150666423538988557839555560243929065415434980904258310530753006723857139742334640122533598517597674807096648905501653461687601339782814316124971547968912893214002992086353183070342498989426570593", "5521712099665906221540423207019333379125265462121169655563495403888449493493629943498064604536961775110765377745550377067893607246020694972959780839151452457728855382113555867743022746090187341871655890805971735385789993", "203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123", // ECC primes: https://tools.ietf.org/html/draft-ladd-safecurves-02 "3618502788666131106986593281521497120414687020801267626233049500247285301239", // Curve1174: 2^251-9 "57896044618658097711785492504343953926634992332820282019728792003956564819949", // Curve25519: 2^255-19 "9850501549098619803069760025035903451269934817616361666987073351061430442874302652853566563721228910201656997576599", // E-382: 2^382-105 "42307582002575910332922579714097346549017899709713998034217522897561970639123926132812109468141778230245837569601494931472367", // Curve41417: 2^414-17 "6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151", // E-521: 2^521-1 } func TestBigIntModSqrt(t *testing.T) { var elt, mod, modx4, sq, sqrt BigInt r := rand.New(rand.NewSource(9)) for i, s := range primes[1:] { // skip 2, use only odd primes mod.SetString(s, 10) modx4.Lsh(&mod, 2) // test a few random elements per prime for x := 1; x < 5; x++ { elt.Rand(r, &modx4) elt.Sub(&elt, &mod) // test range [-mod, 3*mod) if !testModSqrt(t, &elt, &mod, &sq, &sqrt) { t.Errorf("#%d: failed (sqrt(e) = %s)", i, &sqrt) } } if testing.Short() && i > 2 { break } } if testing.Short() { return } // exhaustive test for small values for n := 3; n < 100; n++ { mod.SetInt64(int64(n)) if !mod.ProbablyPrime(10) { continue } isSquare := make([]bool, n) // test all the squares for x := 1; x < n; x++ { elt.SetInt64(int64(x)) if !testModSqrt(t, &elt, &mod, &sq, &sqrt) { t.Errorf("#%d: failed (sqrt(%d,%d) = %s)", x, &elt, &mod, &sqrt) } isSquare[sq.Uint64()] = true } // test all non-squares for x := 1; x < n; x++ { sq.SetInt64(int64(x)) z := sqrt.ModSqrt(&sq, &mod) if !isSquare[x] && z != nil { t.Errorf("#%d: failed (sqrt(%d,%d) = nil)", x, &sqrt, &mod) } } } } func TestBigIntIssue2607(t *testing.T) { // This code sequence used to hang. n := NewBigInt(10) n.Rand(rand.New(rand.NewSource(9)), n) } func TestBigIntSqrt(t *testing.T) { root := 0 r := new(BigInt) for i := 0; i < 10000; i++ { if (root+1)*(root+1) <= i { root++ } n := NewBigInt(int64(i)) r.SetInt64(-2) r.Sqrt(n) if r.Cmp(NewBigInt(int64(root))) != 0 { t.Errorf("Sqrt(%v) = %v, want %v", n, r, root) } } for i := 0; i < 1000; i += 10 { n, _ := new(BigInt).SetString("1"+strings.Repeat("0", i), 10) r := new(BigInt).Sqrt(n) root, _ := new(BigInt).SetString("1"+strings.Repeat("0", i/2), 10) if r.Cmp(root) != 0 { t.Errorf("Sqrt(1e%d) = %v, want 1e%d", i, r, i/2) } } // Test aliasing. r.SetInt64(100) r.Sqrt(r) if r.Int64() != 10 { t.Errorf("Sqrt(100) = %v, want 10 (aliased output)", r.Int64()) } } // We can't test this together with the other Exp tests above because // it requires a different receiver setup. func TestBigIntIssue22830(t *testing.T) { one := new(BigInt).SetInt64(1) base, _ := new(BigInt).SetString("84555555300000000000", 10) mod, _ := new(BigInt).SetString("66666670001111111111", 10) want, _ := new(BigInt).SetString("17888885298888888889", 10) var tests = []int64{ 0, 1, -1, } for _, n := range tests { m := NewBigInt(n) if got := m.Exp(base, one, mod); got.Cmp(want) != 0 { t.Errorf("(%v).Exp(%s, 1, %s) = %s, want %s", n, base, mod, got, want) } } } // // Tests from src/math/big/intconv_test.go // var stringTests = []struct { in string out string base int val int64 ok bool }{ // invalid inputs {in: ""}, {in: "a"}, {in: "z"}, {in: "+"}, {in: "-"}, {in: "0b"}, {in: "0o"}, {in: "0x"}, {in: "0y"}, {in: "2", base: 2}, {in: "0b2", base: 0}, {in: "08"}, {in: "8", base: 8}, {in: "0xg", base: 0}, {in: "g", base: 16}, // invalid inputs with separators // (smoke tests only - a comprehensive set of tests is in natconv_test.go) {in: "_"}, {in: "0_"}, {in: "_0"}, {in: "-1__0"}, {in: "0x10_"}, {in: "1_000", base: 10}, // separators are not permitted for bases != 0 {in: "d_e_a_d", base: 16}, // valid inputs {"0", "0", 0, 0, true}, {"0", "0", 10, 0, true}, {"0", "0", 16, 0, true}, {"+0", "0", 0, 0, true}, {"-0", "0", 0, 0, true}, {"10", "10", 0, 10, true}, {"10", "10", 10, 10, true}, {"10", "10", 16, 16, true}, {"-10", "-10", 16, -16, true}, {"+10", "10", 16, 16, true}, {"0b10", "2", 0, 2, true}, {"0o10", "8", 0, 8, true}, {"0x10", "16", 0, 16, true}, {in: "0x10", base: 16}, {"-0x10", "-16", 0, -16, true}, {"+0x10", "16", 0, 16, true}, {"00", "0", 0, 0, true}, {"0", "0", 8, 0, true}, {"07", "7", 0, 7, true}, {"7", "7", 8, 7, true}, {"023", "19", 0, 19, true}, {"23", "23", 8, 19, true}, {"cafebabe", "cafebabe", 16, 0xcafebabe, true}, {"0b0", "0", 0, 0, true}, {"-111", "-111", 2, -7, true}, {"-0b111", "-7", 0, -7, true}, {"0b1001010111", "599", 0, 0x257, true}, {"1001010111", "1001010111", 2, 0x257, true}, {"A", "a", 36, 10, true}, {"A", "A", 37, 36, true}, {"ABCXYZ", "abcxyz", 36, 623741435, true}, {"ABCXYZ", "ABCXYZ", 62, 33536793425, true}, // valid input with separators // (smoke tests only - a comprehensive set of tests is in natconv_test.go) {"1_000", "1000", 0, 1000, true}, {"0b_1010", "10", 0, 10, true}, {"+0o_660", "432", 0, 0660, true}, {"-0xF00D_1E", "-15731998", 0, -0xf00d1e, true}, } func TestBigIntText(t *testing.T) { z := new(BigInt) for _, test := range stringTests { if !test.ok { continue } _, ok := z.SetString(test.in, test.base) if !ok { t.Errorf("%v: failed to parse", test) continue } base := test.base if base == 0 { base = 10 } if got := z.Text(base); got != test.out { t.Errorf("%v: got %s; want %s", test, got, test.out) } } } func TestBigIntAppendText(t *testing.T) { z := new(BigInt) var buf []byte for _, test := range stringTests { if !test.ok { continue } _, ok := z.SetString(test.in, test.base) if !ok { t.Errorf("%v: failed to parse", test) continue } base := test.base if base == 0 { base = 10 } i := len(buf) buf = z.Append(buf, base) if got := string(buf[i:]); got != test.out { t.Errorf("%v: got %s; want %s", test, got, test.out) } } } func TestBigIntGetString(t *testing.T) { format := func(base int) string { switch base { case 2: return "%b" case 8: return "%o" case 16: return "%x" } return "%d" } z := new(BigInt) for i, test := range stringTests { if !test.ok { continue } z.SetInt64(test.val) if test.base == 10 { if got := z.String(); got != test.out { t.Errorf("#%da got %s; want %s", i, got, test.out) } } f := format(test.base) got := fmt.Sprintf(f, z) if f == "%d" { if got != fmt.Sprintf("%d", test.val) { t.Errorf("#%db got %s; want %d", i, got, test.val) } } else { if got != test.out { t.Errorf("#%dc got %s; want %s", i, got, test.out) } } } } func TestBigIntSetString(t *testing.T) { tmp := new(BigInt) for i, test := range stringTests { // initialize to a non-zero value so that issues with parsing // 0 are detected tmp.SetInt64(1234567890) n1, ok1 := new(BigInt).SetString(test.in, test.base) n2, ok2 := tmp.SetString(test.in, test.base) expected := NewBigInt(test.val) if ok1 != test.ok || ok2 != test.ok { t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok) continue } if !ok1 { if n1 != nil { t.Errorf("#%d (input '%s') n1 != nil", i, test.in) } continue } if !ok2 { if n2 != nil { t.Errorf("#%d (input '%s') n2 != nil", i, test.in) } continue } if n1.Cmp(expected) != 0 { t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n1, test.val) } if n2.Cmp(expected) != 0 { t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n2, test.val) } } } var formatTests = []struct { input string format string output string }{ {"", "%x", ""}, {"", "%#x", ""}, {"", "%#y", "%!y(big.Int=)"}, {"10", "%b", "1010"}, {"10", "%o", "12"}, {"10", "%d", "10"}, {"10", "%v", "10"}, {"10", "%x", "a"}, {"10", "%X", "A"}, {"-10", "%X", "-A"}, {"10", "%y", "%!y(big.Int=10)"}, {"-10", "%y", "%!y(big.Int=-10)"}, {"10", "%#b", "0b1010"}, {"10", "%#o", "012"}, {"10", "%O", "0o12"}, {"-10", "%#b", "-0b1010"}, {"-10", "%#o", "-012"}, {"-10", "%O", "-0o12"}, {"10", "%#d", "10"}, {"10", "%#v", "10"}, {"10", "%#x", "0xa"}, {"10", "%#X", "0XA"}, {"-10", "%#X", "-0XA"}, {"10", "%#y", "%!y(big.Int=10)"}, {"-10", "%#y", "%!y(big.Int=-10)"}, {"1234", "%d", "1234"}, {"1234", "%3d", "1234"}, {"1234", "%4d", "1234"}, {"-1234", "%d", "-1234"}, {"1234", "% 5d", " 1234"}, {"1234", "%+5d", "+1234"}, {"1234", "%-5d", "1234 "}, {"1234", "%x", "4d2"}, {"1234", "%X", "4D2"}, {"-1234", "%3x", "-4d2"}, {"-1234", "%4x", "-4d2"}, {"-1234", "%5x", " -4d2"}, {"-1234", "%-5x", "-4d2 "}, {"1234", "%03d", "1234"}, {"1234", "%04d", "1234"}, {"1234", "%05d", "01234"}, {"1234", "%06d", "001234"}, {"-1234", "%06d", "-01234"}, {"1234", "%+06d", "+01234"}, {"1234", "% 06d", " 01234"}, {"1234", "%-6d", "1234 "}, {"1234", "%-06d", "1234 "}, {"-1234", "%-06d", "-1234 "}, {"1234", "%.3d", "1234"}, {"1234", "%.4d", "1234"}, {"1234", "%.5d", "01234"}, {"1234", "%.6d", "001234"}, {"-1234", "%.3d", "-1234"}, {"-1234", "%.4d", "-1234"}, {"-1234", "%.5d", "-01234"}, {"-1234", "%.6d", "-001234"}, {"1234", "%8.3d", " 1234"}, {"1234", "%8.4d", " 1234"}, {"1234", "%8.5d", " 01234"}, {"1234", "%8.6d", " 001234"}, {"-1234", "%8.3d", " -1234"}, {"-1234", "%8.4d", " -1234"}, {"-1234", "%8.5d", " -01234"}, {"-1234", "%8.6d", " -001234"}, {"1234", "%+8.3d", " +1234"}, {"1234", "%+8.4d", " +1234"}, {"1234", "%+8.5d", " +01234"}, {"1234", "%+8.6d", " +001234"}, {"-1234", "%+8.3d", " -1234"}, {"-1234", "%+8.4d", " -1234"}, {"-1234", "%+8.5d", " -01234"}, {"-1234", "%+8.6d", " -001234"}, {"1234", "% 8.3d", " 1234"}, {"1234", "% 8.4d", " 1234"}, {"1234", "% 8.5d", " 01234"}, {"1234", "% 8.6d", " 001234"}, {"-1234", "% 8.3d", " -1234"}, {"-1234", "% 8.4d", " -1234"}, {"-1234", "% 8.5d", " -01234"}, {"-1234", "% 8.6d", " -001234"}, {"1234", "%.3x", "4d2"}, {"1234", "%.4x", "04d2"}, {"1234", "%.5x", "004d2"}, {"1234", "%.6x", "0004d2"}, {"-1234", "%.3x", "-4d2"}, {"-1234", "%.4x", "-04d2"}, {"-1234", "%.5x", "-004d2"}, {"-1234", "%.6x", "-0004d2"}, {"1234", "%8.3x", " 4d2"}, {"1234", "%8.4x", " 04d2"}, {"1234", "%8.5x", " 004d2"}, {"1234", "%8.6x", " 0004d2"}, {"-1234", "%8.3x", " -4d2"}, {"-1234", "%8.4x", " -04d2"}, {"-1234", "%8.5x", " -004d2"}, {"-1234", "%8.6x", " -0004d2"}, {"1234", "%+8.3x", " +4d2"}, {"1234", "%+8.4x", " +04d2"}, {"1234", "%+8.5x", " +004d2"}, {"1234", "%+8.6x", " +0004d2"}, {"-1234", "%+8.3x", " -4d2"}, {"-1234", "%+8.4x", " -04d2"}, {"-1234", "%+8.5x", " -004d2"}, {"-1234", "%+8.6x", " -0004d2"}, {"1234", "% 8.3x", " 4d2"}, {"1234", "% 8.4x", " 04d2"}, {"1234", "% 8.5x", " 004d2"}, {"1234", "% 8.6x", " 0004d2"}, {"1234", "% 8.7x", " 00004d2"}, {"1234", "% 8.8x", " 000004d2"}, {"-1234", "% 8.3x", " -4d2"}, {"-1234", "% 8.4x", " -04d2"}, {"-1234", "% 8.5x", " -004d2"}, {"-1234", "% 8.6x", " -0004d2"}, {"-1234", "% 8.7x", "-00004d2"}, {"-1234", "% 8.8x", "-000004d2"}, {"1234", "%-8.3d", "1234 "}, {"1234", "%-8.4d", "1234 "}, {"1234", "%-8.5d", "01234 "}, {"1234", "%-8.6d", "001234 "}, {"1234", "%-8.7d", "0001234 "}, {"1234", "%-8.8d", "00001234"}, {"-1234", "%-8.3d", "-1234 "}, {"-1234", "%-8.4d", "-1234 "}, {"-1234", "%-8.5d", "-01234 "}, {"-1234", "%-8.6d", "-001234 "}, {"-1234", "%-8.7d", "-0001234"}, {"-1234", "%-8.8d", "-00001234"}, {"16777215", "%b", "111111111111111111111111"}, // 2**24 - 1 {"0", "%.d", ""}, {"0", "%.0d", ""}, {"0", "%3.d", ""}, } func TestBigIntFormat(t *testing.T) { for i, test := range formatTests { var x *BigInt if test.input != "" { var ok bool x, ok = new(BigInt).SetString(test.input, 0) if !ok { t.Errorf("#%d failed reading input %s", i, test.input) } } output := fmt.Sprintf(test.format, x) if output != test.output { t.Errorf("#%d got %q; want %q, {%q, %q, %q}", i, output, test.output, test.input, test.format, test.output) } } } var scanTests = []struct { input string format string output string remaining int }{ {"1010", "%b", "10", 0}, {"0b1010", "%v", "10", 0}, {"12", "%o", "10", 0}, {"012", "%v", "10", 0}, {"10", "%d", "10", 0}, {"10", "%v", "10", 0}, {"a", "%x", "10", 0}, {"0xa", "%v", "10", 0}, {"A", "%X", "10", 0}, {"-A", "%X", "-10", 0}, {"+0b1011001", "%v", "89", 0}, {"0xA", "%v", "10", 0}, {"0 ", "%v", "0", 1}, {"2+3", "%v", "2", 2}, {"0XABC 12", "%v", "2748", 3}, } func TestBigIntScan(t *testing.T) { var buf bytes.Buffer for i, test := range scanTests { x := new(BigInt) buf.Reset() buf.WriteString(test.input) if _, err := fmt.Fscanf(&buf, test.format, x); err != nil { t.Errorf("#%d error: %s", i, err) } if x.String() != test.output { t.Errorf("#%d got %s; want %s", i, x.String(), test.output) } if buf.Len() != test.remaining { t.Errorf("#%d got %d bytes remaining; want %d", i, buf.Len(), test.remaining) } } } // // Tests from src/math/big/intmarsh_test.go // var encodingTests = []string{ "0", "1", "2", "10", "1000", "1234567890", "298472983472983471903246121093472394872319615612417471234712061", } func TestBigIntGobEncoding(t *testing.T) { var medium bytes.Buffer enc := gob.NewEncoder(&medium) dec := gob.NewDecoder(&medium) for _, test := range encodingTests { for _, sign := range []string{"", "+", "-"} { x := sign + test medium.Reset() // empty buffer for each test case (in case of failures) var tx BigInt tx.SetString(x, 10) if err := enc.Encode(&tx); err != nil { t.Errorf("encoding of %s failed: %s", &tx, err) continue } var rx BigInt if err := dec.Decode(&rx); err != nil { t.Errorf("decoding of %s failed: %s", &tx, err) continue } if rx.Cmp(&tx) != 0 { t.Errorf("transmission of %s failed: got %s want %s", &tx, &rx, &tx) } } } } // Sending a nil BigInt pointer (inside a slice) on a round trip through gob should yield a zero. func TestBigIntGobEncodingNilIntInSlice(t *testing.T) { buf := new(bytes.Buffer) enc := gob.NewEncoder(buf) dec := gob.NewDecoder(buf) var in = make([]*BigInt, 1) err := enc.Encode(&in) if err != nil { t.Errorf("gob encode failed: %q", err) } var out []*BigInt err = dec.Decode(&out) if err != nil { t.Fatalf("gob decode failed: %q", err) } if len(out) != 1 { t.Fatalf("wrong len; want 1 got %d", len(out)) } var zero BigInt if out[0].Cmp(&zero) != 0 { t.Fatalf("transmission of (*BigInt)(nil) failed: got %s want 0", out) } } func TestBigIntJSONEncoding(t *testing.T) { for _, test := range encodingTests { for _, sign := range []string{"", "+", "-"} { x := sign + test var tx BigInt tx.SetString(x, 10) b, err := json.Marshal(&tx) if err != nil { t.Errorf("marshaling of %s failed: %s", &tx, err) continue } var rx BigInt if err := json.Unmarshal(b, &rx); err != nil { t.Errorf("unmarshaling of %s failed: %s", &tx, err) continue } if rx.Cmp(&tx) != 0 { t.Errorf("JSON encoding of %s failed: got %s want %s", &tx, &rx, &tx) } } } } func TestBigIntXMLEncoding(t *testing.T) { for _, test := range encodingTests { for _, sign := range []string{"", "+", "-"} { x := sign + test var tx BigInt tx.SetString(x, 0) b, err := xml.Marshal(&tx) if err != nil { t.Errorf("marshaling of %s failed: %s", &tx, err) continue } var rx BigInt if err := xml.Unmarshal(b, &rx); err != nil { t.Errorf("unmarshaling of %s failed: %s", &tx, err) continue } if rx.Cmp(&tx) != 0 { t.Errorf("XML encoding of %s failed: got %s want %s", &tx, &rx, &tx) } } } } // // Benchmarks from src/math/big/int_test.go // func BenchmarkBigIntBinomial(b *testing.B) { var z BigInt for i := b.N - 1; i >= 0; i-- { z.Binomial(1000, 990) } } func BenchmarkBigIntQuoRem(b *testing.B) { x, _ := new(BigInt).SetString("153980389784927331788354528594524332344709972855165340650588877572729725338415474372475094155672066328274535240275856844648695200875763869073572078279316458648124537905600131008790701752441155668003033945258023841165089852359980273279085783159654751552359397986180318708491098942831252291841441726305535546071", 0) y, _ := new(BigInt).SetString("7746362281539803897849273317883545285945243323447099728551653406505888775727297253384154743724750941556720663282745352402758568446486952008757638690735720782793164586481245379056001310087907017524411556680030339452580238411650898523599802732790857831596547515523593979861803187084910989428312522918414417263055355460715745539358014631136245887418412633787074173796862711588221766398229333338511838891484974940633857861775630560092874987828057333663969469797013996401149696897591265769095952887917296740109742927689053276850469671231961384715398038978492733178835452859452433234470997285516534065058887757272972533841547437247509415567206632827453524027585684464869520087576386907357207827931645864812453790560013100879070175244115566800303394525802384116508985235998027327908578315965475155235939798618031870849109894283125229184144172630553554607112725169432413343763989564437170644270643461665184965150423819594083121075825", 0) q := new(BigInt) r := new(BigInt) b.ResetTimer() for i := 0; i < b.N; i++ { q.QuoRem(y, x, r) } } func BenchmarkBigIntExp(b *testing.B) { x, _ := new(BigInt).SetString("11001289118363089646017359372117963499250546375269047542777928006103246876688756735760905680604646624353196869572752623285140408755420374049317646428185270079555372763503115646054602867593662923894140940837479507194934267532831694565516466765025434902348314525627418515646588160955862839022051353653052947073136084780742729727874803457643848197499548297570026926927502505634297079527299004267769780768565695459945235586892627059178884998772989397505061206395455591503771677500931269477503508150175717121828518985901959919560700853226255420793148986854391552859459511723547532575574664944815966793196961286234040892865", 0) y, _ := new(BigInt).SetString("0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF72", 0) n, _ := new(BigInt).SetString("0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73", 0) out := new(BigInt) for i := 0; i < b.N; i++ { out.Exp(x, y, n) } } func BenchmarkBigIntExp2(b *testing.B) { x, _ := new(BigInt).SetString("2", 0) y, _ := new(BigInt).SetString("0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF72", 0) n, _ := new(BigInt).SetString("0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73", 0) out := new(BigInt) for i := 0; i < b.N; i++ { out.Exp(x, y, n) } } func BenchmarkBigIntBitset(b *testing.B) { z := new(BigInt) z.SetBit(z, 512, 1) b.ResetTimer() b.StartTimer() for i := b.N - 1; i >= 0; i-- { z.SetBit(z, i&512, 1) } } func BenchmarkBigIntBitsetNeg(b *testing.B) { z := NewBigInt(-1) z.SetBit(z, 512, 0) b.ResetTimer() b.StartTimer() for i := b.N - 1; i >= 0; i-- { z.SetBit(z, i&512, 0) } } func BenchmarkBigIntBitsetOrig(b *testing.B) { z := new(BigInt) altSetBit(z, z, 512, 1) b.ResetTimer() b.StartTimer() for i := b.N - 1; i >= 0; i-- { altSetBit(z, z, i&512, 1) } } func BenchmarkBigIntBitsetNegOrig(b *testing.B) { z := NewBigInt(-1) altSetBit(z, z, 512, 0) b.ResetTimer() b.StartTimer() for i := b.N - 1; i >= 0; i-- { altSetBit(z, z, i&512, 0) } } func BenchmarkBigIntModInverse(b *testing.B) { p := new(BigInt).SetInt64(1) // Mersenne prime 2**1279 -1 p.Lsh(p, 1279) p.Sub(p, bigOne) x := new(BigInt).Sub(p, bigOne) z := new(BigInt) for i := 0; i < b.N; i++ { z.ModInverse(x, p) } } func BenchmarkBigIntSqrt(b *testing.B) { n, _ := new(BigInt).SetString("1"+strings.Repeat("0", 1001), 10) b.ResetTimer() t := new(BigInt) for i := 0; i < b.N; i++ { t.Sqrt(n) } } // randBigInt returns a pseudo-random Int in the range [1<<(size-1), (1< 1<<(size-1) } func benchmarkBigIntDiv(b *testing.B, aSize, bSize int) { var r = rand.New(rand.NewSource(1234)) aa := randBigInt(r, uint(aSize)) bb := randBigInt(r, uint(bSize)) if aa.Cmp(bb) < 0 { aa, bb = bb, aa } x := new(BigInt) y := new(BigInt) b.ResetTimer() for i := 0; i < b.N; i++ { x.DivMod(aa, bb, y) } } func BenchmarkBigIntDiv(b *testing.B) { sizes := []int{ 10, 20, 50, 100, 200, 500, 1000, 1e4, 1e5, 1e6, 1e7, } for _, i := range sizes { j := 2 * i b.Run(fmt.Sprintf("%d/%d", j, i), func(b *testing.B) { benchmarkBigIntDiv(b, j, i) }) } } apd-3.2.1/condition.go000066400000000000000000000124011450022325000145650ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "errors" "fmt" "strings" ) // Condition holds condition flags. type Condition uint32 const ( // SystemOverflow is raised when an exponent is greater than MaxExponent. SystemOverflow Condition = 1 << iota // SystemUnderflow is raised when an exponent is less than MinExponent. SystemUnderflow // Overflow is raised when the exponent of a result is too large to be // represented. Overflow // Underflow is raised when a result is both subnormal and inexact. Underflow // Inexact is raised when a result is not exact (one or more non-zero // coefficient digits were discarded during rounding). Inexact // Subnormal is raised when a result is subnormal (its adjusted exponent is // less than Emin), before any rounding. Subnormal // Rounded is raised when a result has been rounded (that is, some zero or // non-zero coefficient digits were discarded). Rounded // DivisionUndefined is raised when both division operands are 0. DivisionUndefined // DivisionByZero is raised when a non-zero dividend is divided by zero. DivisionByZero // DivisionImpossible is raised when integer division cannot be exactly // represented with the given precision. DivisionImpossible // InvalidOperation is raised when a result would be undefined or impossible. InvalidOperation // Clamped is raised when the exponent of a result has been altered or // constrained in order to fit the constraints of the Decimal representation. Clamped ) // Any returns true if any flag is true. func (r Condition) Any() bool { return r != 0 } // SystemOverflow returns true if the SystemOverflow flag is set. func (r Condition) SystemOverflow() bool { return r&SystemOverflow != 0 } // SystemUnderflow returns true if the SystemUnderflow flag is set. func (r Condition) SystemUnderflow() bool { return r&SystemUnderflow != 0 } // Overflow returns true if the Overflow flag is set. func (r Condition) Overflow() bool { return r&Overflow != 0 } // Underflow returns true if the Underflow flag is set. func (r Condition) Underflow() bool { return r&Underflow != 0 } // Inexact returns true if the Inexact flag is set. func (r Condition) Inexact() bool { return r&Inexact != 0 } // Subnormal returns true if the Subnormal flag is set. func (r Condition) Subnormal() bool { return r&Subnormal != 0 } // Rounded returns true if the Rounded flag is set. func (r Condition) Rounded() bool { return r&Rounded != 0 } // DivisionUndefined returns true if the DivisionUndefined flag is set. func (r Condition) DivisionUndefined() bool { return r&DivisionUndefined != 0 } // DivisionByZero returns true if the DivisionByZero flag is set. func (r Condition) DivisionByZero() bool { return r&DivisionByZero != 0 } // DivisionImpossible returns true if the DivisionImpossible flag is set. func (r Condition) DivisionImpossible() bool { return r&DivisionImpossible != 0 } // InvalidOperation returns true if the InvalidOperation flag is set. func (r Condition) InvalidOperation() bool { return r&InvalidOperation != 0 } // Clamped returns true if the Clamped flag is set. func (r Condition) Clamped() bool { return r&Clamped != 0 } // GoError converts r to an error based on the given traps and returns // r. Traps are the conditions which will trigger an error result if the // corresponding Flag condition occurred. func (r Condition) GoError(traps Condition) (Condition, error) { const ( systemErrors = SystemOverflow | SystemUnderflow ) var err error if r&systemErrors != 0 { err = errors.New(errExponentOutOfRangeStr) } else if t := r & traps; t != 0 { err = errors.New(t.String()) } return r, err } func (r Condition) String() string { var names []string for i := Condition(1); r != 0; i <<= 1 { if r&i == 0 { continue } r ^= i var s string switch i { case SystemOverflow, SystemUnderflow: continue case Overflow: s = "overflow" case Underflow: s = "underflow" case Inexact: s = "inexact" case Subnormal: s = "subnormal" case Rounded: s = "rounded" case DivisionUndefined: s = "division undefined" case DivisionByZero: s = "division by zero" case DivisionImpossible: s = "division impossible" case InvalidOperation: s = "invalid operation" case Clamped: s = "clamped" default: panic(fmt.Errorf("unknown condition %d", i)) } names = append(names, s) } return strings.Join(names, ", ") } // negateOverflowFlags converts Overflow and SystemOverflow flags into their // equivalent Underflows. func (r Condition) negateOverflowFlags() Condition { if r.Overflow() { // Underflow always also means Subnormal. See GDA definition. r |= Underflow | Subnormal r &= ^Overflow } if r.SystemOverflow() { r |= SystemUnderflow r &= ^SystemOverflow } return r } apd-3.2.1/const.go000066400000000000000000000220771450022325000137370ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import "math" var ( bigOne = NewBigInt(1) bigTwo = NewBigInt(2) bigFive = NewBigInt(5) bigTen = NewBigInt(10) decimalZero = New(0, 0) decimalOneEighth = New(125, -3) decimalHalf = New(5, -1) decimalOne = New(1, 0) decimalTwo = New(2, 0) decimalThree = New(3, 0) decimalEight = New(8, 0) decimalMaxInt64 = New(math.MaxInt64, 0) decimalMinInt64 = New(math.MinInt64, 0) decimalCbrtC1 = makeConst(strCbrtC1) decimalCbrtC2 = makeConst(strCbrtC2) decimalCbrtC3 = makeConst(strCbrtC3) // ln(10) decimalLn10 = makeConstWithPrecision(strLn10) // 1/ln(10) decimalInvLn10 = makeConstWithPrecision(strInvLn10) ) func makeConst(strVal string) *Decimal { d := &Decimal{} _, _, err := d.SetString(strVal) if err != nil { panic(err) } return d } // constWithPrecision implements a look-up table for a constant, rounded-down to // various precisions. The point is to avoid doing calculations with all the // digits of the constant when a smaller precision is required. type constWithPrecision struct { unrounded Decimal vals []Decimal } func makeConstWithPrecision(strVal string) *constWithPrecision { c := &constWithPrecision{} if _, _, err := c.unrounded.SetString(strVal); err != nil { panic(err) } // The length of the string might be one higher than the available precision // (because of the decimal point), but that's ok. maxPrec := uint32(len(strVal)) for p := uint32(1); p < maxPrec; p *= 2 { var d Decimal ctx := Context{ Precision: p, Rounding: RoundHalfUp, MaxExponent: MaxExponent, MinExponent: MinExponent, } _, err := ctx.Round(&d, &c.unrounded) if err != nil { panic(err) } c.vals = append(c.vals, d) } return c } // get returns the given constant, rounded down to a precision at least as high // as the given precision. func (c *constWithPrecision) get(precision uint32) *Decimal { i := 0 // Find the smallest precision available that's at least as high as precision, // i.e. Ceil[ log2(p) ] = 1 + Floor[ log2(p-1) ] if precision > 1 { precision-- i++ } for precision >= 16 { precision /= 16 i += 4 } for precision >= 2 { precision /= 2 i++ } if i >= len(c.vals) { return &c.unrounded } return &c.vals[i] } const strLn10 = "2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058498078280597511938544450099781311469159346662410718466923101075984383191912922307925037472986509290098803919417026544168163357275557031515961135648465461908970428197633658369837163289821744073660091621778505417792763677311450417821376601110107310423978325218948988175979217986663943195239368559164471182467532456309125287783309636042629821530408745609277607266413547875766162629265682987049579549139549180492090694385807900327630179415031178668620924085379498612649334793548717374516758095370882810674524401058924449764796860751202757241818749893959716431055188481952883307466993178146349300003212003277656541304726218839705967944579434683432183953044148448037013057536742621536755798147704580314136377932362915601281853364984669422614652064599420729171193706024449293580370077189810973625332245483669885055282859661928050984471751985036666808749704969822732202448233430971691111368135884186965493237149969419796878030088504089796185987565798948364452120436982164152929878117429733325886079159125109671875109292484750239305726654462762009230687915181358034777012955936462984123664970233551745861955647724618577173693684046765770478743197805738532718109338834963388130699455693993461010907456160333122479493604553618491233330637047517248712763791409243983318101647378233796922656376820717069358463945316169494117018419381194054164494661112747128197058177832938417422314099300229115023621921867233372683856882735333719251034129307056325444266114297653883018223840910261985828884335874559604530045483707890525784731662837019533922310475275649981192287427897137157132283196410034221242100821806795252766898581809561192083917607210809199234615169525990994737827806481280587927319938934534153201859697110214075422827962982370689417647406422257572124553925261793736524344405605953365915391603125244801493132345724538795243890368392364505078817313597112381453237015084134911223243909276817247496079557991513639828810582857405380006533716555530141963322419180876210182049194926514838926922937079" const strInvLn10 = "0.4342944819032518276511289189166050822943970058036665661144537831658646492088707747292249493384317483187061067447663037336416792871589639065692210646628122658521270865686703295933708696588266883311636077384905142844348666768646586085135561482123487653435434357317253835622281395603048646652366095539377356176323431916710991411597894962993512457934926357655469077671082419150479910989674900103277537653570270087328550951731440674697951899513594088040423931518868108402544654089797029863286828762624144013457043546132920600712605104028367125954846287707861998992326748439902348171535934551079475492552482577820679220140931468164467381030560475635720408883383209488996522717494541331791417640247407505788767860971099257547730046048656049515610057985741340272675201439247917970859047931285212493341197329877226463885350226083881626316463883553685501768460295286399391633510647555704050513182342988874882120643595023818902643317711537382203362634416478397146001858396093006317333986134035135741787144971453076492968331392399810608505734816169809280016199523523117237676561989228127013815804248715978344927215947562057179993483814031940166771520104787197582531617951490375597514246570736646439756863149325162498727994852637448791165959219701720662704559284657036462635675733575739369673994570909602526350957193468839951236811356428010958778313759442713049980643798750414472095974872674060160650105375287000491167867133309154761441005054775930890767885596533432190763128353570304854020979941614010807910607498871752495841461303867532086001324486392545573072842386175970677989354844570318359336523016027971626535726514428519866063768635338181954876389161343652374759465663921380736144503683797876824369028804493640496751871720614130731804417180216440993200651069696951247072666224570004229341407923361685302418860272411867806272570337552562870767696632173672454758133339263840130320038598899947332285703494195837691472090608812447825078736711573033931565625157907093245370450744326623349807143038059581776957944070042202545430531910888982754062263600601879152267477788232096025228766762416332296812464502577295040226623627536311798532153780883272326920785980990757434437367248710355853306546581653535157943990070326436222520010336980419843015524524173190520247212241110927324425302930200871037337504867498689117225672067268275246578790446735268575794059983346595878592624978725380185506389602375304294539963737367434680767515249986297676732404903363175488195323680087668648666069282082342536311304939972702858872849086258458687045569244548538607202497396631126372122497538854967981580284810494724140453341192674240839673061167234256843129624666246259542760677182858963306586513950932049023032806357536242804315480658368852257832901530787483141985929074121415344772165398214847619288406571345438798607895199435011532826457742311266817183284968697890904324421005272233475053141625981646457044538901148313760708445483457955728303866473638468537587172210685993933008378534367552699899185150879055911525282664" const ( // Cbrt uses a quadratic polynomial that approximates the cube root // of x when 0.125 <= x <= 1. This approximation is the starting point // of the convergence loop. Coefficients are from: // https://people.freebsd.org/~lstewart/references/apple_tr_kt32_cuberoot.pdf strCbrtC1 = "-0.46946116" strCbrtC2 = "1.072302" strCbrtC3 = "0.3812513" ) apd-3.2.1/const_test.go000066400000000000000000000021041450022325000147630ustar00rootroot00000000000000// Copyright 2017 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import "testing" func TestConstWithPrecision(t *testing.T) { c := makeConstWithPrecision("123.456789") expected := []string{ "1E+2", // 0 "1E+2", // 1 "1.2E+2", // 2 "123.5", "123.5", // 3, 4 "123.45679", "123.45679", "123.45679", "123.45679", // 5..8 "123.456789", "123.456789", "123.456789", // 9+ } for i, e := range expected { if s := c.get(uint32(i)).String(); s != e { t.Errorf("%d: expected %s, got %s", i, e, s) } } } apd-3.2.1/context.go000066400000000000000000001014011450022325000142620ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "errors" "fmt" "math" ) // Context maintains options for Decimal operations. It can safely be used // concurrently, but not modified concurrently. Arguments for any method // can safely be used as both result and operand. type Context struct { // Precision is the number of places to round during rounding; this is // effectively the total number of digits (before and after the decimal // point). Precision uint32 // MaxExponent specifies the largest effective exponent. The // effective exponent is the value of the Decimal in scientific notation. That // is, for 10e2, the effective exponent is 3 (1.0e3). Zero (0) is not a special // value; it does not disable this check. MaxExponent int32 // MinExponent is similar to MaxExponent, but for the smallest effective // exponent. MinExponent int32 // Traps are the conditions which will trigger an error result if the // corresponding Flag condition occurred. Traps Condition // Rounding specifies the Rounder to use during rounding. RoundHalfUp is used if // empty or not present in Roundings. Rounding Rounder } const ( // DefaultTraps is the default trap set used by BaseContext. DefaultTraps = SystemOverflow | SystemUnderflow | Overflow | Underflow | Subnormal | DivisionUndefined | DivisionByZero | DivisionImpossible | InvalidOperation errZeroPrecisionStr = "Context may not have 0 Precision for this operation" ) // BaseContext is a useful default Context. Should not be mutated. var BaseContext = Context{ // Disable rounding. Precision: 0, // MaxExponent and MinExponent are set to the packages's limits. MaxExponent: MaxExponent, MinExponent: MinExponent, // Default error conditions. Traps: DefaultTraps, } // WithPrecision returns a copy of c but with the specified precision. func (c *Context) WithPrecision(p uint32) *Context { r := new(Context) *r = *c r.Precision = p return r } // goError converts flags into an error based on c.Traps. //gcassert:inline func (c *Context) goError(flags Condition) (Condition, error) { if flags == 0 { return flags, nil } return flags.GoError(c.Traps) } // etiny returns the smallest value an Exponent can contain. func (c *Context) etiny() int32 { return c.MinExponent - int32(c.Precision) + 1 } // shouldSetAsNaN determines whether setAsNaN should be called, given // the provided values, where x is required and y is optional. It is // split from setAsNaN to permit inlining of this function. //gcassert:inline func (c *Context) shouldSetAsNaN(x, y *Decimal) bool { return x.Form == NaNSignaling || x.Form == NaN || (y != nil && (y.Form == NaNSignaling || y.Form == NaN)) } // setAsNaN sets d to the first NaNSignaling, or otherwise first NaN, of // x and y. x is required, y is optional. Expects one of the two inputs // to be NaN. func (c *Context) setAsNaN(d *Decimal, x, y *Decimal) (Condition, error) { var nan *Decimal // Per the method contract, NaNSignaling takes precedence over NaN. if x.Form == NaNSignaling { nan = x } else if y != nil && y.Form == NaNSignaling { nan = y } else if x.Form == NaN { nan = x } else if y != nil && y.Form == NaN { nan = y } else { return 0, errors.New("no NaN value found; was shouldSetAsNaN called?") } d.Set(nan) var res Condition if nan.Form == NaNSignaling { res = InvalidOperation d.Form = NaN } _, err := c.goError(res) return res, err } func (c *Context) add(d, x, y *Decimal, subtract bool) (Condition, error) { if c.shouldSetAsNaN(x, y) { return c.setAsNaN(d, x, y) } xn := x.Negative yn := y.Negative != subtract if xi, yi := x.Form == Infinite, y.Form == Infinite; xi || yi { if xi && yi && xn != yn { d.Set(decimalNaN) return c.goError(InvalidOperation) } else if xi { d.Set(x) } else { d.Set(decimalInfinity) d.Negative = yn } return 0, nil } var tmp BigInt a, b, s, err := upscale(x, y, &tmp) if err != nil { return 0, fmt.Errorf("add: %w", err) } d.Negative = xn if xn == yn { d.Coeff.Add(a, b) } else { d.Coeff.Sub(a, b) switch d.Coeff.Sign() { case -1: d.Negative = !d.Negative d.Coeff.Neg(&d.Coeff) case 0: d.Negative = c.Rounding == RoundFloor } } d.Exponent = s d.Form = Finite res := c.round(d, d) return c.goError(res) } // Add sets d to the sum x+y. func (c *Context) Add(d, x, y *Decimal) (Condition, error) { return c.add(d, x, y, false) } // Sub sets d to the difference x-y. func (c *Context) Sub(d, x, y *Decimal) (Condition, error) { return c.add(d, x, y, true) } // Abs sets d to |x| (the absolute value of x). func (c *Context) Abs(d, x *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, nil) { return c.setAsNaN(d, x, nil) } d.Abs(x) res := c.round(d, d) return c.goError(res) } // Neg sets d to -x. func (c *Context) Neg(d, x *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, nil) { return c.setAsNaN(d, x, nil) } d.Neg(x) res := c.round(d, d) return c.goError(res) } // Mul sets d to the product x*y. func (c *Context) Mul(d, x, y *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, y) { return c.setAsNaN(d, x, y) } // The sign of the result is the exclusive or of the signs of the operands. neg := x.Negative != y.Negative if xi, yi := x.Form == Infinite, y.Form == Infinite; xi || yi { if x.IsZero() || y.IsZero() { d.Set(decimalNaN) return c.goError(InvalidOperation) } d.Set(decimalInfinity) d.Negative = neg return 0, nil } d.Coeff.Mul(&x.Coeff, &y.Coeff) d.Negative = neg d.Form = Finite res := d.setExponent(c, unknownNumDigits, 0, int64(x.Exponent), int64(y.Exponent)) res |= c.round(d, d) return c.goError(res) } func (c *Context) quoSpecials(d, x, y *Decimal, canClamp bool) (bool, Condition, error) { if c.shouldSetAsNaN(x, y) { res, err := c.setAsNaN(d, x, y) return true, res, err } // The sign of the result is the exclusive or of the signs of the operands. neg := x.Negative != y.Negative if xi, yi := x.Form == Infinite, y.Form == Infinite; xi || yi { var res Condition if xi && yi { d.Set(decimalNaN) res = InvalidOperation } else if xi { d.Set(decimalInfinity) d.Negative = neg } else { d.SetInt64(0) d.Negative = neg if canClamp { d.Exponent = c.etiny() res = Clamped } } res, err := c.goError(res) return true, res, err } if y.IsZero() { var res Condition if x.IsZero() { res |= DivisionUndefined d.Set(decimalNaN) } else { res |= DivisionByZero d.Set(decimalInfinity) d.Negative = neg } res, err := c.goError(res) return true, res, err } if c.Precision == 0 { // 0 precision is disallowed because we compute the required number of digits // during the 10**x calculation using the precision. return true, 0, errors.New(errZeroPrecisionStr) } return false, 0, nil } // Quo sets d to the quotient x/y for y != 0. c.Precision must be > 0. If an // exact division is required, use a context with high precision and verify // it was exact by checking the Inexact flag on the return Condition. func (c *Context) Quo(d, x, y *Decimal) (Condition, error) { if set, res, err := c.quoSpecials(d, x, y, true); set { return res, err } // The sign of the result is the exclusive or of the signs of the operands. neg := x.Negative != y.Negative // Shift the resulting exponent by the difference between the dividend and // the divisor's exponent after performing arithmetic on the coefficients. shift := int64(x.Exponent - y.Exponent) var res Condition if x.IsZero() { d.Set(decimalZero) d.Negative = neg res |= d.setExponent(c, unknownNumDigits, res, shift) return c.goError(res) } var dividend, divisor BigInt dividend.Abs(&x.Coeff) divisor.Abs(&y.Coeff) // The operand coefficients are adjusted so that the coefficient of the // dividend is greater than or equal to the coefficient of the divisor and // is also less than ten times the coefficient of the divisor. While doing // so, keep track of how far the two have been adjusted. ndDividend := NumDigits(÷nd) ndDivisor := NumDigits(&divisor) ndDiff := ndDividend - ndDivisor var tmpE BigInt if ndDiff < 0 { // numDigits(dividend) < numDigits(divisor), multiply dividend by 10^diff. dividend.Mul(÷nd, tableExp10(-ndDiff, &tmpE)) } else if ndDiff > 0 { // numDigits(dividend) > numDigits(divisor), multiply divisor by 10^diff. divisor.Mul(&divisor, tableExp10(ndDiff, &tmpE)) } adjCoeffs := -ndDiff if dividend.Cmp(&divisor) < 0 { // dividend < divisor, multiply dividend by 10. dividend.Mul(÷nd, bigTen) adjCoeffs++ } // In order to compute the decimal remainder part, add enough 0s to the // numerator to accurately round with the given precision. -1 because the // previous adjustment ensured that the dividend is already greater than or // equal to the divisor, so the result will always be greater than or equal // to 1. adjExp10 := int64(c.Precision - 1) dividend.Mul(÷nd, tableExp10(adjExp10, &tmpE)) // Perform the division. var rem BigInt d.Coeff.QuoRem(÷nd, &divisor, &rem) d.Form = Finite d.Negative = neg // If there was a remainder, it is taken into account for rounding. To do // so, we determine whether the remainder was more or less than half of the // divisor and round accordingly. nd := NumDigits(&d.Coeff) if rem.Sign() != 0 { // Use the adjusted exponent to determine if we are Subnormal. // If so, don't round. This computation of adj and the check // against MinExponent mirrors the logic in setExponent. adj := shift + (-adjCoeffs) + (-adjExp10) + nd - 1 if adj >= int64(c.MinExponent) { res |= Inexact | Rounded rem.Mul(&rem, bigTwo) half := rem.Cmp(&divisor) if c.Rounding.ShouldAddOne(&d.Coeff, d.Negative, half) { d.Coeff.Add(&d.Coeff, bigOne) // The coefficient changed, so recompute num digits in // setExponent. nd = unknownNumDigits } } } res |= d.setExponent(c, nd, res, shift, -adjCoeffs, -adjExp10) return c.goError(res) } // QuoInteger sets d to the integer part of the quotient x/y. If the result // cannot fit in d.Precision digits, an error is returned. func (c *Context) QuoInteger(d, x, y *Decimal) (Condition, error) { if set, res, err := c.quoSpecials(d, x, y, false); set { return res, err } // The sign of the result is the exclusive or of the signs of the operands. neg := x.Negative != y.Negative var res Condition var tmp BigInt a, b, _, err := upscale(x, y, &tmp) if err != nil { return 0, fmt.Errorf("QuoInteger: %w", err) } d.Coeff.Quo(a, b) d.Form = Finite if d.NumDigits() > int64(c.Precision) { d.Set(decimalNaN) res |= DivisionImpossible } d.Exponent = 0 d.Negative = neg return c.goError(res) } // Rem sets d to the remainder part of the quotient x/y. If // the integer part cannot fit in d.Precision digits, an error is returned. func (c *Context) Rem(d, x, y *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, y) { return c.setAsNaN(d, x, y) } if x.Form != Finite { d.Set(decimalNaN) return c.goError(InvalidOperation) } if y.Form == Infinite { d.Set(x) return 0, nil } var res Condition if y.IsZero() { if x.IsZero() { res |= DivisionUndefined } else { res |= InvalidOperation } d.Set(decimalNaN) return c.goError(res) } var tmp1 BigInt a, b, s, err := upscale(x, y, &tmp1) if err != nil { return 0, fmt.Errorf("Rem: %w", err) } var tmp2 BigInt tmp2.QuoRem(a, b, &d.Coeff) if NumDigits(&tmp2) > int64(c.Precision) { d.Set(decimalNaN) return c.goError(DivisionImpossible) } d.Form = Finite d.Exponent = s // The sign of the result is sign if the dividend. d.Negative = x.Negative res |= c.round(d, d) return c.goError(res) } func (c *Context) rootSpecials(d, x *Decimal, factor int32) (bool, Condition, error) { if c.shouldSetAsNaN(x, nil) { res, err := c.setAsNaN(d, x, nil) return true, res, err } if x.Form == Infinite { if x.Negative { d.Set(decimalNaN) res, err := c.goError(InvalidOperation) return true, res, err } d.Set(decimalInfinity) return true, 0, nil } switch x.Sign() { case -1: if factor%2 == 0 { d.Set(decimalNaN) res, err := c.goError(InvalidOperation) return true, res, err } case 0: d.Set(x) d.Exponent /= factor return true, 0, nil } return false, 0, nil } // Sqrt sets d to the square root of x. Sqrt uses the Babylonian method // for computing the square root, which uses O(log p) steps for p digits // of precision. func (c *Context) Sqrt(d, x *Decimal) (Condition, error) { // See: Properly Rounded Variable Precision Square Root by T. E. Hull // and A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, // pp229–237, ACM, September 1985. if set, res, err := c.rootSpecials(d, x, 2); set { return res, err } // workp is the number of digits of precision used. We use the same precision // as in decNumber. workp := c.Precision + 1 if nd := uint32(x.NumDigits()); workp < nd { workp = nd } if workp < 7 { workp = 7 } var f Decimal f.Set(x) nd := x.NumDigits() e := nd + int64(x.Exponent) f.Exponent = int32(-nd) nc := c.WithPrecision(workp) nc.Rounding = RoundHalfEven ed := MakeErrDecimal(nc) // Set approx to the first guess, based on whether e (the exponent part of x) // is odd or even. var approx Decimal if e%2 == 0 { approx.SetFinite(819, -3) ed.Mul(&approx, &approx, &f) ed.Add(&approx, &approx, New(259, -3)) } else { f.Exponent-- e++ approx.SetFinite(259, -2) ed.Mul(&approx, &approx, &f) ed.Add(&approx, &approx, New(819, -4)) } // Now we repeatedly improve approx. Our precision improves quadratically, // which we keep track of in p. p := uint32(3) var tmp Decimal // The algorithm in the paper says to use c.Precision + 2. decNumber uses // workp + 2. But we use workp + 5 to make the tests pass. This means it is // possible there are inputs we don't compute correctly and could be 1ulp off. for maxp := workp + 5; p != maxp; { p = 2*p - 2 if p > maxp { p = maxp } nc.Precision = p // tmp = f / approx ed.Quo(&tmp, &f, &approx) // tmp = approx + f / approx ed.Add(&tmp, &tmp, &approx) // approx = 0.5 * (approx + f / approx) ed.Mul(&approx, &tmp, decimalHalf) } // At this point the paper says: "approx is now within 1 ulp of the properly // rounded square root off; to ensure proper rounding, compare squares of // (approx - l/2 ulp) and (approx + l/2 ulp) with f." We originally implemented // the proceeding algorithm from the paper. However none of the tests take // any of the branches that modify approx. Our best guess as to why is that // since we use workp + 5 instead of the + 2 as described in the paper, // we are more accurate than this section needed to account for. Thus, // we have removed the block from this implementation. if err := ed.Err(); err != nil { return 0, err } d.Set(&approx) d.Exponent += int32(e / 2) nc.Precision = c.Precision nc.Rounding = RoundHalfEven res := nc.round(d, d) return nc.goError(res) } // Cbrt sets d to the cube root of x. func (c *Context) Cbrt(d, x *Decimal) (Condition, error) { // The cube root calculation is implemented using Newton-Raphson // method. We start with an initial estimate for cbrt(d), and // then iterate: // x_{n+1} = 1/3 * ( 2 * x_n + (d / x_n / x_n) ). if set, res, err := c.rootSpecials(d, x, 3); set { return res, err } var ax, z Decimal ax.Abs(x) z.Set(&ax) neg := x.Negative nc := BaseContext.WithPrecision(c.Precision*2 + 2) ed := MakeErrDecimal(nc) exp8 := 0 // See: Turkowski, Ken. Computing the cube root. technical report, Apple // Computer, 1998. // https://people.freebsd.org/~lstewart/references/apple_tr_kt32_cuberoot.pdf // // Computing the cube root of any number is reduced to computing // the cube root of a number between 0.125 and 1. After the next loops, // x = z * 8^exp8 will hold. for z.Cmp(decimalOneEighth) < 0 { exp8-- ed.Mul(&z, &z, decimalEight) } for z.Cmp(decimalOne) > 0 { exp8++ ed.Mul(&z, &z, decimalOneEighth) } // Use this polynomial to approximate the cube root between 0.125 and 1. // z = (-0.46946116 * z + 1.072302) * z + 0.3812513 // It will serve as an initial estimate, hence the precision of this // computation may only impact performance, not correctness. var z0 Decimal z0.Set(&z) ed.Mul(&z, &z, decimalCbrtC1) ed.Add(&z, &z, decimalCbrtC2) ed.Mul(&z, &z, &z0) ed.Add(&z, &z, decimalCbrtC3) for ; exp8 < 0; exp8++ { ed.Mul(&z, &z, decimalHalf) } for ; exp8 > 0; exp8-- { ed.Mul(&z, &z, decimalTwo) } // Loop until convergence. for loop := nc.newLoop("cbrt", &z, c.Precision+1, 1); ; { // z = (2.0 * z0 + x / (z0 * z0) ) / 3.0; z0.Set(&z) ed.Mul(&z, &z, &z0) ed.Quo(&z, &ax, &z) ed.Add(&z, &z, &z0) ed.Add(&z, &z, &z0) ed.Quo(&z, &z, decimalThree) if err := ed.Err(); err != nil { return 0, err } if done, err := loop.done(&z); err != nil { return 0, err } else if done { break } } z0.Set(x) res := c.round(d, &z) res, err := c.goError(res) d.Negative = neg // Set z = d^3 to check for exactness. ed.Mul(&z, d, d) ed.Mul(&z, &z, d) if err := ed.Err(); err != nil { return 0, err } // Result is exact if z0.Cmp(&z) == 0 { return 0, nil } return res, err } func (c *Context) logSpecials(d, x *Decimal) (bool, Condition, error) { if c.shouldSetAsNaN(x, nil) { res, err := c.setAsNaN(d, x, nil) return true, res, err } if x.Sign() < 0 { d.Set(decimalNaN) res, err := c.goError(InvalidOperation) return true, res, err } if x.Form == Infinite { d.Set(decimalInfinity) return true, 0, nil } if x.Cmp(decimalZero) == 0 { d.Set(decimalInfinity) d.Negative = true return true, 0, nil } if x.Cmp(decimalOne) == 0 { d.Set(decimalZero) return true, 0, nil } return false, 0, nil } // Ln sets d to the natural log of x. func (c *Context) Ln(d, x *Decimal) (Condition, error) { // See: On the Use of Iteration Methods for Approximating the Natural // Logarithm, James F. Epperson, The American Mathematical Monthly, Vol. 96, // No. 9, November 1989, pp. 831-835. if set, res, err := c.logSpecials(d, x); set { return res, err } // The internal precision needs to be a few digits higher because errors in // series/iterations add up. p := c.Precision + 2 nc := c.WithPrecision(p) nc.Rounding = RoundHalfEven ed := MakeErrDecimal(nc) var tmp1, tmp2, tmp3, tmp4, z, resAdjust Decimal z.Set(x) // To get an initial estimate, we first reduce the input range to the interval // [0.1, 1) by changing the exponent, and later adjust the result by a // multiple of ln(10). // // However, this does not work well for z very close to 1, where the result is // very close to 0. For example: // z = 1.00001 // ln(z) = 0.00000999995 // If we adjust by 10: // z' = 0.100001 // ln(z') = -2.30257509304 // ln(10) = 2.30258509299 // ln(z) = 0.00001000... // // The issue is that we may need to calculate a much higher (~double) // precision for ln(z) because many of the significant digits cancel out. // // Halley's iteration has a similar problem when z is close to 1: in this case // the correction term (exp(a_n) - z) needs to be calculated to a high // precision. So for z close to 1 (before scaling) we use a power series // instead (which converges very rapidly in this range). // tmp1 = z - 1 ed.Sub(&tmp1, &z, decimalOne) // tmp3 = 0.1 tmp3.SetFinite(1, -1) usePowerSeries := false if tmp2.Abs(&tmp1).Cmp(&tmp3) <= 0 { usePowerSeries = true } else { // Reduce input to range [0.1, 1). expDelta := int32(z.NumDigits()) + z.Exponent z.Exponent -= expDelta // We multiplied the input by 10^-expDelta, we will need to add // ln(10^expDelta) = expDelta * ln(10) // to the result. resAdjust.setCoefficient(int64(expDelta)) ed.Mul(&resAdjust, &resAdjust, decimalLn10.get(p)) // tmp1 = z - 1 ed.Sub(&tmp1, &z, decimalOne) if tmp2.Abs(&tmp1).Cmp(&tmp3) <= 0 { usePowerSeries = true } else { // Compute an initial estimate using floats. zFloat, err := z.Float64() if err != nil { // We know that z is in a reasonable range; no errors should happen during conversion. return 0, err } if _, err := tmp1.SetFloat64(math.Log(zFloat)); err != nil { return 0, err } } } if usePowerSeries { // We use the power series: // ln(1+x) = 2 sum [ 1 / (2n+1) * (x / (x+2))^(2n+1) ] // // This converges rapidly for small x. // See https://en.wikipedia.org/wiki/Logarithm#Power_series // tmp1 is already x // tmp3 = x + 2 ed.Add(&tmp3, &tmp1, decimalTwo) // tmp2 = (x / (x+2)) ed.Quo(&tmp2, &tmp1, &tmp3) // tmp1 = tmp3 = 2 * (x / (x+2)) ed.Add(&tmp3, &tmp2, &tmp2) tmp1.Set(&tmp3) var eps Decimal eps.Coeff.Set(bigOne) eps.Exponent = -int32(p) for n := 1; ; n++ { // tmp3 *= (x / (x+2))^2 ed.Mul(&tmp3, &tmp3, &tmp2) ed.Mul(&tmp3, &tmp3, &tmp2) // tmp4 = 2n+1 tmp4.SetFinite(int64(2*n+1), 0) ed.Quo(&tmp4, &tmp3, &tmp4) ed.Add(&tmp1, &tmp1, &tmp4) if tmp4.Abs(&tmp4).Cmp(&eps) <= 0 { break } } } else { // Use Halley's Iteration. // We use a bit more precision than the context asks for in newLoop because // this is not the final result. for loop := nc.newLoop("ln", x, c.Precision+1, 1); ; { // tmp1 = a_n (either from initial estimate or last iteration) // tmp2 = exp(a_n) ed.Exp(&tmp2, &tmp1) // tmp3 = exp(a_n) - z ed.Sub(&tmp3, &tmp2, &z) // tmp3 = 2 * (exp(a_n) - z) ed.Add(&tmp3, &tmp3, &tmp3) // tmp4 = exp(a_n) + z ed.Add(&tmp4, &tmp2, &z) // tmp2 = 2 * (exp(a_n) - z) / (exp(a_n) + z) ed.Quo(&tmp2, &tmp3, &tmp4) // tmp1 = a_(n+1) = a_n - 2 * (exp(a_n) - z) / (exp(a_n) + z) ed.Sub(&tmp1, &tmp1, &tmp2) if done, err := loop.done(&tmp1); err != nil { return 0, err } else if done { break } if err := ed.Err(); err != nil { return 0, err } } } // Apply the adjustment due to the initial rescaling. ed.Add(&tmp1, &tmp1, &resAdjust) if err := ed.Err(); err != nil { return 0, err } res := c.round(d, &tmp1) res |= Inexact return c.goError(res) } // Log10 sets d to the base 10 log of x. func (c *Context) Log10(d, x *Decimal) (Condition, error) { if set, res, err := c.logSpecials(d, x); set { return res, err } // TODO(mjibson): This is exact under some conditions. res := Inexact nc := BaseContext.WithPrecision(c.Precision + 2) nc.Rounding = RoundHalfEven var z Decimal _, err := nc.Ln(&z, x) if err != nil { return 0, fmt.Errorf("ln: %w", err) } nc.Precision = c.Precision qr, err := nc.Mul(d, &z, decimalInvLn10.get(c.Precision+2)) if err != nil { return 0, err } res |= qr return c.goError(res) } // Exp sets d = e**x. func (c *Context) Exp(d, x *Decimal) (Condition, error) { // See: Variable Precision Exponential Function, T. E. Hull and A. Abrham, ACM // Transactions on Mathematical Software, Vol 12 #2, pp79-91, ACM, June 1986. if c.shouldSetAsNaN(x, nil) { return c.setAsNaN(d, x, nil) } if x.Form == Infinite { if x.Negative { d.Set(decimalZero) } else { d.Set(decimalInfinity) } return 0, nil } if x.IsZero() { d.Set(decimalOne) return 0, nil } if c.Precision == 0 { return 0, errors.New(errZeroPrecisionStr) } res := Inexact | Rounded // Stage 1 cp := c.Precision var tmp1 Decimal tmp1.Abs(x) if f, err := tmp1.Float64(); err == nil { // This algorithm doesn't work if currentprecision*23 < |x|. Attempt to // increase the working precision if needed as long as it isn't too large. If // it is too large, don't bump the precision, causing an early overflow return. if ncp := f / 23; ncp > float64(cp) && ncp < 1000 { cp = uint32(math.Ceil(ncp)) } } var tmp2 Decimal tmp2.SetInt64(int64(cp) * 23) // if abs(x) > 23*currentprecision; assert false if tmp1.Cmp(&tmp2) > 0 { res |= Overflow if x.Sign() < 0 { res = res.negateOverflowFlags() res |= Clamped d.SetFinite(0, c.etiny()) } else { d.Set(decimalInfinity) } return c.goError(res) } // if abs(x) <= setexp(.9, -currentprecision); then result 1 tmp2.SetFinite(9, int32(-cp)-1) if tmp1.Cmp(&tmp2) <= 0 { d.Set(decimalOne) return c.goError(res) } // Stage 2 // Add x.NumDigits because the paper assumes that x.Coeff [0.1, 1). t := x.Exponent + int32(x.NumDigits()) if t < 0 { t = 0 } var k, r Decimal k.SetFinite(1, t) nc := c.WithPrecision(cp) nc.Rounding = RoundHalfEven if _, err := nc.Quo(&r, x, &k); err != nil { return 0, fmt.Errorf("Quo: %w", err) } var ra Decimal ra.Abs(&r) p := int64(cp) + int64(t) + 2 // Stage 3 rf, err := ra.Float64() if err != nil { return 0, fmt.Errorf("r.Float64: %w", err) } pf := float64(p) nf := math.Ceil((1.435*pf - 1.182) / math.Log10(pf/rf)) if nf > 1000 || math.IsNaN(nf) { return 0, errors.New("too many iterations") } n := int64(nf) // Stage 4 nc.Precision = uint32(p) ed := MakeErrDecimal(nc) var sum Decimal sum.SetInt64(1) tmp2.Exponent = 0 for i := n - 1; i > 0; i-- { tmp2.setCoefficient(i) // tmp1 = r / i ed.Quo(&tmp1, &r, &tmp2) // sum = sum * r / i ed.Mul(&sum, &tmp1, &sum) // sum = sum + 1 ed.Add(&sum, &sum, decimalOne) } if err != ed.Err() { return 0, err } // sum ** k var tmpE BigInt ki, err := exp10(int64(t), &tmpE) if err != nil { return 0, fmt.Errorf("ki: %w", err) } ires, err := nc.integerPower(d, &sum, ki) if err != nil { return 0, fmt.Errorf("integer power: %w", err) } res |= ires nc.Precision = c.Precision res |= nc.round(d, d) return c.goError(res) } // integerPower sets d = x**y. d and x must not point to the same Decimal. func (c *Context) integerPower(d, x *Decimal, y *BigInt) (Condition, error) { // See: https://en.wikipedia.org/wiki/Exponentiation_by_squaring. var b BigInt b.Set(y) neg := b.Sign() < 0 if neg { b.Abs(&b) } var n Decimal n.Set(x) z := d z.Set(decimalOne) ed := MakeErrDecimal(c) for b.Sign() > 0 { if b.Bit(0) == 1 { ed.Mul(z, z, &n) } b.Rsh(&b, 1) // Only compute the next n if we are going to use it. Otherwise n can overflow // on the last iteration causing this to error. if b.Sign() > 0 { ed.Mul(&n, &n, &n) } if err := ed.Err(); err != nil { // In the negative case, convert overflow to underflow. if neg { ed.Flags = ed.Flags.negateOverflowFlags() } return ed.Flags, err } } if neg { ed.Quo(z, decimalOne, z) } return ed.Flags, ed.Err() } // Pow sets d = x**y. func (c *Context) Pow(d, x, y *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, y) { return c.setAsNaN(d, x, y) } var integ, frac Decimal y.Modf(&integ, &frac) yIsInt := frac.IsZero() neg := x.Negative && y.Form == Finite && yIsInt && integ.Coeff.Bit(0) == 1 && integ.Exponent == 0 if x.Form == Infinite { var res Condition if y.Sign() == 0 { d.Set(decimalOne) } else if x.Negative && (y.Form == Infinite || !yIsInt) { d.Set(decimalNaN) res = InvalidOperation } else if y.Negative { d.Set(decimalZero) } else { d.Set(decimalInfinity) } d.Negative = neg return c.goError(res) } // Check if y is of type int. var tmp Decimal tmp.Abs(y) xs := x.Sign() ys := y.Sign() if xs == 0 { var res Condition switch ys { case 0: d.Set(decimalNaN) res = InvalidOperation case 1: d.Set(decimalZero) default: // -1 d.Set(decimalInfinity) } d.Negative = neg return c.goError(res) } if ys == 0 { d.Set(decimalOne) return 0, nil } if xs < 0 && !yIsInt { d.Set(decimalNaN) return c.goError(InvalidOperation) } // decNumber sets the precision to be max(x digits, c.Precision) + // len(exponent) + 4. 6 is used as the exponent maximum length. p := c.Precision if nd := uint32(x.NumDigits()); p < nd { p = nd } p += 4 + 6 nc := BaseContext.WithPrecision(p) z := d if z == x { z = new(Decimal) } // If integ.Exponent > 0, we need to add trailing 0s to integ.Coeff. res := c.quantize(&integ, &integ, 0) nres, err := nc.integerPower(z, x, integ.setBig(&integ.Coeff)) res |= nres if err != nil { d.Set(decimalNaN) return res, err } if yIsInt { res |= c.round(d, z) return c.goError(res) } ed := MakeErrDecimal(nc) // Compute x**frac(y) ed.Abs(&tmp, x) ed.Ln(&tmp, &tmp) ed.Mul(&tmp, &tmp, &frac) ed.Exp(&tmp, &tmp) // Join integer and frac parts back. ed.Mul(&tmp, z, &tmp) if err := ed.Err(); err != nil { return ed.Flags, err } res |= c.round(d, &tmp) d.Negative = neg res |= Inexact return c.goError(res) } // Quantize adjusts and rounds x as necessary so it is represented with // exponent exp and stores the result in d. func (c *Context) Quantize(d, x *Decimal, exp int32) (Condition, error) { if c.shouldSetAsNaN(x, nil) { return c.setAsNaN(d, x, nil) } if x.Form == Infinite || exp < c.etiny() { d.Set(decimalNaN) return c.goError(InvalidOperation) } res := c.quantize(d, x, exp) if nd := d.NumDigits(); nd > int64(c.Precision) || exp > c.MaxExponent { res = InvalidOperation d.Set(decimalNaN) } else { res |= c.round(d, d) if res.Overflow() || res.Underflow() { res = InvalidOperation d.Set(decimalNaN) } } return c.goError(res) } func (c *Context) quantize(d, v *Decimal, exp int32) Condition { diff := exp - v.Exponent d.Set(v) var res Condition if diff < 0 { if diff < MinExponent { return SystemUnderflow | Underflow } var tmpE BigInt d.Coeff.Mul(&d.Coeff, tableExp10(-int64(diff), &tmpE)) } else if diff > 0 { p := int32(d.NumDigits()) - diff if p < 0 { if !d.IsZero() { d.Coeff.SetInt64(0) res = Inexact | Rounded } } else { nc := c.WithPrecision(uint32(p)) // The idea here is that the resulting d.Exponent after rounding will be 0. We // have a number of, say, 5 digits, but p (our precision) above is set at, say, // 3. So here d.Exponent is set to `-2`. We have a number like `NNN.xx`, where // the `.xx` part will be rounded away. However during rounding of 0.9 to 1.0, // d.Exponent could be set to 1 instead of 0, so we have to reduce it and // increase the coefficient below. // Another solution is to set d.Exponent = v.Exponent and adjust it to exp, // instead of setting d.Exponent = -diff and adjusting it to zero. Although // this computes the correct result, it fails the Max/MinExponent checks // during Round and raises underflow flags. Quantize (as per the spec) // is guaranteed to not raise underflow, and using 0 instead of exp as the // target eliminates this problem. d.Exponent = -diff // Round even if nc.Precision == 0. res = nc.Rounding.Round(nc, d, d, false /* disableIfPrecisionZero */) // Adjust for 0.9 -> 1.0 rollover. if d.Exponent > 0 { d.Coeff.Mul(&d.Coeff, bigTen) } } } d.Exponent = exp return res } func (c *Context) toIntegral(d, x *Decimal) Condition { res := c.quantize(d, x, 0) return res } func (c *Context) toIntegralSpecials(d, x *Decimal) (bool, Condition, error) { if c.shouldSetAsNaN(x, nil) { res, err := c.setAsNaN(d, x, nil) return true, res, err } if x.Form != Finite { d.Set(x) return true, 0, nil } return false, 0, nil } // RoundToIntegralValue sets d to integral value of x. Inexact and Rounded flags // are ignored and removed. func (c *Context) RoundToIntegralValue(d, x *Decimal) (Condition, error) { if set, res, err := c.toIntegralSpecials(d, x); set { return res, err } res := c.toIntegral(d, x) res &= ^(Inexact | Rounded) return c.goError(res) } // RoundToIntegralExact sets d to integral value of x. func (c *Context) RoundToIntegralExact(d, x *Decimal) (Condition, error) { if set, res, err := c.toIntegralSpecials(d, x); set { return res, err } res := c.toIntegral(d, x) return c.goError(res) } // Ceil sets d to the smallest integer >= x. func (c *Context) Ceil(d, x *Decimal) (Condition, error) { var frac Decimal x.Modf(d, &frac) if frac.Sign() > 0 { return c.Add(d, d, decimalOne) } return 0, nil } // Floor sets d to the largest integer <= x. func (c *Context) Floor(d, x *Decimal) (Condition, error) { var frac Decimal x.Modf(d, &frac) if frac.Sign() < 0 { return c.Sub(d, d, decimalOne) } return 0, nil } // Reduce sets d to x with all trailing zeros removed and returns the number // of zeros removed. func (c *Context) Reduce(d, x *Decimal) (int, Condition, error) { if c.shouldSetAsNaN(x, nil) { res, err := c.setAsNaN(d, x, nil) return 0, res, err } neg := x.Negative _, n := d.Reduce(x) d.Negative = neg res := c.round(d, d) res, err := c.goError(res) return n, res, err } // exp10 returns x, 10^x. An error is returned if x is too large. // The returned value must not be mutated. func exp10(x int64, tmp *BigInt) (exp *BigInt, err error) { if x > MaxExponent || x < MinExponent { return nil, errors.New(errExponentOutOfRangeStr) } return tableExp10(x, tmp), nil } apd-3.2.1/decimal.go000066400000000000000000000500771450022325000142100ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "errors" "fmt" "strconv" "strings" "unsafe" "database/sql/driver" ) // Decimal is an arbitrary-precision decimal. Its value is: // // Negative × Coeff × 10**Exponent // // Coeff must be positive. If it is negative results may be incorrect and // apd may panic. type Decimal struct { Form Form Negative bool Exponent int32 Coeff BigInt } // Form specifies the form of a Decimal. type Form int8 const ( // These constants must be in the following order. CmpTotal assumes that // the order of these constants reflects the total order on decimals. // Finite is the finite form. Finite Form = iota // Infinite is the infinite form. Infinite // NaNSignaling is the signaling NaN form. It will always raise the // InvalidOperation condition during an operation. NaNSignaling // NaN is the NaN form. NaN ) var ( decimalNaN = &Decimal{Form: NaN} decimalInfinity = &Decimal{Form: Infinite} ) //go:generate stringer -type=Form const ( // TODO(mjibson): MaxExponent is set because both upscale and Round // perform a calculation of 10^x, where x is an exponent. This is done by // big.Int.Exp. This restriction could be lifted if better algorithms were // determined during upscale and Round that don't need to perform Exp. // MaxExponent is the highest exponent supported. Exponents near this range will // perform very slowly (many seconds per operation). MaxExponent = 100000 // MinExponent is the lowest exponent supported with the same limitations as // MaxExponent. MinExponent = -MaxExponent ) // New creates a new decimal with the given coefficient and exponent. func New(coeff int64, exponent int32) *Decimal { d := new(Decimal) d.SetFinite(coeff, exponent) return d } // NewWithBigInt creates a new decimal with the given coefficient and exponent. func NewWithBigInt(coeff *BigInt, exponent int32) *Decimal { d := new(Decimal) d.Coeff.Set(coeff) if d.Coeff.Sign() < 0 { d.Negative = true d.Coeff.Abs(&d.Coeff) } d.Exponent = exponent return d } func consumePrefix(s, prefix string) (string, bool) { if strings.HasPrefix(s, prefix) { return s[len(prefix):], true } return s, false } func (d *Decimal) setString(c *Context, s string) (Condition, error) { orig := s s, d.Negative = consumePrefix(s, "-") if !d.Negative { s, _ = consumePrefix(s, "+") } s = strings.ToLower(s) d.Exponent = 0 d.Coeff.SetInt64(0) // Until there are no parse errors, leave as NaN. d.Form = NaN if strings.HasPrefix(s, "-") || strings.HasPrefix(s, "+") { return 0, fmt.Errorf("could not parse: %s", orig) } switch s { case "infinity", "inf": d.Form = Infinite return 0, nil } isNaN := false s, consumed := consumePrefix(s, "nan") if consumed { isNaN = true } s, consumed = consumePrefix(s, "snan") if consumed { isNaN = true d.Form = NaNSignaling } if isNaN { if s != "" { // We ignore these digits, but must verify them. _, err := strconv.ParseUint(s, 10, 64) if err != nil { return 0, fmt.Errorf("parse payload: %s: %w", s, err) } } return 0, nil } exps := make([]int64, 0, 2) if i := strings.IndexByte(s, 'e'); i >= 0 { exp, err := strconv.ParseInt(s[i+1:], 10, 32) if err != nil { return 0, fmt.Errorf("parse exponent: %s: %w", s[i+1:], err) } exps = append(exps, exp) s = s[:i] } if i := strings.IndexByte(s, '.'); i >= 0 { exp := int64(len(s) - i - 1) exps = append(exps, -exp) s = s[:i] + s[i+1:] } if _, ok := d.Coeff.SetString(s, 10); !ok { return 0, fmt.Errorf("parse mantissa: %s", s) } // No parse errors, can now flag as finite. d.Form = Finite return c.goError(d.setExponent(c, unknownNumDigits, 0, exps...)) } // NewFromString creates a new decimal from s. It has no restrictions on // exponents or precision. func NewFromString(s string) (*Decimal, Condition, error) { return BaseContext.NewFromString(s) } // SetString sets d to s and returns d. It has no restrictions on exponents // or precision. func (d *Decimal) SetString(s string) (*Decimal, Condition, error) { return BaseContext.SetString(d, s) } // NewFromString creates a new decimal from s. The returned Decimal has its // exponents restricted by the context and its value rounded if it contains more // digits than the context's precision. func (c *Context) NewFromString(s string) (*Decimal, Condition, error) { d := new(Decimal) return c.SetString(d, s) } // SetString sets d to s and returns d. The returned Decimal has its exponents // restricted by the context and its value rounded if it contains more digits // than the context's precision. func (c *Context) SetString(d *Decimal, s string) (*Decimal, Condition, error) { res, err := d.setString(c, s) if err != nil { return nil, 0, err } res |= c.round(d, d) _, err = c.goError(res) return d, res, err } // Set sets d's fields to the values of x and returns d. // //gcassert:inline func (d *Decimal) Set(x *Decimal) *Decimal { if d == x { return d } return d.setSlow(x) } // setSlow is split from Set to allow the aliasing fast-path to be // inlined in callers. func (d *Decimal) setSlow(x *Decimal) *Decimal { d.Form = x.Form d.Negative = x.Negative d.Exponent = x.Exponent d.Coeff.Set(&x.Coeff) return d } // SetInt64 sets d to x and returns d. func (d *Decimal) SetInt64(x int64) *Decimal { return d.SetFinite(x, 0) } // SetFinite sets d to x with exponent e and returns d. func (d *Decimal) SetFinite(x int64, e int32) *Decimal { d.setCoefficient(x) d.Exponent = e return d } // setCoefficient sets d's coefficient and negative value to x and its Form // to Finite The exponent is not changed. Since the exponent is not changed // (and this is thus easy to misuse), this is unexported for internal use only. func (d *Decimal) setCoefficient(x int64) { d.Negative = x < 0 d.Coeff.SetInt64(x) d.Coeff.Abs(&d.Coeff) d.Form = Finite } // SetFloat64 sets d's Coefficient and Exponent to x and returns d. d will // hold the exact value of f. func (d *Decimal) SetFloat64(f float64) (*Decimal, error) { var buf [32]byte // Avoid most of the allocations in strconv. _, _, err := d.SetString(string(strconv.AppendFloat(buf[:0], f, 'E', -1, 64))) return d, err } // Int64 returns the int64 representation of x. If x cannot be represented in an // int64, an error is returned. func (d *Decimal) Int64() (int64, error) { if d.Form != Finite { return 0, fmt.Errorf("%s is not finite", d.String()) } var integ, frac Decimal d.Modf(&integ, &frac) if !frac.IsZero() { return 0, fmt.Errorf("%s: has fractional part", d.String()) } var ed ErrDecimal if integ.Cmp(decimalMaxInt64) > 0 { return 0, fmt.Errorf("%s: greater than max int64", d.String()) } if integ.Cmp(decimalMinInt64) < 0 { return 0, fmt.Errorf("%s: less than min int64", d.String()) } if err := ed.Err(); err != nil { return 0, err } v := integ.Coeff.Int64() for i := int32(0); i < integ.Exponent; i++ { v *= 10 } if d.Negative { v = -v } return v, nil } // Float64 returns the float64 representation of x. This conversion may lose // data (see strconv.ParseFloat for caveats). func (d *Decimal) Float64() (float64, error) { return strconv.ParseFloat(d.String(), 64) } const ( errExponentOutOfRangeStr = "exponent out of range" unknownNumDigits = int64(-1) ) // setExponent sets d's Exponent to the sum of xs. Each value and the sum // of xs must fit within an int32. An error occurs if the sum is outside of // the MaxExponent or MinExponent range. nd is the number of digits in d, as // computed by NumDigits. Callers can pass unknownNumDigits to indicate that // they have not yet computed this digit count, in which case setExponent will // do so. res is any Condition previously set for this operation, which can // cause Underflow to be set if, for example, Inexact is already set. func (d *Decimal) setExponent(c *Context, nd int64, res Condition, xs ...int64) Condition { var sum int64 for _, x := range xs { if x > MaxExponent { return SystemOverflow | Overflow } if x < MinExponent { return SystemUnderflow | Underflow } sum += x } r := int32(sum) if nd == unknownNumDigits { nd = d.NumDigits() } // adj is the adjusted exponent: exponent + clength - 1 adj := sum + nd - 1 // Make sure it is less than the system limits. if adj > MaxExponent { return SystemOverflow | Overflow } if adj < MinExponent { return SystemUnderflow | Underflow } v := int32(adj) // d is subnormal. if v < c.MinExponent { if !d.IsZero() { res |= Subnormal } Etiny := c.MinExponent - (int32(c.Precision) - 1) // Only need to round if exponent < Etiny. if r < Etiny { // We need to take off (r - Etiny) digits. Split up d.Coeff into integer and // fractional parts and do operations similar Round. We avoid calling Round // directly because it calls setExponent and modifies the result's exponent // and coeff in ways that would be wrong here. var tmp Decimal tmp.Coeff.Set(&d.Coeff) tmp.Exponent = r - Etiny var integ, frac Decimal tmp.Modf(&integ, &frac) frac.Abs(&frac) if !frac.IsZero() { res |= Inexact if c.Rounding.ShouldAddOne(&integ.Coeff, integ.Negative, frac.Cmp(decimalHalf)) { integ.Coeff.Add(&integ.Coeff, bigOne) } } if integ.IsZero() { res |= Clamped } r = Etiny d.Coeff.Set(&integ.Coeff) res |= Rounded } } else if v > c.MaxExponent { if d.IsZero() { res |= Clamped r = c.MaxExponent } else { res |= Overflow | Inexact d.Form = Infinite } } if res.Inexact() && res.Subnormal() { res |= Underflow } d.Exponent = r return res } // upscale converts a and b to BigInts with the same scaling. It returns // them with this scaling, along with the scaling. An error can be produced // if the resulting scale factor is out of range. The tmp argument must be // provided and can be (but won't always be) one of the return values. func upscale(a, b *Decimal, tmp *BigInt) (*BigInt, *BigInt, int32, error) { if a.Exponent == b.Exponent { return &a.Coeff, &b.Coeff, a.Exponent, nil } swapped := false if a.Exponent < b.Exponent { swapped = true b, a = a, b } s := int64(a.Exponent) - int64(b.Exponent) // TODO(mjibson): figure out a better way to upscale numbers with highly // differing exponents. if s > MaxExponent { return nil, nil, 0, errors.New(errExponentOutOfRangeStr) } x := tmp e := tableExp10(s, x) x.Mul(&a.Coeff, e) y := &b.Coeff if swapped { x, y = y, x } return x, y, b.Exponent, nil } // setBig sets b to d's coefficient with negative. func (d *Decimal) setBig(b *BigInt) *BigInt { b.Set(&d.Coeff) if d.Negative { b.Neg(b) } return b } // CmpTotal compares d and x using their abstract representation rather // than their numerical value. A total ordering is defined for all possible // abstract representations, as described below. If the first operand is // lower in the total order than the second operand then the result is -1, // if the operands have the same abstract representation then the result is // 0, and if the first operand is higher in the total order than the second // operand then the result is 1. // // Numbers (representations which are not NaNs) are ordered such that a // larger numerical value is higher in the ordering. If two representations // have the same numerical value then the exponent is taken into account; // larger (more positive) exponents are higher in the ordering. // // For example, the following values are ordered from lowest to highest. Note // the difference in ordering between 1.2300 and 1.23. // // -NaN // -NaNSignaling // -Infinity // -127 // -1.00 // -1 // -0.000 // -0 // 0 // 1.2300 // 1.23 // 1E+9 // Infinity // NaNSignaling // NaN func (d *Decimal) CmpTotal(x *Decimal) int { do := d.cmpOrder() xo := x.cmpOrder() if do < xo { return -1 } if do > xo { return 1 } switch d.Form { case Finite: // d and x have the same sign and form, compare their value. if c := d.Cmp(x); c != 0 { return c } lt := -1 gt := 1 if d.Negative { lt = 1 gt = -1 } // Values are equal, compare exponents. if d.Exponent < x.Exponent { return lt } if d.Exponent > x.Exponent { return gt } return 0 case Infinite: return 0 default: return d.Coeff.Cmp(&x.Coeff) } } func (d *Decimal) cmpOrder() int { v := int(d.Form) + 1 if d.Negative { v = -v } return v } // Cmp compares x and y and sets d to: // // -1 if x < y // 0 if x == y // +1 if x > y // // This comparison respects the normal rules of special values (like NaN), // and does not compare them. func (c *Context) Cmp(d, x, y *Decimal) (Condition, error) { if c.shouldSetAsNaN(x, y) { return c.setAsNaN(d, x, y) } v := x.Cmp(y) d.SetInt64(int64(v)) return 0, nil } // Cmp compares d and x and returns: // // -1 if d < x // 0 if d == x // +1 if d > x // undefined if d or x are NaN func (d *Decimal) Cmp(x *Decimal) int { ds := d.Sign() xs := x.Sign() // First compare signs. if ds < xs { return -1 } else if ds > xs { return 1 } else if ds == 0 && xs == 0 { return 0 } // Use gt and lt here with flipped signs if d is negative. gt and lt then // allow for simpler comparisons since we can ignore the sign of the decimals // and only worry about the form and value. gt := 1 lt := -1 if ds == -1 { gt = -1 lt = 1 } if d.Form == Infinite { if x.Form == Infinite { return 0 } return gt } else if x.Form == Infinite { return lt } if d.Exponent == x.Exponent { cmp := d.Coeff.Cmp(&x.Coeff) if ds < 0 { cmp = -cmp } return cmp } // Next compare adjusted exponents. dn := d.NumDigits() + int64(d.Exponent) xn := x.NumDigits() + int64(x.Exponent) if dn < xn { return lt } else if dn > xn { return gt } // Now have to use aligned BigInts. This function previously used upscale to // align in all cases, but that requires an error in the return value. upscale // does that so that it can fail if it needs to take the Exp of too-large a // number, which is very slow. The only way for that to happen here is for d // and x's coefficients to be of hugely differing values. That is practically // more difficult, so we are assuming the user is already comfortable with // slowness in those operations. var cmp int if d.Exponent < x.Exponent { var xScaled, tmpE BigInt xScaled.Set(&x.Coeff) xScaled.Mul(&xScaled, tableExp10(int64(x.Exponent)-int64(d.Exponent), &tmpE)) cmp = d.Coeff.Cmp(&xScaled) } else { var dScaled, tmpE BigInt dScaled.Set(&d.Coeff) dScaled.Mul(&dScaled, tableExp10(int64(d.Exponent)-int64(x.Exponent), &tmpE)) cmp = dScaled.Cmp(&x.Coeff) } if ds < 0 { cmp = -cmp } return cmp } // Sign returns, if d is Finite: // // -1 if d < 0 // 0 if d == 0 or -0 // +1 if d > 0 // // Otherwise (if d is Infinite or NaN): // // -1 if d.Negative == true // +1 if d.Negative == false func (d *Decimal) Sign() int { if d.Form == Finite && d.Coeff.Sign() == 0 { return 0 } if d.Negative { return -1 } return 1 } // IsZero returns true if d == 0 or -0. func (d *Decimal) IsZero() bool { return d.Sign() == 0 } // Modf sets integ to the integral part of d and frac to the fractional part // such that d = integ+frac. If d is negative, both integ or frac will be either // 0 or negative. integ.Exponent will be >= 0; frac.Exponent will be <= 0. // Either argument can be nil, preventing it from being set. func (d *Decimal) Modf(integ, frac *Decimal) { if integ == nil && frac == nil { return } neg := d.Negative // No fractional part. if d.Exponent > 0 { if frac != nil { frac.Negative = neg frac.Exponent = 0 frac.Coeff.SetInt64(0) } if integ != nil { integ.Set(d) } return } nd := d.NumDigits() exp := -int64(d.Exponent) // d < 0 because exponent is larger than number of digits. if exp > nd { if integ != nil { integ.Negative = neg integ.Exponent = 0 integ.Coeff.SetInt64(0) } if frac != nil { frac.Set(d) } return } var tmpE BigInt e := tableExp10(exp, &tmpE) var icoeff *BigInt if integ != nil { icoeff = &integ.Coeff integ.Exponent = 0 integ.Negative = neg } else { // This is the integ == nil branch, and we already checked if both integ and // frac were nil above, so frac can never be nil in this branch. icoeff = new(BigInt) } if frac != nil { icoeff.QuoRem(&d.Coeff, e, &frac.Coeff) frac.Exponent = d.Exponent frac.Negative = neg } else { // This is the frac == nil, which means integ must not be nil since they both // can't be due to the check above. icoeff.Quo(&d.Coeff, e) } } // Neg sets d to -x and returns d. func (d *Decimal) Neg(x *Decimal) *Decimal { d.Set(x) if d.IsZero() { d.Negative = false } else { d.Negative = !d.Negative } return d } // Abs sets d to |x| and returns d. func (d *Decimal) Abs(x *Decimal) *Decimal { d.Set(x) d.Negative = false return d } // Reduce sets d to x with all trailing zeros removed and returns d and the // number of zeros removed. func (d *Decimal) Reduce(x *Decimal) (*Decimal, int) { if x.Form != Finite { d.Set(x) return d, 0 } var nd int neg := false switch x.Sign() { case 0: nd = int(d.NumDigits()) d.SetInt64(0) return d, nd - 1 case -1: neg = true } d.Set(x) // Use a uint64 for the division if possible. if d.Coeff.IsUint64() { i := d.Coeff.Uint64() for i >= 10000 && i%10000 == 0 { i /= 10000 nd += 4 } for i%10 == 0 { i /= 10 nd++ } if nd != 0 { d.Exponent += int32(nd) d.Coeff.SetUint64(i) d.Negative = neg } return d, nd } // Divide by 10 in a loop. In benchmarks of reduce0.decTest, this is 20% // faster than converting to a string and trimming the 0s from the end. var z, r BigInt d.setBig(&z) for { z.QuoRem(&d.Coeff, bigTen, &r) if r.Sign() == 0 { d.Coeff.Set(&z) nd++ } else { break } } d.Exponent += int32(nd) return d, nd } const decimalSize = unsafe.Sizeof(Decimal{}) // Size returns the total memory footprint of d in bytes. func (d *Decimal) Size() uintptr { return decimalSize - bigIntSize + d.Coeff.Size() } // Value implements the database/sql/driver.Valuer interface. It converts d to a // string. func (d Decimal) Value() (driver.Value, error) { return d.String(), nil } // Scan implements the database/sql.Scanner interface. It supports string, // []byte, int64, float64. func (d *Decimal) Scan(src interface{}) error { switch src := src.(type) { case []byte: _, _, err := d.SetString(string(src)) return err case string: _, _, err := d.SetString(src) return err case int64: d.SetInt64(src) return nil case float64: _, err := d.SetFloat64(src) return err default: return fmt.Errorf("could not convert %T to Decimal", src) } } // UnmarshalText implements the encoding.TextUnmarshaler interface. func (d *Decimal) UnmarshalText(b []byte) error { _, _, err := d.SetString(string(b)) return err } // MarshalText implements the encoding.TextMarshaler interface. func (d *Decimal) MarshalText() ([]byte, error) { if d == nil { return []byte(""), nil } return []byte(d.String()), nil } // NullDecimal represents a string that may be null. NullDecimal implements // the database/sql.Scanner interface so it can be used as a scan destination: // // var d NullDecimal // err := db.QueryRow("SELECT num FROM foo WHERE id=?", id).Scan(&d) // ... // if d.Valid { // // use d.Decimal // } else { // // NULL value // } type NullDecimal struct { Decimal Decimal Valid bool // Valid is true if Decimal is not NULL } // Scan implements the database/sql.Scanner interface. func (nd *NullDecimal) Scan(value interface{}) error { if value == nil { nd.Valid = false return nil } nd.Valid = true return nd.Decimal.Scan(value) } // Value implements the database/sql/driver.Valuer interface. func (nd NullDecimal) Value() (driver.Value, error) { if !nd.Valid { return nil, nil } return nd.Decimal.Value() } apd-3.2.1/decimal_test.go000066400000000000000000000457171450022325000152540ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "encoding/json" "fmt" "math" "math/bits" "strings" "testing" "unsafe" ) var ( testCtx = &BaseContext ) func (d *Decimal) GoString() string { return fmt.Sprintf(`{Coeff: %s, Exponent: %d, Negative: %v, Form: %s}`, d.Coeff.String(), d.Exponent, d.Negative, d.Form) } // testExponentError skips t if err was caused by an exponent being outside // of the package's supported exponent range. Since the exponent is so large, // we don't support those tests yet (i.e., it's an expected failure, so we // skip it). func testExponentError(t *testing.T, err error) { if err == nil { return } if err.Error() == errExponentOutOfRangeStr { t.Skip(err) } } func newDecimal(t *testing.T, c *Context, s string) *Decimal { d, _, err := c.NewFromString(s) testExponentError(t, err) if err != nil { t.Fatalf("%s: %+v", s, err) } return d } func TestNewWithBigInt(t *testing.T) { tests := []string{ "0", "1", "-1", } for _, tc := range tests { t.Run(tc, func(t *testing.T) { expect, _, err := new(Decimal).SetString(tc) if err != nil { t.Fatal(err) } b, ok := new(BigInt).SetString(tc, 10) if !ok { t.Fatal("bad bigint") } d := NewWithBigInt(b, 0) if d.Coeff.Sign() < 0 { t.Fatal("unexpected negative coeff") } // Verify that changing b doesn't change d. b.Set(NewBigInt(1234)) if d.CmpTotal(expect) != 0 { t.Fatalf("expected %s, got %s", expect, d) } }) } } func TestUpscale(t *testing.T) { tests := []struct { x, y *Decimal a, b *BigInt s int32 }{ {x: New(1, 0), y: New(100, -1), a: NewBigInt(10), b: NewBigInt(100), s: -1}, {x: New(1, 0), y: New(10, -1), a: NewBigInt(10), b: NewBigInt(10), s: -1}, {x: New(1, 0), y: New(10, 0), a: NewBigInt(1), b: NewBigInt(10), s: 0}, {x: New(1, 1), y: New(1, 0), a: NewBigInt(10), b: NewBigInt(1), s: 0}, {x: New(10, -2), y: New(1, -1), a: NewBigInt(10), b: NewBigInt(10), s: -2}, {x: New(1, -2), y: New(100, 1), a: NewBigInt(1), b: NewBigInt(100000), s: -2}, } for _, tc := range tests { t.Run(fmt.Sprintf("%s, %s", tc.x, tc.y), func(t *testing.T) { a, b, s, err := upscale(tc.x, tc.y, new(BigInt)) if err != nil { t.Fatal(err) } if a.Cmp(tc.a) != 0 { t.Errorf("a: expected %s, got %s", tc.a, a) } if b.Cmp(tc.b) != 0 { t.Errorf("b: expected %s, got %s", tc.b, b) } if s != tc.s { t.Errorf("s: expected %d, got %d", tc.s, s) } }) } } func TestAdd(t *testing.T) { tests := []struct { x, y string r string }{ {x: "1", y: "10", r: "11"}, {x: "1", y: "1e1", r: "11"}, {x: "1e1", y: "1", r: "11"}, {x: ".1e1", y: "100e-1", r: "11.0"}, } for _, tc := range tests { t.Run(fmt.Sprintf("%s, %s", tc.x, tc.y), func(t *testing.T) { x := newDecimal(t, testCtx, tc.x) y := newDecimal(t, testCtx, tc.y) d := new(Decimal) _, err := testCtx.Add(d, x, y) if err != nil { t.Fatal(err) } s := d.String() if s != tc.r { t.Fatalf("expected: %s, got: %s", tc.r, s) } }) } } func TestCmp(t *testing.T) { tests := []struct { x, y string c int }{ {x: "1", y: "10", c: -1}, {x: "1", y: "1e1", c: -1}, {x: "1e1", y: "1", c: 1}, {x: ".1e1", y: "100e-1", c: -1}, {x: ".1e1", y: "100e-2", c: 0}, {x: "1", y: ".1e1", c: 0}, {x: "1", y: "1", c: 0}, } for _, tc := range tests { t.Run(fmt.Sprintf("%s, %s", tc.x, tc.y), func(t *testing.T) { x := newDecimal(t, testCtx, tc.x) y := newDecimal(t, testCtx, tc.y) c := x.Cmp(y) if c != tc.c { t.Fatalf("expected: %d, got: %d", tc.c, c) } }) } } func TestModf(t *testing.T) { tests := []struct { x string i string f string }{ {x: "1", i: "1", f: "0"}, {x: "1.0", i: "1", f: "0.0"}, {x: "1.0e1", i: "10", f: "0"}, {x: "1.0e2", i: "1.0E+2", f: "0"}, {x: "1.0e-1", i: "0", f: "0.10"}, {x: "1.0e-2", i: "0", f: "0.010"}, {x: "1.1", i: "1", f: "0.1"}, {x: "1234.56", i: "1234", f: "0.56"}, {x: "1234.56e2", i: "123456", f: "0"}, {x: "1234.56e4", i: "1.23456E+7", f: "0"}, {x: "1234.56e-2", i: "12", f: "0.3456"}, {x: "1234.56e-4", i: "0", f: "0.123456"}, {x: "1234.56e-6", i: "0", f: "0.00123456"}, {x: "123456e-8", i: "0", f: "0.00123456"}, {x: ".123456e8", i: "1.23456E+7", f: "0"}, {x: "-1", i: "-1", f: "-0"}, {x: "-1.0", i: "-1", f: "-0.0"}, {x: "-1.0e1", i: "-10", f: "-0"}, {x: "-1.0e2", i: "-1.0E+2", f: "-0"}, {x: "-1.0e-1", i: "-0", f: "-0.10"}, {x: "-1.0e-2", i: "-0", f: "-0.010"}, {x: "-1.1", i: "-1", f: "-0.1"}, {x: "-1234.56", i: "-1234", f: "-0.56"}, {x: "-1234.56e2", i: "-123456", f: "-0"}, {x: "-1234.56e4", i: "-1.23456E+7", f: "-0"}, {x: "-1234.56e-2", i: "-12", f: "-0.3456"}, {x: "-1234.56e-4", i: "-0", f: "-0.123456"}, {x: "-1234.56e-6", i: "-0", f: "-0.00123456"}, {x: "-123456e-8", i: "-0", f: "-0.00123456"}, {x: "-.123456e8", i: "-1.23456E+7", f: "-0"}, } for _, tc := range tests { t.Run(tc.x, func(t *testing.T) { x := newDecimal(t, testCtx, tc.x) integ, frac := new(Decimal), new(Decimal) x.Modf(integ, frac) if tc.i != integ.String() { t.Fatalf("integ: expected: %s, got: %s", tc.i, integ) } if tc.f != frac.String() { t.Fatalf("frac: expected: %s, got: %s", tc.f, frac) } a := new(Decimal) if _, err := testCtx.Add(a, integ, frac); err != nil { t.Fatal(err) } if a.Cmp(x) != 0 { t.Fatalf("%s != %s", a, x) } if integ.Exponent < 0 { t.Fatal(integ.Exponent) } if frac.Exponent > 0 { t.Fatal(frac.Exponent) } integ2, frac2 := new(Decimal), new(Decimal) x.Modf(integ2, nil) x.Modf(nil, frac2) if integ.CmpTotal(integ2) != 0 { t.Fatalf("got %s, expected %s", integ2, integ) } if frac.CmpTotal(frac2) != 0 { t.Fatalf("got %s, expected %s", frac2, frac) } }) } // Ensure we don't panic on both nil. a := new(Decimal) a.Modf(nil, nil) } func TestInt64(t *testing.T) { tests := []struct { x string i int64 err bool }{ {x: "0.12e1", err: true}, {x: "0.1e1", i: 1}, {x: "10", i: 10}, {x: "12.3e3", i: 12300}, {x: "1e-1", err: true}, {x: "1e2", i: 100}, {x: "1", i: 1}, {x: "NaN", err: true}, {x: "Inf", err: true}, {x: "9223372036854775807", i: 9223372036854775807}, {x: "-9223372036854775808", i: -9223372036854775808}, {x: "9223372036854775808", err: true}, } for _, tc := range tests { t.Run(tc.x, func(t *testing.T) { x := newDecimal(t, testCtx, tc.x) i, err := x.Int64() hasErr := err != nil if tc.err != hasErr { t.Fatalf("expected error: %v, got error: %v", tc.err, err) } if hasErr { return } if i != tc.i { t.Fatalf("expected: %v, got %v", tc.i, i) } }) } } func TestQuoErr(t *testing.T) { tests := []struct { x, y string p uint32 err string }{ {x: "1", y: "1", p: 0, err: errZeroPrecisionStr}, {x: "1", y: "0", p: 1, err: "division by zero"}, } for _, tc := range tests { c := testCtx.WithPrecision(tc.p) x := newDecimal(t, testCtx, tc.x) y := newDecimal(t, testCtx, tc.y) d := new(Decimal) _, err := c.Quo(d, x, y) if err == nil { t.Fatal("expected error") } if err.Error() != tc.err { t.Fatalf("expected %s, got %s", tc.err, err) } } } func TestConditionString(t *testing.T) { tests := map[Condition]string{ Overflow: "overflow", Overflow | Underflow: "overflow, underflow", Subnormal | Inexact: "inexact, subnormal", } for c, s := range tests { t.Run(s, func(t *testing.T) { cs := c.String() if cs != s { t.Errorf("expected %s; got %s", s, cs) } }) } } func TestFloat64(t *testing.T) { tests := []float64{ 0, 1, -1, math.MaxFloat32, math.SmallestNonzeroFloat32, math.MaxFloat64, math.SmallestNonzeroFloat64, } for _, tc := range tests { t.Run(fmt.Sprint(tc), func(t *testing.T) { d := new(Decimal) d.SetFloat64(tc) f, err := d.Float64() if err != nil { t.Fatal(err) } if tc != f { t.Fatalf("expected %v, got %v", tc, f) } }) } } func TestCeil(t *testing.T) { tests := map[float64]int64{ 0: 0, -0.1: 0, 0.1: 1, -0.9: 0, 0.9: 1, -1: -1, 1: 1, -1.1: -1, 1.1: 2, } for f, r := range tests { t.Run(fmt.Sprint(f), func(t *testing.T) { d, err := new(Decimal).SetFloat64(f) if err != nil { t.Fatal(err) } _, err = testCtx.Ceil(d, d) if err != nil { t.Fatal(err) } i, err := d.Int64() if err != nil { t.Fatal(err) } if i != r { t.Fatalf("got %v, expected %v", i, r) } }) } } func TestFloor(t *testing.T) { tests := map[float64]int64{ 0: 0, -0.1: -1, 0.1: 0, -0.9: -1, 0.9: 0, -1: -1, 1: 1, -1.1: -2, 1.1: 1, } for f, r := range tests { t.Run(fmt.Sprint(f), func(t *testing.T) { d, err := new(Decimal).SetFloat64(f) if err != nil { t.Fatal(err) } _, err = testCtx.Floor(d, d) if err != nil { t.Fatal(err) } i, err := d.Int64() if err != nil { t.Fatal(err) } if i != r { t.Fatalf("got %v, expected %v", i, r) } }) } } func TestFormat(t *testing.T) { tests := map[string]struct { e, E, f, g, G string }{ "NaN": {}, "Infinity": {}, "-Infinity": {}, "sNaN": {}, "0": { e: "0e+0", E: "0E+0", }, "-0": { e: "-0e+0", E: "-0E+0", }, "0.0": { e: "0e-1", E: "0E-1", }, "-0.0": { e: "-0e-1", E: "-0E-1", }, "0E+2": { e: "0e+2", f: "000", g: "0e+2", }, "0E-9": { e: "0e-9", f: "0.000000000", g: "0.000000000", G: "0.000000000", }, "0E-2000": { e: "0e-2000", f: "0." + strings.Repeat("0", 2000), g: "0." + strings.Repeat("0", 2000), G: "0." + strings.Repeat("0", 2000), }, "0E-2001": { e: "0e-2001", f: "0." + strings.Repeat("0", 2001), g: "0e-2001", G: "0E-2001", }, } verbs := []string{"%e", "%E", "%f", "%g", "%G"} for input, tc := range tests { t.Run(input, func(t *testing.T) { d, _, err := NewFromString(input) if err != nil { t.Fatal(err) } for i, s := range []string{tc.e, tc.E, tc.f, tc.g, tc.G} { if s == "" { s = input } v := verbs[i] t.Run(v, func(t *testing.T) { out := fmt.Sprintf(v, d) if out != s { t.Fatalf("expected %s, got %s", s, out) } }) } }) } } func TestFormatFlags(t *testing.T) { const stdD = "1.23E+56" tests := []struct { d string fmt string out string }{ { d: stdD, fmt: "%3G", out: "1.23E+56", }, { d: stdD, fmt: "%010G", out: "001.23E+56", }, { d: stdD, fmt: "%10G", out: " 1.23E+56", }, { d: stdD, fmt: "%+G", out: "+1.23E+56", }, { d: stdD, fmt: "% G", out: " 1.23E+56", }, { d: stdD, fmt: "%-10G", out: "1.23E+56 ", }, { d: stdD, fmt: "%-010G", out: "1.23E+56 ", }, { d: "nan", fmt: "%-10G", out: "NaN ", }, { d: "nan", fmt: "%10G", out: " NaN", }, { d: "nan", fmt: "%010G", out: " NaN", }, { d: "inf", fmt: "%-10G", out: "Infinity ", }, { d: "inf", fmt: "%10G", out: " Infinity", }, { d: "inf", fmt: "%010G", out: " Infinity", }, { d: "-inf", fmt: "%-10G", out: "-Infinity ", }, { d: "-inf", fmt: "%10G", out: " -Infinity", }, { d: "-inf", fmt: "%010G", out: " -Infinity", }, { d: "0", fmt: "%d", out: "%!d(*apd.Decimal=0)", }, } for _, tc := range tests { t.Run(fmt.Sprintf("%s: %s", tc.d, tc.fmt), func(t *testing.T) { d := newDecimal(t, &BaseContext, tc.d) s := fmt.Sprintf(tc.fmt, d) if s != tc.out { t.Fatalf("expected %q, got %q", tc.out, s) } }) } } func TestContextSetStringt(t *testing.T) { tests := []struct { s string c *Context expect string }{ { s: "1.234", c: &BaseContext, expect: "1.234", }, { s: "1.234", c: BaseContext.WithPrecision(2), expect: "1.2", }, } for i, tc := range tests { t.Run(fmt.Sprintf("%d: %s", i, tc.s), func(t *testing.T) { d := new(Decimal) if _, _, err := tc.c.SetString(d, tc.s); err != nil { t.Fatal(err) } got := d.String() if got != tc.expect { t.Fatalf("expected: %s, got: %s", tc.expect, got) } }) } } func TestQuantize(t *testing.T) { tests := []struct { s string e int32 expect string }{ { s: "1.00", e: -1, expect: "1.0", }, { s: "2.0", e: -1, expect: "2.0", }, { s: "3", e: -1, expect: "3.0", }, { s: "9.9999", e: -2, expect: "10.00", }, } c := BaseContext.WithPrecision(10) for _, tc := range tests { t.Run(fmt.Sprintf("%s: %d", tc.s, tc.e), func(t *testing.T) { d, _, err := NewFromString(tc.s) if err != nil { t.Fatal(err) } if _, err := c.Quantize(d, d, tc.e); err != nil { t.Fatal(err) } s := d.String() if s != tc.expect { t.Fatalf("expected: %s, got: %s", tc.expect, s) } }) } } func TestCmpOrder(t *testing.T) { tests := []struct { s string order int }{ {s: "-NaN", order: -4}, {s: "-sNaN", order: -3}, {s: "-Infinity", order: -2}, {s: "-127", order: -1}, {s: "-1.00", order: -1}, {s: "-1", order: -1}, {s: "-0.000", order: -1}, {s: "-0", order: -1}, {s: "0", order: 1}, {s: "1.2300", order: 1}, {s: "1.23", order: 1}, {s: "1E+9", order: 1}, {s: "Infinity", order: 2}, {s: "sNaN", order: 3}, {s: "NaN", order: 4}, } for _, tc := range tests { t.Run(tc.s, func(t *testing.T) { d, _, err := NewFromString(tc.s) if err != nil { t.Fatal(err) } o := d.cmpOrder() if o != tc.order { t.Fatalf("got %d, expected %d", o, tc.order) } }) } } func TestIsZero(t *testing.T) { tests := []struct { s string zero bool }{ {s: "-NaN", zero: false}, {s: "-sNaN", zero: false}, {s: "-Infinity", zero: false}, {s: "-127", zero: false}, {s: "-1.00", zero: false}, {s: "-1", zero: false}, {s: "-0.000", zero: true}, {s: "-0", zero: true}, {s: "0", zero: true}, {s: "1.2300", zero: false}, {s: "1.23", zero: false}, {s: "1E+9", zero: false}, {s: "Infinity", zero: false}, {s: "sNaN", zero: false}, {s: "NaN", zero: false}, } for _, tc := range tests { t.Run(tc.s, func(t *testing.T) { d, _, err := NewFromString(tc.s) if err != nil { t.Fatal(err) } z := d.IsZero() if z != tc.zero { t.Fatalf("got %v, expected %v", z, tc.zero) } }) } } func TestNeg(t *testing.T) { tests := map[string]string{ "0": "0", "-0": "0", "-0.000": "0.000", "-00.000100": "0.000100", } for tc, expect := range tests { t.Run(tc, func(t *testing.T) { d, _, err := NewFromString(tc) if err != nil { t.Fatal(err) } var z Decimal z.Neg(d) s := z.String() if s != expect { t.Fatalf("expected %s, got %s", expect, s) } }) } } func TestReduce(t *testing.T) { tests := map[string]int{ "-0": 0, "0": 0, "0.0": 0, "00": 0, "0.00": 0, "-01000": 3, "01000": 3, "-1": 0, "1": 0, "-10.000E4": 4, "10.000E4": 4, "-10.00": 3, "10.00": 3, "-10": 1, "10": 1, "-143200000000000000000000000000000000000000000000000000000000": 56, "143200000000000000000000000000000000000000000000000000000000": 56, "Inf": 0, "NaN": 0, } for s, n := range tests { t.Run(s, func(t *testing.T) { d, _, err := NewFromString(s) if err != nil { t.Fatal(err) } _, got := d.Reduce(d) if n != got { t.Fatalf("got %v, expected %v", got, n) } }) } } // TestSizeof is meant to catch changes that unexpectedly increase // the size of the BigInt, Decimal, and Context structs. func TestSizeof(t *testing.T) { // map[uint_size][type]sizeof exp := map[int]map[string]uintptr{ 32: { "BigInt": 20, "Decimal": 28, "Context": 24, }, 64: { "BigInt": 24, "Decimal": 32, "Context": 32, }, }[bits.UintSize] var b BigInt if s := unsafe.Sizeof(b); s != exp["BigInt"] { t.Errorf("sizeof(BigInt) changed: %d", s) } var d Decimal if s := unsafe.Sizeof(d); s != exp["Decimal"] { t.Errorf("sizeof(Decimal) changed: %d", s) } var c Context if s := unsafe.Sizeof(c); s != exp["Context"] { t.Errorf("sizeof(Context) changed: %d", s) } } // TestSize tests the Size method on BigInt and Decimal. Unlike Sizeof, which // returns the shallow size of the structs, the Size method reports the total // memory footprint of each struct and all referenced objects. func TestSize(t *testing.T) { // map[uint_size][is_inline][type]size exp := map[int]map[bool]map[string]uintptr{ 32: { true: { "BigInt": 20, "Decimal": 28, }, false: { "BigInt": 72, "Decimal": 80, }, }, 64: { true: { "BigInt": 24, "Decimal": 32, }, false: { "BigInt": 112, "Decimal": 120, }, }, }[bits.UintSize] var d Decimal if e, s := exp[true]["Decimal"], d.Size(); e != s { t.Errorf("(*Decimal).Size() != %d: %d", e, s) } if e, s := exp[true]["BigInt"], d.Coeff.Size(); e != s { t.Errorf("(*BigInt).Size() != %d: %d", e, s) } // Set to an inlinable value. d.SetInt64(1234) if e, s := exp[true]["Decimal"], d.Size(); e != s { t.Errorf("(*Decimal).Size() != %d: %d", e, s) } if e, s := exp[true]["BigInt"], d.Coeff.Size(); e != s { t.Errorf("(*BigInt).Size() != %d: %d", e, s) } // Set to a non-inlinable value. if _, _, err := d.SetString("123456789123456789123456789.123456789123456789"); err != nil { t.Fatal(err) } if d.Coeff.isInline() { // Sanity-check, in case inlineWords changes. t.Fatal("BigInt inlined large value. Did inlineWords change?") } if e, s := exp[false]["Decimal"], d.Size(); e != s { t.Errorf("(*Decimal).Size() != %d: %d", e, s) } if e, s := exp[false]["BigInt"], d.Coeff.Size(); e != s { t.Errorf("(*BigInt).Size() != %d: %d", e, s) } } func TestJSONEncoding(t *testing.T) { var encodingTests = []string{ "0", "1", "2", "10", "1000", "1234567890", "298472983472983471903246121093472394872319615612417471234712061", "0.0", "NaN", "Inf", "123.456", "1E1", "1E-1", "1.2E3", } for _, test := range encodingTests { for _, sign := range []string{"", "+", "-"} { x := sign + test var tx Decimal tx.SetString(x) b, err := json.Marshal(&tx) if err != nil { t.Errorf("marshaling of %s failed: %s", &tx, err) continue } var rx Decimal if err := json.Unmarshal(b, &rx); err != nil { t.Errorf("unmarshaling of %s failed: %s", &tx, err) continue } if rx.CmpTotal(&tx) != 0 { t.Errorf("JSON encoding of %s failed: got %s want %s", &tx, &rx, &tx) } } } } apd-3.2.1/decomposer.go000066400000000000000000000073621450022325000147510ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import "fmt" // decomposer composes or decomposes a decimal value to and from individual parts. // There are four separate parts: a boolean negative flag, a form byte with three possible states // (finite=0, infinite=1, NaN=2), a base-2 big-endian integer // coefficient (also known as a significand) as a []byte, and an int32 exponent. // These are composed into a final value as "decimal = (neg) (form=finite) coefficient * 10 ^ exponent". // A zero length coefficient is a zero value. // If the form is not finite the coefficient and scale should be ignored. // The negative parameter may be set to true for any form, although implementations are not required // to respect the negative parameter in the non-finite form. // // Implementations may choose to signal a negative zero or negative NaN, but implementations // that do not support these may also ignore the negative zero or negative NaN without error. // If an implementation does not support Infinity it may be converted into a NaN without error. // If a value is set that is larger then what is supported by an implementation is attempted to // be set, an error must be returned. // Implementations must return an error if a NaN or Infinity is attempted to be set while neither // are supported. type decomposer interface { // Decompose returns the internal decimal state into parts. // If the provided buf has sufficient capacity, buf may be returned as the coefficient with // the value set and length set as appropriate. Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32) // Compose sets the internal decimal value from parts. If the value cannot be // represented then an error should be returned. // The coefficent should not be modified. Successive calls to compose with // the same arguments should result in the same decimal value. Compose(form byte, negative bool, coefficient []byte, exponent int32) error } var _ decomposer = &Decimal{} // Decompose returns the internal decimal state into parts. // If the provided buf has sufficient capacity, buf may be returned as the coefficient with // the value set and length set as appropriate. func (d *Decimal) Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32) { switch d.Form { default: panic(fmt.Errorf("unknown Form: %v", d.Form)) case Finite: // Nothing, continue on. case Infinite: negative = d.Negative form = 1 return case NaNSignaling, NaN: negative = d.Negative form = 2 return } // Finite form. negative = d.Negative exponent = d.Exponent coefficient = d.Coeff.Bytes() return } // Compose sets the internal decimal value from parts. If the value cannot be // represented then an error should be returned. func (d *Decimal) Compose(form byte, negative bool, coefficient []byte, exponent int32) error { switch form { default: return fmt.Errorf("unknown form: %v", form) case 0: d.Form = Finite // Set rest of finite form below. case 1: d.Form = Infinite d.Negative = negative return nil case 2: d.Form = NaN d.Negative = negative return nil } // Finite form. d.Negative = negative d.Coeff.SetBytes(coefficient) d.Exponent = exponent return nil } apd-3.2.1/decomposer_test.go000066400000000000000000000062131450022325000160020ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "fmt" "testing" ) func TestDecomposerRoundTrip(t *testing.T) { list := []struct { N string // Name. S string // String value. E bool // Expect an error. }{ {N: "Zero", S: "0"}, {N: "Normal-1", S: "123.456"}, {N: "Normal-2", S: "-123.456"}, {N: "NaN-1", S: "NaN"}, {N: "NaN-2", S: "-NaN"}, {N: "Infinity-1", S: "Infinity"}, {N: "Infinity-2", S: "-Infinity"}, } for _, item := range list { t.Run(item.N, func(t *testing.T) { d, _, err := NewFromString(item.S) if err != nil { t.Fatal(err) } set, set2 := &Decimal{}, &Decimal{} f, n, c, e := d.Decompose(nil) err = set.Compose(f, n, c, e) if err == nil && item.E { t.Fatal("expected error, got ") } err = set2.Compose(f, n, c, e) if err == nil && item.E { t.Fatal("expected error, got ") } if set.Cmp(set2) != 0 { t.Fatalf("composing the same value twice resulted in different values. set=%v set2=%v", set, set2) } if err != nil && !item.E { t.Fatalf("unexpected error: %v", err) } if set.Cmp(d) != 0 { t.Fatalf("values incorrect, got %v want %v (%s)", set, d, item.S) } }) } } func TestDecomposerCompose(t *testing.T) { list := []struct { N string // Name. S string // String value. Form byte // Form Neg bool Coef []byte // Coefficent Exp int32 Err bool // Expect an error. }{ {N: "Zero", S: "0", Coef: nil, Exp: 0}, {N: "Normal-1", S: "123.456", Coef: []byte{0x01, 0xE2, 0x40}, Exp: -3}, {N: "Neg-1", S: "-123.456", Neg: true, Coef: []byte{0x01, 0xE2, 0x40}, Exp: -3}, {N: "PosExp-1", S: "123456000", Coef: []byte{0x01, 0xE2, 0x40}, Exp: 3}, {N: "PosExp-2", S: "-123456000", Neg: true, Coef: []byte{0x01, 0xE2, 0x40}, Exp: 3}, {N: "AllDec-1", S: "0.123456", Coef: []byte{0x01, 0xE2, 0x40}, Exp: -6}, {N: "AllDec-2", S: "-0.123456", Neg: true, Coef: []byte{0x01, 0xE2, 0x40}, Exp: -6}, {N: "NaN-1", S: "NaN", Form: 2}, {N: "NaN-2", S: "-NaN", Form: 2, Neg: true}, {N: "Infinity-1", S: "Infinity", Form: 1}, {N: "Infinity-2", S: "-Infinity", Form: 1, Neg: true}, } for _, item := range list { t.Run(item.N, func(t *testing.T) { d, _, err := NewFromString(item.S) if err != nil { t.Fatal(err) } err = d.Compose(item.Form, item.Neg, item.Coef, item.Exp) if err != nil && !item.Err { t.Fatalf("unexpected error, got %v", err) } if item.Err { if err == nil { t.Fatal("expected error, got ") } return } if s := fmt.Sprintf("%f", d); s != item.S { t.Fatalf("unexpected value, got %q want %q", s, item.S) } }) } } apd-3.2.1/doc.go000066400000000000000000000063051450022325000133520ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. /* Package apd implements arbitrary-precision decimals. apd implements much of the decimal specification from the General Decimal Arithmetic (http://speleotrove.com/decimal/) description, which is refered to here as GDA. This is the same specification implemented by pythons decimal module (https://docs.python.org/2/library/decimal.html) and GCCs decimal extension. Features Panic-free operation. The math/big types don’t return errors, and instead panic under some conditions that are documented. This requires users to validate the inputs before using them. Meanwhile, we’d like our decimal operations to have more failure modes and more input requirements than the math/big types, so using that API would be difficult. apd instead returns errors when needed. Support for standard functions. sqrt, ln, pow, etc. Accurate and configurable precision. Operations will use enough internal precision to produce a correct result at the requested precision. Precision is set by a "context" structure that accompanies the function arguments, as discussed in the next section. Good performance. Operations will either be fast enough or will produce an error if they will be slow. This prevents edge-case operations from consuming lots of CPU or memory. Condition flags and traps. All operations will report whether their result is exact, is rounded, is over- or under-flowed, is subnormal (https://en.wikipedia.org/wiki/Denormal_number), or is some other condition. apd supports traps which will trigger an error on any of these conditions. This makes it possible to guarantee exactness in computations, if needed. SQL scan and value methods are implemented. This allows the use of Decimals as placeholder parameters and row result Scan destinations. Usage apd has two main types. The first is Decimal which holds the values of decimals. It is simple and uses a big.Int with an exponent to describe values. Most operations on Decimals can’t produce errors as they work directly on the underlying big.Int. Notably, however, there are no arithmetic operations on Decimals. The second main type is Context, which is where all arithmetic operations are defined. A Context describes the precision, range, and some other restrictions during operations. These operations can all produce failures, and so return errors. Context operations, in addition to errors, return a Condition, which is a bitfield of flags that occurred during an operation. These include overflow, underflow, inexact, rounded, and others. The Traps field of a Context can be set which will produce an error if the corresponding flag occurs. An example of this is given below. */ package apd apd-3.2.1/error.go000066400000000000000000000126471450022325000137440ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd // MakeErrDecimal creates a ErrDecimal with given context. func MakeErrDecimal(c *Context) ErrDecimal { return ErrDecimal{ Ctx: c, } } // ErrDecimal performs operations on decimals and collects errors during // operations. If an error is already set, the operation is skipped. Designed to // be used for many operations in a row, with a single error check at the end. type ErrDecimal struct { err error Ctx *Context // Flags are the accumulated flags from operations. Flags Condition } // Err returns the first error encountered or the context's trap error // if present. func (e *ErrDecimal) Err() error { if e.err != nil { return e.err } if e.Ctx != nil { _, e.err = e.Ctx.goError(e.Flags) return e.err } return nil } // update adjusts the ErrDecimal's state with the result of an operation. func (e *ErrDecimal) update(res Condition, err error) { e.Flags |= res e.err = err } // Abs performs e.Ctx.Abs(d, x) and returns d. func (e *ErrDecimal) Abs(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Abs(d, x)) return d } // Add performs e.Ctx.Add(d, x, y) and returns d. func (e *ErrDecimal) Add(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Add(d, x, y)) return d } // Ceil performs e.Ctx.Ceil(d, x) and returns d. func (e *ErrDecimal) Ceil(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Ceil(d, x)) return d } // Exp performs e.Ctx.Exp(d, x) and returns d. func (e *ErrDecimal) Exp(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Exp(d, x)) return d } // Floor performs e.Ctx.Floor(d, x) and returns d. func (e *ErrDecimal) Floor(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Floor(d, x)) return d } // Int64 returns 0 if err is set. Otherwise returns d.Int64(). func (e *ErrDecimal) Int64(d *Decimal) int64 { if e.Err() != nil { return 0 } var r int64 r, e.err = d.Int64() return r } // Ln performs e.Ctx.Ln(d, x) and returns d. func (e *ErrDecimal) Ln(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Ln(d, x)) return d } // Log10 performs d.Log10(x) and returns d. func (e *ErrDecimal) Log10(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Log10(d, x)) return d } // Mul performs e.Ctx.Mul(d, x, y) and returns d. func (e *ErrDecimal) Mul(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Mul(d, x, y)) return d } // Neg performs e.Ctx.Neg(d, x) and returns d. func (e *ErrDecimal) Neg(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Neg(d, x)) return d } // Pow performs e.Ctx.Pow(d, x, y) and returns d. func (e *ErrDecimal) Pow(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Pow(d, x, y)) return d } // Quantize performs e.Ctx.Quantize(d, v, exp) and returns d. func (e *ErrDecimal) Quantize(d, v *Decimal, exp int32) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Quantize(d, v, exp)) return d } // Quo performs e.Ctx.Quo(d, x, y) and returns d. func (e *ErrDecimal) Quo(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Quo(d, x, y)) return d } // QuoInteger performs e.Ctx.QuoInteger(d, x, y) and returns d. func (e *ErrDecimal) QuoInteger(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.QuoInteger(d, x, y)) return d } // Reduce performs e.Ctx.Reduce(d, x) and returns the number of zeros removed // and d. func (e *ErrDecimal) Reduce(d, x *Decimal) (int, *Decimal) { if e.Err() != nil { return 0, d } n, res, err := e.Ctx.Reduce(d, x) e.update(res, err) return n, d } // Rem performs e.Ctx.Rem(d, x, y) and returns d. func (e *ErrDecimal) Rem(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Rem(d, x, y)) return d } // Round performs e.Ctx.Round(d, x) and returns d. func (e *ErrDecimal) Round(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Round(d, x)) return d } // Sqrt performs e.Ctx.Sqrt(d, x) and returns d. func (e *ErrDecimal) Sqrt(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Sqrt(d, x)) return d } // Sub performs e.Ctx.Sub(d, x, y) and returns d. func (e *ErrDecimal) Sub(d, x, y *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.Sub(d, x, y)) return d } // RoundToIntegralValue performs e.Ctx.RoundToIntegralValue(d, x) and returns d. func (e *ErrDecimal) RoundToIntegralValue(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.RoundToIntegralValue(d, x)) return d } // RoundToIntegralExact performs e.Ctx.RoundToIntegralExact(d, x) and returns d. func (e *ErrDecimal) RoundToIntegralExact(d, x *Decimal) *Decimal { if e.Err() != nil { return d } e.update(e.Ctx.RoundToIntegralExact(d, x)) return d } apd-3.2.1/error_test.go000066400000000000000000000026771450022325000150050ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import "testing" // Appease the unused test. // TODO(mjibson): actually test all the ErrDecimal methods. func TestErrDecimal(t *testing.T) { ed := MakeErrDecimal(testCtx) a := New(1, 0) ed.Abs(a, a) ed.Exp(a, a) ed.Ln(a, a) ed.Log10(a, a) ed.Neg(a, a) ed.Pow(a, a, a) ed.QuoInteger(a, a, a) ed.Rem(a, a, a) ed.Round(a, a) } // TestMakeErrDecimalWithPrecision tests that WithPrecision generates a copy // and not a reference. func TestMakeErrDecimalWithPrecision(t *testing.T) { c := &Context{ Precision: 5, MaxExponent: 2, } nc := c.WithPrecision(c.Precision * 2) ed := MakeErrDecimal(nc) if ed.Ctx.Precision != 10 { t.Fatalf("expected %d, got %d", 10, ed.Ctx.Precision) } if c.Precision != 5 { t.Fatalf("expected %d, got %d", 5, c.Precision) } if c.MaxExponent != 2 { t.Fatalf("expected %d, got %d", 2, c.MaxExponent) } } apd-3.2.1/example_test.go000066400000000000000000000101011450022325000152640ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd_test import ( "fmt" "github.com/cockroachdb/apd/v3" ) // ExampleOverflow demonstrates how to detect or error on overflow. func ExampleContext_overflow() { // Create a context that will overflow at 1e3. c := apd.Context{ MaxExponent: 2, Traps: apd.Overflow, } one := apd.New(1, 0) d := apd.New(997, 0) for { res, err := c.Add(d, d, one) fmt.Printf("d: %8s, overflow: %5v, err: %v\n", d, res.Overflow(), err) if err != nil { return } } // Output: // d: 998, overflow: false, err: // d: 999, overflow: false, err: // d: Infinity, overflow: true, err: overflow } // ExampleInexact demonstrates how to detect inexact operations. func ExampleContext_inexact() { d := apd.New(27, 0) three := apd.New(3, 0) c := apd.BaseContext.WithPrecision(5) for { res, err := c.Quo(d, d, three) fmt.Printf("d: %7s, inexact: %5v, err: %v\n", d, res.Inexact(), err) if err != nil { return } if res.Inexact() { return } } // Output: // d: 9.0000, inexact: false, err: // d: 3.0000, inexact: false, err: // d: 1.0000, inexact: false, err: // d: 0.33333, inexact: true, err: } func ExampleContext_Quantize() { input, _, _ := apd.NewFromString("123.45") output := new(apd.Decimal) c := apd.BaseContext.WithPrecision(10) for i := int32(-3); i <= 3; i++ { res, _ := c.Quantize(output, input, i) fmt.Printf("%2v: %s", i, output) if res != 0 { fmt.Printf(" (%s)", res) } fmt.Println() } // Output: // -3: 123.450 // -2: 123.45 // -1: 123.5 (inexact, rounded) // 0: 123 (inexact, rounded) // 1: 1.2E+2 (inexact, rounded) // 2: 1E+2 (inexact, rounded) // 3: 0E+3 (inexact, rounded) } func ExampleErrDecimal() { c := apd.BaseContext.WithPrecision(5) ed := apd.MakeErrDecimal(c) d := apd.New(10, 0) fmt.Printf("%s, err: %v\n", d, ed.Err()) ed.Add(d, d, apd.New(2, 1)) // add 20 fmt.Printf("%s, err: %v\n", d, ed.Err()) ed.Quo(d, d, apd.New(0, 0)) // divide by zero fmt.Printf("%s, err: %v\n", d, ed.Err()) ed.Sub(d, d, apd.New(1, 0)) // attempt to subtract 1 // The subtraction doesn't occur and doesn't change the error. fmt.Printf("%s, err: %v\n", d, ed.Err()) // Output: // 10, err: // 30, err: // Infinity, err: division by zero // Infinity, err: division by zero } // ExampleRoundToIntegralExact demonstrates how to use RoundToIntegralExact to // check if a number is an integer or not. Note the variations between integer // (which allows zeros after the decimal point) and strict (which does not). See // the documentation on Inexact and Rounded. func ExampleContext_RoundToIntegralExact() { inputs := []string{ "123.4", "123.0", "123", "12E1", "120E-1", "120E-2", } for _, input := range inputs { d, _, _ := apd.NewFromString(input) res, _ := apd.BaseContext.RoundToIntegralExact(d, d) integer := !res.Inexact() strict := !res.Rounded() fmt.Printf("input: % 6s, output: %3s, integer: %5t, strict: %5t, res:", input, d, integer, strict) if res != 0 { fmt.Printf(" %s", res) } fmt.Println() } // Output: // input: 123.4, output: 123, integer: false, strict: false, res: inexact, rounded // input: 123.0, output: 123, integer: true, strict: false, res: rounded // input: 123, output: 123, integer: true, strict: true, res: // input: 12E1, output: 120, integer: true, strict: true, res: // input: 120E-1, output: 12, integer: true, strict: false, res: rounded // input: 120E-2, output: 1, integer: false, strict: false, res: inexact, rounded } apd-3.2.1/form_string.go000066400000000000000000000005431450022325000151340ustar00rootroot00000000000000// Code generated by "stringer -type=Form"; DO NOT EDIT. package apd import "fmt" const _Form_name = "FiniteInfiniteNaNSignalingNaN" var _Form_index = [...]uint8{0, 6, 14, 26, 29} func (i Form) String() string { if i < 0 || i >= Form(len(_Form_index)-1) { return fmt.Sprintf("Form(%d)", i) } return _Form_name[_Form_index[i]:_Form_index[i+1]] } apd-3.2.1/format.go000066400000000000000000000143111450022325000140710ustar00rootroot00000000000000// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Adapted from math/big/ftoa.go. package apd import ( "fmt" "strconv" ) // Text converts the floating-point number x to a string according // to the given format. The format is one of: // // 'e' -d.dddde±dd, decimal exponent, exponent digits // 'E' -d.ddddE±dd, decimal exponent, exponent digits // 'f' -ddddd.dddd, no exponent // 'g' like 'e' for large exponents, like 'f' otherwise // 'G' like 'E' for large exponents, like 'f' otherwise // // If format is a different character, Text returns a "%" followed by the // unrecognized.Format character. The 'f' format has the possibility of // displaying precision that is not present in the Decimal when it appends // zeros (the 'g' format avoids the use of 'f' in this case). All other // formats always show the exact precision of the Decimal. func (d *Decimal) Text(format byte) string { var buf [16]byte return string(d.Append(buf[:0], format)) } // String formats x like x.Text('G'). It matches the to-scientific-string // conversion of the GDA spec. func (d *Decimal) String() string { return d.Text('G') } // lowestZeroNegativeCoefficientCockroach is the smallest co-efficient in // Cockroach supports using 0E. const lowestZeroNegativeCoefficientCockroach = -2000 // Append appends to buf the string form of the decimal number d, // as generated by d.Text, and returns the extended buffer. func (d *Decimal) Append(buf []byte, fmtString byte) []byte { // sign if d.Negative { buf = append(buf, '-') } switch d.Form { case Finite: // ignore case NaN: return append(buf, "NaN"...) case NaNSignaling: return append(buf, "sNaN"...) case Infinite: return append(buf, "Infinity"...) default: return append(buf, "unknown"...) } var scratch [16]byte digits := d.Coeff.Append(scratch[:0], 10) switch fmtString { case 'e', 'E': return fmtE(buf, fmtString, d, digits) case 'f': return fmtF(buf, d, digits) case 'g', 'G': digitLen := len(digits) // PG formats all 0s after the decimal point in the 0E- case // (e.g. 0E-9 should be 0.000000000). With the `adjExponentLimit` below, // this does not do that, so for 0 with negative coefficients we pad // the digit length. // Ref: https://github.com/cockroachdb/cockroach/issues/102217 // // To avoid leaking too much memory for pathological cases, e.g. // 0E-100000000, we also fall back to the default exponent format // handling when the exponent is below cockroach's lowest supported 0 // coefficient. if d.Coeff.BitLen() == 0 && d.Exponent >= lowestZeroNegativeCoefficientCockroach && d.Exponent < 0 { digitLen += int(-d.Exponent) } // See: http://speleotrove.com/decimal/daconvs.html#reftostr const adjExponentLimit = -6 adj := int(d.Exponent) + (digitLen - 1) if d.Exponent <= 0 && adj >= adjExponentLimit { return fmtF(buf, d, digits) } // We need to convert the either g or G into a e or E since that's what fmtE // expects. This is indeed fmtString - 2, but attempting to do that in a way that // illustrates the intention. return fmtE(buf, fmtString+'e'-'g', d, digits) } if d.Negative { buf = buf[:len(buf)-1] // sign was added prematurely - remove it again } return append(buf, '%', fmtString) } // %e: d.ddddde±d func fmtE(buf []byte, fmt byte, d *Decimal, digits []byte) []byte { adj := int64(d.Exponent) + int64(len(digits)) - 1 buf = append(buf, digits[0]) if len(digits) > 1 { buf = append(buf, '.') buf = append(buf, digits[1:]...) } buf = append(buf, fmt) var ch byte if adj < 0 { ch = '-' adj = -adj } else { ch = '+' } buf = append(buf, ch) return strconv.AppendInt(buf, adj, 10) } // %f: ddddddd.ddddd func fmtF(buf []byte, d *Decimal, digits []byte) []byte { if d.Exponent < 0 { if left := -int(d.Exponent) - len(digits); left >= 0 { buf = append(buf, "0."...) for i := 0; i < left; i++ { buf = append(buf, '0') } buf = append(buf, digits...) } else if left < 0 { offset := -left buf = append(buf, digits[:offset]...) buf = append(buf, '.') buf = append(buf, digits[offset:]...) } } else if d.Exponent >= 0 { buf = append(buf, digits...) for i := int32(0); i < d.Exponent; i++ { buf = append(buf, '0') } } return buf } var _ fmt.Formatter = decimalZero // *Decimal must implement fmt.Formatter // Format implements fmt.Formatter. It accepts many of the regular formats for // floating-point numbers ('e', 'E', 'f', 'F', 'g', 'G') as well as 's' and 'v', // which are handled like 'G'. Format also supports the output field width, as // well as the format flags '+' and ' ' for sign control, '0' for space or zero // padding, and '-' for left or right justification. It does not support // precision. See the fmt package for details. func (d *Decimal) Format(s fmt.State, format rune) { switch format { case 'e', 'E', 'f', 'g', 'G': // nothing to do case 'F': // (*Decimal).Text doesn't support 'F'; handle like 'f' format = 'f' case 'v', 's': // handle like 'G' format = 'G' default: fmt.Fprintf(s, "%%!%c(*apd.Decimal=%s)", format, d.String()) return } var buf []byte buf = d.Append(buf, byte(format)) if len(buf) == 0 { buf = []byte("?") // should never happen, but don't crash } // len(buf) > 0 var sign string switch { case buf[0] == '-': sign = "-" buf = buf[1:] case buf[0] == '+': // +Inf sign = "+" if s.Flag(' ') { sign = " " } buf = buf[1:] case s.Flag('+'): sign = "+" case s.Flag(' '): sign = " " } var padding int if width, hasWidth := s.Width(); hasWidth && width > len(sign)+len(buf) { padding = width - len(sign) - len(buf) } switch { case s.Flag('0') && d.Form == Finite: // 0-padding on left writeMultiple(s, sign, 1) writeMultiple(s, "0", padding) s.Write(buf) case s.Flag('-'): // padding on right writeMultiple(s, sign, 1) s.Write(buf) writeMultiple(s, " ", padding) default: // padding on left writeMultiple(s, " ", padding) writeMultiple(s, sign, 1) s.Write(buf) } } // write count copies of text to s func writeMultiple(s fmt.State, text string, count int) { if len(text) > 0 { b := []byte(text) for ; count > 0; count-- { s.Write(b) } } } apd-3.2.1/gda_test.go000066400000000000000000000476601450022325000144100ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "bufio" "bytes" "flag" "fmt" "io" "os" "path/filepath" "sort" "strconv" "strings" "sync" "testing" "time" ) const testDir = "testdata" var ( flagFailFast = flag.Bool("fast", false, "stop work after first error; disables parallel testing") flagIgnore = flag.Bool("ignore", false, "print ignore lines on errors") flagNoParallel = flag.Bool("noparallel", false, "disables parallel testing") flagTime = flag.Duration("time", 0, "interval at which to print long-running functions; 0 disables") ) type TestCase struct { Precision int MaxExponent, MinExponent int Rounding string Extended, Clamp bool ID string Operation string Operands []string Result string Conditions []string } func (tc TestCase) HasNull() bool { if tc.Result == "#" { return true } for _, o := range tc.Operands { if o == "#" { return true } } return false } func (tc TestCase) SkipPrecision() bool { switch tc.Operation { case "tosci", "toeng", "apply": return false default: return true } } func ParseDecTest(r io.Reader) ([]TestCase, error) { scanner := bufio.NewScanner(r) tc := TestCase{ Extended: true, } var err error var res []TestCase for scanner.Scan() { text := scanner.Text() // TODO(mjibson): support these test cases if strings.Contains(text, "#") { continue } line := strings.Fields(strings.ToLower(text)) for i, t := range line { if strings.HasPrefix(t, "--") { line = line[:i] break } } if len(line) == 0 { continue } if strings.HasSuffix(line[0], ":") { if len(line) != 2 { return nil, fmt.Errorf("expected 2 tokens, got %q", text) } switch directive := line[0]; directive[:len(directive)-1] { case "precision": tc.Precision, err = strconv.Atoi(line[1]) if err != nil { return nil, err } case "maxexponent": tc.MaxExponent, err = strconv.Atoi(line[1]) if err != nil { return nil, err } case "minexponent": tc.MinExponent, err = strconv.Atoi(line[1]) if err != nil { return nil, err } case "rounding": tc.Rounding = line[1] case "version": // ignore case "extended": tc.Extended = line[1] == "1" case "clamp": tc.Clamp = line[1] == "1" default: return nil, fmt.Errorf("unsupported directive: %s", directive) } } else { if len(line) < 5 { return nil, fmt.Errorf("short test case line: %q", text) } tc.ID = line[0] tc.Operation = line[1] tc.Operands = nil var ops []string line = line[2:] for i, o := range line { if o == "->" { tc.Operands = ops line = line[i+1:] break } o = cleanNumber(o) ops = append(ops, o) } if tc.Operands == nil || len(line) < 1 { return nil, fmt.Errorf("bad test case line: %q", text) } tc.Result = strings.ToUpper(cleanNumber(line[0])) tc.Conditions = line[1:] res = append(res, tc) } } if err := scanner.Err(); err != nil { return nil, err } return res, nil } func cleanNumber(s string) string { if len(s) > 1 && s[0] == '\'' && s[len(s)-1] == '\'' { s = s[1 : len(s)-1] s = strings.Replace(s, `''`, `'`, -1) } else if len(s) > 1 && s[0] == '"' && s[len(s)-1] == '"' { s = s[1 : len(s)-1] s = strings.Replace(s, `""`, `"`, -1) } return s } // Copy ioutil.ReadDir to avoid staticcheck warning on go1.19 and above. Replace // with a call to os.ReadDir when we remove support for go1.15 and below. func ReadDir(dirname string) ([]os.FileInfo, error) { f, err := os.Open(dirname) if err != nil { return nil, err } list, err := f.Readdir(-1) f.Close() if err != nil { return nil, err } sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() }) return list, nil } func TestParseDecTest(t *testing.T) { files, err := ReadDir(testDir) if err != nil { t.Fatal(err) } for _, fi := range files { t.Run(fi.Name(), func(t *testing.T) { f, err := os.Open(filepath.Join(testDir, fi.Name())) if err != nil { t.Fatal(err) } defer f.Close() _, err = ParseDecTest(f) if err != nil { t.Fatal(err) } }) } } var GDAfiles = []string{ "abs", "add", "base", "compare", "comparetotal", "divide", "divideint", "exp", "ln", "log10", "minus", "multiply", "plus", "power", "powersqrt", "quantize", "randoms", "reduce", "remainder", "rounding", "squareroot", "subtract", "tointegral", "tointegralx", // non-GDA tests "cuberoot-apd", } func TestGDA(t *testing.T) { var buf bytes.Buffer fmt.Fprintf(&buf, "%10s%8s%8s%8s%8s%8s%8s\n", "name", "total", "success", "fail", "ignore", "skip", "missing") for _, fname := range GDAfiles { succeed := t.Run(fname, func(t *testing.T) { path, tcs := readGDA(t, fname) gdaTest(t, path, tcs) }) if !succeed && *flagFailFast { break } } } func (tc TestCase) Run(c *Context, done chan error, d, x, y *Decimal) (res Condition, err error) { switch tc.Operation { case "abs": res, err = c.Abs(d, x) case "add": res, err = c.Add(d, x, y) case "compare": res, err = c.Cmp(d, x, y) case "cuberoot": res, err = c.Cbrt(d, x) case "divide": res, err = c.Quo(d, x, y) case "divideint": res, err = c.QuoInteger(d, x, y) case "exp": res, err = c.Exp(d, x) case "ln": res, err = c.Ln(d, x) case "log10": res, err = c.Log10(d, x) case "minus": res, err = c.Neg(d, x) case "multiply": res, err = c.Mul(d, x, y) case "plus": res, err = c.Add(d, x, decimalZero) case "power": res, err = c.Pow(d, x, y) case "quantize": res, err = c.Quantize(d, x, y.Exponent) case "reduce": _, res, err = c.Reduce(d, x) case "remainder": res, err = c.Rem(d, x, y) case "squareroot": res, err = c.Sqrt(d, x) case "subtract": res, err = c.Sub(d, x, y) case "tointegral": res, err = c.RoundToIntegralValue(d, x) case "tointegralx": res, err = c.RoundToIntegralExact(d, x) // Below used only in benchmarks. Tests call it themselves. case "comparetotal": x.CmpTotal(y) case "tosci": _ = x.String() default: done <- fmt.Errorf("unknown operation: %s", tc.Operation) } return } // BenchmarkGDA benchmarks a GDA test. It should not be used without specifying // a sub-benchmark to run. For example: // go test -run XX -bench GDA/squareroot func BenchmarkGDA(b *testing.B) { for _, fname := range GDAfiles { b.Run(fname, func(b *testing.B) { type benchCase struct { tc TestCase ctx *Context ops [2]*Decimal } _, tcs := readGDA(b, fname) bcs := make([]benchCase, 0, len(tcs)) Loop: for _, tc := range tcs { if GDAignore[tc.ID] || tc.Result == "?" || tc.HasNull() { continue } switch tc.Operation { case "apply", "toeng": continue } bc := benchCase{ tc: tc, ctx: tc.Context(b), } for i, o := range tc.Operands { d, _, err := NewFromString(o) if err != nil { continue Loop } bc.ops[i] = d } bcs = append(bcs, bc) } // Translate inputs and outputs to Decimal vectors. op1s := make([]Decimal, len(bcs)) op2s := make([]Decimal, len(bcs)) res := make([]Decimal, b.N*len(bcs)) for i, bc := range bcs { op1s[i].Set(bc.ops[0]) if bc.ops[1] != nil { op2s[i].Set(bc.ops[1]) } } b.ResetTimer() for i := 0; i < b.N; i++ { for j, bc := range bcs { // Ignore errors here because the full tests catch them. _, _ = bc.tc.Run(bc.ctx, nil, &res[i*len(bcs)+j], &op1s[j], &op2s[j]) } } }) } } func readGDA(t testing.TB, name string) (string, []TestCase) { path := filepath.Join(testDir, name+".decTest") f, err := os.Open(path) if err != nil { t.Fatal(err) } defer f.Close() tcs, err := ParseDecTest(f) if err != nil { t.Fatal(err) } return path, tcs } func (tc TestCase) Context(t testing.TB) *Context { rounding := Rounder(tc.Rounding) if _, ok := roundings[rounding]; !ok { t.Fatalf("unsupported rounding mode %s", tc.Rounding) } c := &Context{ Precision: uint32(tc.Precision), MaxExponent: int32(tc.MaxExponent), MinExponent: int32(tc.MinExponent), Rounding: rounding, Traps: 0, } return c } func gdaTest(t *testing.T, path string, tcs []TestCase) { for _, tc := range tcs { tc := tc succeed := t.Run(tc.ID, func(t *testing.T) { if *flagTime > 0 { timeDone := make(chan struct{}, 1) go func() { start := time.Now() for { select { case <-timeDone: return case <-time.After(*flagTime): fmt.Println(tc.ID, "running for", time.Since(start)) } } }() defer func() { timeDone <- struct{}{} }() } defer func() { if t.Failed() { if *flagIgnore { tc.PrintIgnore() } } }() if GDAignore[tc.ID] { t.Skip("ignored") } if tc.HasNull() { t.Skip("has null") } switch tc.Operation { case "toeng", "apply": t.Skip("unsupported") } if !*flagNoParallel && !*flagFailFast { t.Parallel() } // helpful acme address link t.Logf("%s:/^%s ", path, tc.ID) t.Logf("%s %s = %s (%s)", tc.Operation, strings.Join(tc.Operands, " "), tc.Result, strings.Join(tc.Conditions, " ")) t.Logf("prec: %d, round: %s, Emax: %d, Emin: %d", tc.Precision, tc.Rounding, tc.MaxExponent, tc.MinExponent) operands := make([]*Decimal, 2) c := tc.Context(t) var res, opres Condition opctx := c if tc.SkipPrecision() { opctx = opctx.WithPrecision(1000) opctx.MaxExponent = MaxExponent opctx.MinExponent = MinExponent } for i, o := range tc.Operands { d, ores, err := opctx.NewFromString(o) expectError := tc.Result == "NAN" && strings.Join(tc.Conditions, "") == "conversion_syntax" if err != nil { if expectError { // Successfully detected bad syntax. return } switch tc.Operation { case "tosci": // Skip cases with exponents larger than we will parse. if strings.Contains(err.Error(), "value out of range") { return } } testExponentError(t, err) if tc.Result == "?" { return } t.Logf("%v, %v, %v", tc.Result, tc.Conditions, tc.Operation) t.Fatalf("operand %d: %s: %+v", i, o, err) } else if expectError { t.Fatalf("expected error, got %s", d) } operands[i] = d opres |= ores } switch tc.Operation { case "power": tmp := new(Decimal).Abs(operands[1]) // We don't handle power near the max exp limit. if tmp.Cmp(New(MaxExponent, 0)) >= 0 { t.Skip("x ** large y") } if tmp.Cmp(New(int64(c.MaxExponent), 0)) >= 0 { t.Skip("x ** large y") } case "quantize": if operands[1].Form != Finite { t.Skip("quantize requires finite second operand") } } var s string // Fill d with bogus data to make sure all fields are correctly set. d := &Decimal{ Form: -2, Negative: true, Exponent: -6437897, } // Use d1 and d2 to verify that the result can be the same as the first and // second operand. var d1, d2 *Decimal d.Coeff.SetInt64(9221) start := time.Now() defer func() { t.Logf("duration: %s", time.Since(start)) }() done := make(chan error, 1) var err error go func() { switch tc.Operation { case "tosci": s = operands[0].String() // non-extended tests don't retain exponents for 0 if !tc.Extended && operands[0].IsZero() { s = "0" } // Clear d's bogus data. d.Set(operands[0]) // Set d1 to prevent the result-equals-operand check failing. d1 = d case "comparetotal": var c int c = operands[0].CmpTotal(operands[1]) d.SetInt64(int64(c)) default: var wg sync.WaitGroup wg.Add(2) // Check that the result is correct even if it is either argument. Use some // go routines since we are running tc.Run three times. go func() { d1 = new(Decimal).Set(operands[0]) tc.Run(c, done, d1, d1, operands[1]) wg.Done() }() go func() { if operands[1] != nil { d2 = new(Decimal).Set(operands[1]) tc.Run(c, done, d2, operands[0], d2) } wg.Done() }() res, err = tc.Run(c, done, d, operands[0], operands[1]) wg.Wait() } done <- nil }() select { case err := <-done: if err != nil { t.Fatal(err) } case <-time.After(time.Second * 20): t.Fatalf("timeout") } if d.Coeff.Sign() < 0 { t.Fatalf("negative coeff: %s", d.Coeff.String()) } // Make sure the bogus Form above got cleared. if d.Form < 0 { t.Fatalf("unexpected form: %#v", d) } // Verify the operands didn't change. for i, o := range tc.Operands { v := newDecimal(t, opctx, o) if v.CmpTotal(operands[i]) != 0 { t.Fatalf("operand %d changed from %s to %s", i, o, operands[i]) } } // Verify the result-equals-operand worked correctly. if d1 != nil && d.CmpTotal(d1) != 0 { t.Errorf("first operand as result mismatch: got %s, expected %s", d1, d) } if d2 != nil && d.CmpTotal(d2) != 0 { t.Errorf("second operand as result mismatch: got %s, expected %s", d2, d) } if !GDAignoreFlags[tc.ID] { var rcond Condition for _, cond := range tc.Conditions { switch cond { case "underflow": rcond |= Underflow case "inexact": rcond |= Inexact case "overflow": rcond |= Overflow case "subnormal": rcond |= Subnormal case "division_undefined": rcond |= DivisionUndefined case "division_by_zero": rcond |= DivisionByZero case "division_impossible": rcond |= DivisionImpossible case "invalid_operation": rcond |= InvalidOperation case "rounded": rcond |= Rounded case "clamped": rcond |= Clamped case "invalid_context": // ignore default: t.Fatalf("unknown condition: %s", cond) } } switch tc.Operation { case "tosci": // We only care about the operand flags for the string conversion operations. res |= opres } t.Logf("want flags (%d): %s", rcond, rcond) t.Logf("have flags (%d): %s", res, res) // TODO(mjibson): after upscaling, operations need to remove the 0s added // after the operation is done. Since this isn't happening, things are being // rounded when they shouldn't because the coefficient has so many trailing 0s. // Manually remove Rounded flag from context until the TODO is fixed. res &= ^Rounded rcond &= ^Rounded switch tc.Operation { case "log10": // TODO(mjibson): Under certain conditions these are exact, but we don't // correctly mark them. Ignore these flags for now. // squareroot sometimes marks things exact when GDA says they should be // inexact. rcond &= ^Inexact res &= ^Inexact } // Don't worry about these flags; they are handled by GoError. res &= ^SystemOverflow res &= ^SystemUnderflow if (res.Overflow() || res.Underflow()) && (strings.HasPrefix(tc.ID, "rpow") || strings.HasPrefix(tc.ID, "powr")) { t.Skip("overflow") } // Ignore Clamped on error. if tc.Result == "?" { rcond &= ^Clamped res &= ^Clamped } if rcond != res { if tc.Operation == "power" && (res.Overflow() || res.Underflow()) { t.Skip("power overflow") } t.Logf("got: %s (%#v)", d, d) t.Logf("error: %+v", err) t.Errorf("expected flags %q (%d); got flags %q (%d)", rcond, rcond, res, res) } } if tc.Result == "?" { if err != nil { return } t.Fatalf("expected error, got %s", d) } if err != nil { testExponentError(t, err) if tc.Operation == "power" && (res.Overflow() || res.Underflow()) { t.Skip("power overflow") } t.Fatalf("%+v", err) } switch tc.Operation { case "tosci", "toeng": if strings.HasPrefix(tc.Result, "-NAN") { tc.Result = "-NaN" } if strings.HasPrefix(tc.Result, "-SNAN") { tc.Result = "-sNaN" } if strings.HasPrefix(tc.Result, "NAN") { tc.Result = "NaN" } if strings.HasPrefix(tc.Result, "SNAN") { tc.Result = "sNaN" } expected := tc.Result // Adjust 0E- or -0E- tests to match PostgreSQL behavior. // See: https://github.com/cockroachdb/cockroach/issues/102217. if pos, neg := strings.HasPrefix(expected, "0E-"), strings.HasPrefix(expected, "-0E-"); pos || neg { startIdx := 3 if neg { startIdx = 4 } p, err := strconv.ParseInt(expected[startIdx:], 10, 64) if err != nil { t.Fatalf("unexpected error converting int: %v", err) } if p <= -lowestZeroNegativeCoefficientCockroach { expected = "" if neg { expected = "-" } expected += "0." + strings.Repeat("0", int(p)) } } if !strings.EqualFold(s, expected) { t.Fatalf("expected %s, got %s", expected, s) } return } r := newDecimal(t, testCtx, tc.Result) var equal bool if d.Form == Finite { // Don't worry about trailing zeros being inequal in CmpTotal. equal = d.Cmp(r) == 0 && d.Negative == r.Negative } else { equal = d.CmpTotal(r) == 0 } if !equal { t.Logf("want: %s", tc.Result) t.Logf("got: %s (%#v)", d, d) // Some operations allow 1ulp of error in tests. switch tc.Operation { case "exp", "ln", "log10", "power": nc := c.WithPrecision(0) nc.Sub(d, d, r) if d.Coeff.Cmp(bigOne) == 0 { t.Logf("pass: within 1ulp: %s, %s", d, r) return } } t.Fatalf("unexpected result") } else { t.Logf("got: %s (%#v)", d, d) } }) if !succeed { if *flagFailFast { break } } } } func (tc TestCase) PrintIgnore() { fmt.Printf(" \"%s\": true,\n", tc.ID) } var GDAignore = map[string]bool{ // Invalid context "expx901": true, "expx902": true, "expx903": true, "expx905": true, "lnx901": true, "lnx902": true, "lnx903": true, "lnx905": true, "logx901": true, "logx902": true, "logx903": true, "logx905": true, "powx4001": true, "powx4002": true, "powx4003": true, "powx4005": true, // NaN payloads with weird digits "basx725": true, "basx745": true, // NaN payloads "cotx970": true, "cotx973": true, "cotx974": true, "cotx977": true, "cotx980": true, "cotx983": true, "cotx984": true, "cotx987": true, "cotx994": true, // too large exponents, supposed to fail anyway "quax525": true, "quax531": true, "quax805": true, "quax806": true, "quax807": true, "quax808": true, "quax809": true, "quax810": true, "quax811": true, "quax812": true, "quax813": true, "quax814": true, "quax815": true, "quax816": true, "quax817": true, "quax818": true, "quax819": true, "quax820": true, "quax821": true, "quax822": true, "quax861": true, "quax862": true, "quax866": true, // TODO(mjibson): fix tests below // overflows to infinity "powx4125": true, "powx4145": true, // exceeds system overflow "expx291": true, "expx292": true, "expx293": true, "expx294": true, "expx295": true, "expx296": true, // inexact zeros "addx1633": true, "addx1634": true, "addx1638": true, "addx61633": true, "addx61634": true, "addx61638": true, // should be -0E-398, got -1E-398 "addx1613": true, "addx1614": true, "addx1618": true, "addx61613": true, "addx61614": true, "addx61618": true, // extreme input range, but should work "sqtx8636": true, "sqtx8644": true, "sqtx8646": true, "sqtx8647": true, "sqtx8648": true, "sqtx8650": true, "sqtx8651": true, } var GDAignoreFlags = map[string]bool{ // unflagged clamped "sqtx9024": true, "sqtx9025": true, "sqtx9026": true, "sqtx9027": true, "sqtx9038": true, "sqtx9039": true, "sqtx9040": true, "sqtx9045": true, } apd-3.2.1/go.mod000066400000000000000000000001211450022325000133520ustar00rootroot00000000000000module github.com/cockroachdb/apd/v3 go 1.17 require github.com/lib/pq v1.10.7 apd-3.2.1/go.sum000066400000000000000000000002331450022325000134030ustar00rootroot00000000000000github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw= github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= apd-3.2.1/loop.go000066400000000000000000000056031450022325000135560ustar00rootroot00000000000000// Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file is adapted from https://github.com/robpike/ivy/blob/master/value/loop.go. package apd import ( "fmt" "math" ) type loop struct { c *Context name string // The name of the function we are evaluating. i uint64 // Loop count. precision int32 maxIterations uint64 // When to give up. arg *Decimal // original argument to function; only used for diagnostic. prevZ Decimal // Result from the previous iteration. delta Decimal // |Change| from previous iteration. } const digitsToBitsRatio = math.Ln10 / math.Ln2 // newLoop returns a new loop checker. Arguments: // - name: name of the function being calculated (for error messages) // - arg: argument to the function (for error messages) // - precision: desired precision; the loop ends when consecutive estimates // differ less than the desired precision. Note that typically // the inner computations in an iteration need higher precision, // so this is normally lower than the precision in the context. // - maxItersPerDigit: after this many iterations per digit of precision, the // loop ends in error. func (c *Context) newLoop(name string, arg *Decimal, precision uint32, maxItersPerDigit int) *loop { return &loop{ c: c, name: name, arg: new(Decimal).Set(arg), precision: int32(precision), maxIterations: 10 + uint64(maxItersPerDigit*int(precision)), } } // done reports whether the loop is done. If it does not converge // after the maximum number of iterations, it returns an error. func (l *loop) done(z *Decimal) (bool, error) { if _, err := l.c.Sub(&l.delta, &l.prevZ, z); err != nil { return false, err } sign := l.delta.Sign() if sign == 0 { return true, nil } if sign < 0 { // Convergence can oscillate when the calculation is nearly // done and we're running out of bits. This stops that. // See next comment. l.delta.Neg(&l.delta) } // We stop if the delta is smaller than a change of 1 in the // (l.precision)-th digit of z. Examples: // // p = 4 // z = 12345.678 = 12345678 * 10^-3 // eps = 10.000 = 10^(-4+8-3) // // p = 3 // z = 0.001234 = 1234 * 10^-6 // eps = 0.00001 = 10^(-3+4-6) var eps Decimal eps.Coeff.Set(bigOne) eps.Exponent = -l.precision + int32(z.NumDigits()) + z.Exponent if l.delta.Cmp(&eps) <= 0 { return true, nil } l.i++ if l.i == l.maxIterations { return false, fmt.Errorf( "%s %s: did not converge after %d iterations; prev,last result %s,%s delta %s precision: %d", l.name, l.arg.String(), l.maxIterations, z.String(), l.prevZ.String(), l.delta.String(), l.precision, ) } l.prevZ.Set(z) return false, nil } apd-3.2.1/round.go000066400000000000000000000131031450022325000137260ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd // Round sets d to rounded x, rounded to the precision specified by c. If c // has zero precision, no rounding will occur. If c has no Rounding specified, // RoundHalfUp is used. func (c *Context) Round(d, x *Decimal) (Condition, error) { return c.goError(c.round(d, x)) } //gcassert:inline func (c *Context) round(d, x *Decimal) Condition { return c.Rounding.Round(c, d, x, true /* disableIfPrecisionZero */) } // Rounder specifies the behavior of rounding. type Rounder string // ShouldAddOne returns true if 1 should be added to the absolute value // of a number being rounded. result is the result to which the 1 would // be added. neg is true if the number is negative. half is -1 if the // discarded digits are < 0.5, 0 if = 0.5, or 1 if > 0.5. func (r Rounder) ShouldAddOne(result *BigInt, neg bool, half int) bool { // NOTE: this is written using a switch statement instead of some // other form of dynamic dispatch to assist Go's escape analysis. switch r { case RoundDown: return roundDown(result, neg, half) case RoundHalfUp: return roundHalfUp(result, neg, half) case RoundHalfEven: return roundHalfEven(result, neg, half) case RoundCeiling: return roundCeiling(result, neg, half) case RoundFloor: return roundFloor(result, neg, half) case RoundHalfDown: return roundHalfDown(result, neg, half) case RoundUp: return roundUp(result, neg, half) case Round05Up: return round05Up(result, neg, half) default: return roundHalfUp(result, neg, half) } } // Round sets d to rounded x. func (r Rounder) Round(c *Context, d, x *Decimal, disableIfPrecisionZero bool) Condition { d.Set(x) nd := x.NumDigits() xs := x.Sign() var res Condition if disableIfPrecisionZero && c.Precision == 0 { // Rounding has been disabled. return d.setExponent(c, nd, res, int64(d.Exponent)) } // adj is the adjusted exponent: exponent + clength - 1 if adj := int64(x.Exponent) + nd - 1; xs != 0 && adj < int64(c.MinExponent) { // Subnormal is defined before rounding. res |= Subnormal // setExponent here to prevent double-rounded subnormals. res |= d.setExponent(c, nd, res, int64(d.Exponent)) return res } diff := nd - int64(c.Precision) if diff > 0 { if diff > MaxExponent { return SystemOverflow | Overflow } if diff < MinExponent { return SystemUnderflow | Underflow } res |= Rounded var y, m BigInt e := tableExp10(diff, &y) y.QuoRem(&d.Coeff, e, &m) if m.Sign() != 0 { res |= Inexact var discard Decimal discard.Coeff.Set(&m) discard.Exponent = int32(-diff) if r.ShouldAddOne(&y, x.Negative, discard.Cmp(decimalHalf)) { roundAddOne(&y, &diff) } } d.Coeff.Set(&y) // The coefficient changed, so recompute num digits in setExponent. nd = unknownNumDigits } else { diff = 0 } res |= d.setExponent(c, nd, res, int64(d.Exponent), diff) return res } // roundAddOne adds 1 to abs(b). func roundAddOne(b *BigInt, diff *int64) { if b.Sign() < 0 { panic("unexpected negative") } nd := NumDigits(b) b.Add(b, bigOne) nd2 := NumDigits(b) if nd2 > nd { b.Quo(b, bigTen) *diff++ } } // roundings is a set containing all available Rounders. var roundings = map[Rounder]struct{}{ RoundDown: {}, RoundHalfUp: {}, RoundHalfEven: {}, RoundCeiling: {}, RoundFloor: {}, RoundHalfDown: {}, RoundUp: {}, Round05Up: {}, } const ( // RoundDown rounds toward 0; truncate. RoundDown Rounder = "down" // RoundHalfUp rounds up if the digits are >= 0.5. RoundHalfUp Rounder = "half_up" // RoundHalfEven rounds up if the digits are > 0.5. If the digits are equal // to 0.5, it rounds up if the previous digit is odd, always producing an // even digit. RoundHalfEven Rounder = "half_even" // RoundCeiling towards +Inf: rounds up if digits are > 0 and the number // is positive. RoundCeiling Rounder = "ceiling" // RoundFloor towards -Inf: rounds up if digits are > 0 and the number // is negative. RoundFloor Rounder = "floor" // RoundHalfDown rounds up if the digits are > 0.5. RoundHalfDown Rounder = "half_down" // RoundUp rounds away from 0. RoundUp Rounder = "up" // Round05Up rounds zero or five away from 0; same as round-up, except that // rounding up only occurs if the digit to be rounded up is 0 or 5. Round05Up Rounder = "05up" ) func roundDown(result *BigInt, neg bool, half int) bool { return false } func roundUp(result *BigInt, neg bool, half int) bool { return true } func round05Up(result *BigInt, neg bool, half int) bool { var z BigInt z.Rem(result, bigFive) if z.Sign() == 0 { return true } z.Rem(result, bigTen) return z.Sign() == 0 } func roundHalfUp(result *BigInt, neg bool, half int) bool { return half >= 0 } func roundHalfEven(result *BigInt, neg bool, half int) bool { if half > 0 { return true } if half < 0 { return false } return result.Bit(0) == 1 } func roundHalfDown(result *BigInt, neg bool, half int) bool { return half > 0 } func roundFloor(result *BigInt, neg bool, half int) bool { return neg } func roundCeiling(result *BigInt, neg bool, half int) bool { return !neg } apd-3.2.1/sql_test.go000066400000000000000000000045461450022325000144500ustar00rootroot00000000000000// Copyright 2017 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. //go:build sql // +build sql package apd import ( "database/sql" "flag" "testing" _ "github.com/lib/pq" ) var ( flagPostgres = flag.String("postgres", "postgres://postgres@localhost/apd?sslmode=disable", "Postgres connection string to an empty database") ) // TestSQL tests the Scan and Value methods of Decimal. func TestSQL(t *testing.T) { db, err := sql.Open("postgres", *flagPostgres) if err != nil { t.Fatal(err) } var a Decimal if _, _, err = a.SetString("1234.567e5"); err != nil { t.Fatal(err) } if _, err := db.Exec("drop table if exists d"); err != nil { t.Fatal(err) } if _, err := db.Exec("create table d (v decimal)"); err != nil { t.Fatal(err) } if _, err := db.Exec("insert into d values ($1)", a); err != nil { t.Fatal(err) } if _, err := db.Exec("update d set v = v + 1e5"); err != nil { t.Fatal(err) } var b, c, d Decimal var nd NullDecimal if err := db.QueryRow("select v, v::text, v::int, v::float, v from d").Scan(&a, &b, &c, &d, &nd); err != nil { t.Fatal(err) } want, _, err := NewFromString("123556700") if err != nil { t.Fatal(err) } for i, v := range []*Decimal{&a, &b, &c, &d, &nd.Decimal} { if v.Cmp(want) != 0 { t.Fatalf("%d: unexpected: %s, want: %s", i, v.String(), want.String()) } } if _, err := db.Exec("update d set v = NULL"); err != nil { t.Fatal(err) } if err := db.QueryRow("select v from d").Scan(&nd); err != nil { t.Fatal(err) } if nd.Valid { t.Fatal("expected null") } var g Decimal if err := db.QueryRow("select 0::decimal(19,9)").Scan(&g); err != nil { t.Fatal(err) } zeroD, _, err := NewFromString("0.000000000") if err != nil { t.Fatal(err) } if g.String() != zeroD.String() { t.Fatalf("expected 0::decimal(19.9) pg value %s match, found %s", g.String(), zeroD.String()) } } apd-3.2.1/table.go000066400000000000000000000074111450022325000136730ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd // digitsLookupTable is used to map binary digit counts to their corresponding // decimal border values. The map relies on the proof that (without leading zeros) // for any given number of binary digits r, such that the number represented is // between 2^r and 2^(r+1)-1, there are only two possible decimal digit counts // k and k+1 that the binary r digits could be representing. // // Using this proof, for a given digit count, the map will return the lower number // of decimal digits (k) the binary digit count could represent, along with the // value of the border between the two decimal digit counts (10^k). const digitsTableSize = 128 var digitsLookupTable [digitsTableSize + 1]tableVal type tableVal struct { digits int64 border BigInt nborder BigInt } func init() { curVal := NewBigInt(1) curExp := new(BigInt) for i := 1; i <= digitsTableSize; i++ { if i > 1 { curVal.Lsh(curVal, 1) } elem := &digitsLookupTable[i] elem.digits = int64(len(curVal.String())) elem.border.SetInt64(10) curExp.SetInt64(elem.digits) elem.border.Exp(&elem.border, curExp, nil) elem.nborder.Neg(&elem.border) } } // NumDigits returns the number of decimal digits of d.Coeff. //gcassert:inline func (d *Decimal) NumDigits() int64 { return NumDigits(&d.Coeff) } // NumDigits returns the number of decimal digits of b. func NumDigits(b *BigInt) int64 { bl := b.BitLen() if bl == 0 { return 1 } if bl <= digitsTableSize { val := &digitsLookupTable[bl] // In general, we either have val.digits or val.digits+1 digits and we have // to compare with the border value. But that's not true for all values of // bl: in particular, if bl+1 maps to the same number of digits, then we // know for sure we have val.digits and we can skip the comparison. // This is the case for about 2 out of 3 values. if bl < digitsTableSize && digitsLookupTable[bl+1].digits == val.digits { return val.digits } switch b.Sign() { case 1: if b.Cmp(&val.border) < 0 { return val.digits } case -1: if b.Cmp(&val.nborder) > 0 { return val.digits } } return val.digits + 1 } n := int64(float64(bl) / digitsToBitsRatio) var tmp BigInt e := tableExp10(n, &tmp) var a *BigInt if b.Sign() < 0 { var tmpA BigInt a := &tmpA a.Abs(b) } else { a = b } if a.Cmp(e) >= 0 { n++ } return n } // powerTenTableSize is the magnitude of the maximum power of 10 exponent that // is stored in the pow10LookupTable. For instance, if the powerTenTableSize // if 3, then the lookup table will store power of 10 values from 10^0 to // 10^3 inclusive. const powerTenTableSize = 128 var pow10LookupTable [powerTenTableSize + 1]BigInt func init() { for i := int64(0); i <= powerTenTableSize; i++ { setBigWithPow(&pow10LookupTable[i], i) } } func setBigWithPow(res *BigInt, pow int64) { var tmp BigInt tmp.SetInt64(pow) res.Exp(bigTen, &tmp, nil) } // tableExp10 returns 10^x for x >= 0, looked up from a table when // possible. This returned value must not be mutated. tmp is used as an // intermediate variable and must not be nil. func tableExp10(x int64, tmp *BigInt) *BigInt { if x <= powerTenTableSize { return &pow10LookupTable[x] } setBigWithPow(tmp, x) return tmp } apd-3.2.1/table_test.go000066400000000000000000000104151450022325000147300ustar00rootroot00000000000000// Copyright 2016 The Cockroach Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. package apd import ( "bytes" "math/rand" "strings" "testing" ) func BenchmarkNumDigitsLookup(b *testing.B) { prep := func(start string, c byte) []*Decimal { var ds []*Decimal buf := bytes.NewBufferString(start) for i := 1; i < digitsTableSize; i++ { buf.WriteByte(c) d, _, _ := NewFromString(buf.String()) ds = append(ds, d) } return ds } var ds []*Decimal ds = append(ds, prep("", '9')...) ds = append(ds, prep("1", '0')...) ds = append(ds, prep("-", '9')...) ds = append(ds, prep("-1", '0')...) b.ResetTimer() for i := 0; i < b.N; i++ { for _, d := range ds { d.NumDigits() } } } func BenchmarkNumDigitsFull(b *testing.B) { prep := func(start string, c byte) []*Decimal { var ds []*Decimal buf := bytes.NewBufferString(start) for i := 1; i < 1000; i++ { buf.WriteByte(c) d, _, _ := NewFromString(buf.String()) ds = append(ds, d) } return ds } var ds []*Decimal ds = append(ds, prep("", '9')...) ds = append(ds, prep("1", '0')...) ds = append(ds, prep("-", '9')...) ds = append(ds, prep("-1", '0')...) b.ResetTimer() for i := 0; i < b.N; i++ { for _, d := range ds { d.NumDigits() } } } func TestNumDigits(t *testing.T) { runTest := func(start string, c byte) { buf := bytes.NewBufferString(start) var offset int if strings.HasPrefix(start, "-") { offset-- } for i := 1; i < 1000; i++ { buf.WriteByte(c) bs := buf.String() t.Run(bs, func(t *testing.T) { d := newDecimal(t, testCtx, bs) n := d.NumDigits() e := int64(buf.Len() + offset) if n != e { t.Fatalf("%s ('%c'): expected %d, got %d", bs, c, e, n) } }) } } runTest("", '9') runTest("1", '0') runTest("-", '9') runTest("-1", '0') } func TestDigitsLookupTable(t *testing.T) { // Make sure all elements in table make sense. min := new(BigInt) prevBorder := NewBigInt(0) for i := 1; i <= digitsTableSize; i++ { elem := &digitsLookupTable[i] min.SetInt64(2) min.Exp(min, NewBigInt(int64(i-1)), nil) if minLen := int64(len(min.String())); minLen != elem.digits { t.Errorf("expected 2^%d to have %d digits, found %d", i, elem.digits, minLen) } if zeros := int64(strings.Count(elem.border.String(), "0")); zeros != elem.digits { t.Errorf("the %d digits for digitsLookupTable[%d] does not agree with the border %v", elem.digits, i, &elem.border) } if min.Cmp(&elem.border) >= 0 { t.Errorf("expected 2^%d = %v to be less than the border, found %v", i-1, min, &elem.border) } if elem.border.Cmp(prevBorder) > 0 { if min.Cmp(prevBorder) <= 0 { t.Errorf("expected 2^%d = %v to be greater than or equal to the border, found %v", i-1, min, prevBorder) } prevBorder = &elem.border } } // Throw random big.Ints at the table and make sure the // digit lengths line up. const randomTrials = 100 for i := 0; i < randomTrials; i++ { a := NewBigInt(rand.Int63()) b := NewBigInt(rand.Int63()) a.Mul(a, b) d := NewWithBigInt(a, 0) tableDigits := d.NumDigits() if actualDigits := int64(len(a.String())); actualDigits != tableDigits { t.Errorf("expected %d digits for %v, found %d", tableDigits, a, actualDigits) } } } func TestTableExp10(t *testing.T) { tests := []struct { pow int64 str string }{ { pow: 0, str: "1", }, { pow: 1, str: "10", }, { pow: 5, str: "100000", }, { pow: powerTenTableSize + 1, str: "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", }, } for i, test := range tests { var tmpE BigInt d := tableExp10(test.pow, &tmpE) if s := d.String(); s != test.str { t.Errorf("%d: expected PowerOfTenDec(%d) to give %s, got %s", i, test.pow, test.str, s) } } } apd-3.2.1/testdata/000077500000000000000000000000001450022325000140635ustar00rootroot00000000000000apd-3.2.1/testdata/abs.decTest000066400000000000000000000143501450022325000161500ustar00rootroot00000000000000------------------------------------------------------------------------ -- abs.decTest -- decimal absolute value -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This set of tests primarily tests the existence of the operator. -- Additon, subtraction, rounding, and more overflows are tested -- elsewhere. precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 extended: 1 absx001 abs '1' -> '1' absx002 abs '-1' -> '1' absx003 abs '1.00' -> '1.00' absx004 abs '-1.00' -> '1.00' absx005 abs '0' -> '0' absx006 abs '0.00' -> '0.00' absx007 abs '00.0' -> '0.0' absx008 abs '00.00' -> '0.00' absx009 abs '00' -> '0' absx010 abs '-2' -> '2' absx011 abs '2' -> '2' absx012 abs '-2.00' -> '2.00' absx013 abs '2.00' -> '2.00' absx014 abs '-0' -> '0' absx015 abs '-0.00' -> '0.00' absx016 abs '-00.0' -> '0.0' absx017 abs '-00.00' -> '0.00' absx018 abs '-00' -> '0' absx020 abs '-2000000' -> '2000000' absx021 abs '2000000' -> '2000000' precision: 7 absx022 abs '-2000000' -> '2000000' absx023 abs '2000000' -> '2000000' precision: 6 absx024 abs '-2000000' -> '2.00000E+6' Rounded absx025 abs '2000000' -> '2.00000E+6' Rounded precision: 3 absx026 abs '-2000000' -> '2.00E+6' Rounded absx027 abs '2000000' -> '2.00E+6' Rounded absx030 abs '+0.1' -> '0.1' absx031 abs '-0.1' -> '0.1' absx032 abs '+0.01' -> '0.01' absx033 abs '-0.01' -> '0.01' absx034 abs '+0.001' -> '0.001' absx035 abs '-0.001' -> '0.001' absx036 abs '+0.000001' -> '0.000001' absx037 abs '-0.000001' -> '0.000001' absx038 abs '+0.000000000001' -> '1E-12' absx039 abs '-0.000000000001' -> '1E-12' -- examples from decArith precision: 9 absx040 abs '2.1' -> '2.1' absx041 abs '-100' -> '100' absx042 abs '101.5' -> '101.5' absx043 abs '-101.5' -> '101.5' -- more fixed, potential LHS swaps/overlays if done by subtract 0 precision: 9 absx060 abs '-56267E-10' -> '0.0000056267' absx061 abs '-56267E-5' -> '0.56267' absx062 abs '-56267E-2' -> '562.67' absx063 abs '-56267E-1' -> '5626.7' absx065 abs '-56267E-0' -> '56267' -- overflow tests maxexponent: 999999999 minexponent: -999999999 precision: 3 absx120 abs 9.999E+999999999 -> Infinity Inexact Overflow Rounded -- subnormals and underflow precision: 3 maxexponent: 999 minexponent: -999 absx210 abs 1.00E-999 -> 1.00E-999 absx211 abs 0.1E-999 -> 1E-1000 Subnormal absx212 abs 0.10E-999 -> 1.0E-1000 Subnormal absx213 abs 0.100E-999 -> 1.0E-1000 Subnormal Rounded absx214 abs 0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin absx215 abs 0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow absx216 abs 0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow absx217 abs 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow absx218 abs 0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped absx219 abs 0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped absx220 abs 0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped absx230 abs -1.00E-999 -> 1.00E-999 absx231 abs -0.1E-999 -> 1E-1000 Subnormal absx232 abs -0.10E-999 -> 1.0E-1000 Subnormal absx233 abs -0.100E-999 -> 1.0E-1000 Subnormal Rounded absx234 abs -0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin absx235 abs -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow absx236 abs -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow absx237 abs -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow absx238 abs -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped absx239 abs -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped absx240 abs -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped -- long operand tests maxexponent: 999 minexponent: -999 precision: 9 absx301 abs 12345678000 -> 1.23456780E+10 Rounded absx302 abs 1234567800 -> 1.23456780E+9 Rounded absx303 abs 1234567890 -> 1.23456789E+9 Rounded absx304 abs 1234567891 -> 1.23456789E+9 Inexact Rounded absx305 abs 12345678901 -> 1.23456789E+10 Inexact Rounded absx306 abs 1234567896 -> 1.23456790E+9 Inexact Rounded precision: 15 absx321 abs 12345678000 -> 12345678000 absx322 abs 1234567800 -> 1234567800 absx323 abs 1234567890 -> 1234567890 absx324 abs 1234567891 -> 1234567891 absx325 abs 12345678901 -> 12345678901 absx326 abs 1234567896 -> 1234567896 -- Specials precision: 9 -- specials absx520 abs 'Inf' -> 'Infinity' absx521 abs '-Inf' -> 'Infinity' absx522 abs NaN -> NaN absx523 abs sNaN -> NaN Invalid_operation absx524 abs NaN22 -> NaN22 absx525 abs sNaN33 -> NaN33 Invalid_operation absx526 abs -NaN22 -> -NaN22 absx527 abs -sNaN33 -> -NaN33 Invalid_operation -- Null tests absx900 abs # -> NaN Invalid_operation apd-3.2.1/testdata/add.decTest000066400000000000000000004272041450022325000161410ustar00rootroot00000000000000------/cancell---------------------------------------------------------- -- add.decTest -- decimal addition -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 extended: 1 -- [first group are 'quick confidence check'] addx001 add 1 1 -> 2 addx002 add 2 3 -> 5 addx003 add '5.75' '3.3' -> 9.05 addx004 add '5' '-3' -> 2 addx005 add '-5' '-3' -> -8 addx006 add '-7' '2.5' -> -4.5 addx007 add '0.7' '0.3' -> 1.0 addx008 add '1.25' '1.25' -> 2.50 addx009 add '1.23456789' '1.00000000' -> '2.23456789' addx010 add '1.23456789' '1.00000011' -> '2.23456800' addx011 add '0.4444444444' '0.5555555555' -> '1.00000000' Inexact Rounded addx012 add '0.4444444440' '0.5555555555' -> '1.00000000' Inexact Rounded addx013 add '0.4444444444' '0.5555555550' -> '0.999999999' Inexact Rounded addx014 add '0.44444444449' '0' -> '0.444444444' Inexact Rounded addx015 add '0.444444444499' '0' -> '0.444444444' Inexact Rounded addx016 add '0.4444444444999' '0' -> '0.444444444' Inexact Rounded addx017 add '0.4444444445000' '0' -> '0.444444445' Inexact Rounded addx018 add '0.4444444445001' '0' -> '0.444444445' Inexact Rounded addx019 add '0.444444444501' '0' -> '0.444444445' Inexact Rounded addx020 add '0.44444444451' '0' -> '0.444444445' Inexact Rounded addx021 add 0 1 -> 1 addx022 add 1 1 -> 2 addx023 add 2 1 -> 3 addx024 add 3 1 -> 4 addx025 add 4 1 -> 5 addx026 add 5 1 -> 6 addx027 add 6 1 -> 7 addx028 add 7 1 -> 8 addx029 add 8 1 -> 9 addx030 add 9 1 -> 10 -- some carrying effects addx031 add '0.9998' '0.0000' -> '0.9998' addx032 add '0.9998' '0.0001' -> '0.9999' addx033 add '0.9998' '0.0002' -> '1.0000' addx034 add '0.9998' '0.0003' -> '1.0001' addx035 add '70' '10000e+9' -> '1.00000000E+13' Inexact Rounded addx036 add '700' '10000e+9' -> '1.00000000E+13' Inexact Rounded addx037 add '7000' '10000e+9' -> '1.00000000E+13' Inexact Rounded addx038 add '70000' '10000e+9' -> '1.00000001E+13' Inexact Rounded addx039 add '700000' '10000e+9' -> '1.00000007E+13' Rounded -- symmetry: addx040 add '10000e+9' '70' -> '1.00000000E+13' Inexact Rounded addx041 add '10000e+9' '700' -> '1.00000000E+13' Inexact Rounded addx042 add '10000e+9' '7000' -> '1.00000000E+13' Inexact Rounded addx044 add '10000e+9' '70000' -> '1.00000001E+13' Inexact Rounded addx045 add '10000e+9' '700000' -> '1.00000007E+13' Rounded -- same, higher precision precision: 15 addx046 add '10000e+9' '7' -> '10000000000007' addx047 add '10000e+9' '70' -> '10000000000070' addx048 add '10000e+9' '700' -> '10000000000700' addx049 add '10000e+9' '7000' -> '10000000007000' addx050 add '10000e+9' '70000' -> '10000000070000' addx051 add '10000e+9' '700000' -> '10000000700000' addx052 add '10000e+9' '7000000' -> '10000007000000' -- examples from decarith addx053 add '12' '7.00' -> '19.00' addx054 add '1.3' '-1.07' -> '0.23' addx055 add '1.3' '-1.30' -> '0.00' addx056 add '1.3' '-2.07' -> '-0.77' addx057 add '1E+2' '1E+4' -> '1.01E+4' -- zero preservation precision: 6 addx060 add '10000e+9' '70000' -> '1.00000E+13' Inexact Rounded addx061 add 1 '0.0001' -> '1.0001' addx062 add 1 '0.00001' -> '1.00001' addx063 add 1 '0.000001' -> '1.00000' Inexact Rounded addx064 add 1 '0.0000001' -> '1.00000' Inexact Rounded addx065 add 1 '0.00000001' -> '1.00000' Inexact Rounded -- some funny zeros [in case of bad signum] addx070 add 1 0 -> 1 addx071 add 1 0. -> 1 addx072 add 1 .0 -> 1.0 addx073 add 1 0.0 -> 1.0 addx074 add 1 0.00 -> 1.00 addx075 add 0 1 -> 1 addx076 add 0. 1 -> 1 addx077 add .0 1 -> 1.0 addx078 add 0.0 1 -> 1.0 addx079 add 0.00 1 -> 1.00 precision: 9 -- some carries addx080 add 999999998 1 -> 999999999 addx081 add 999999999 1 -> 1.00000000E+9 Rounded addx082 add 99999999 1 -> 100000000 addx083 add 9999999 1 -> 10000000 addx084 add 999999 1 -> 1000000 addx085 add 99999 1 -> 100000 addx086 add 9999 1 -> 10000 addx087 add 999 1 -> 1000 addx088 add 99 1 -> 100 addx089 add 9 1 -> 10 -- more LHS swaps addx090 add '-56267E-10' 0 -> '-0.0000056267' addx091 add '-56267E-6' 0 -> '-0.056267' addx092 add '-56267E-5' 0 -> '-0.56267' addx093 add '-56267E-4' 0 -> '-5.6267' addx094 add '-56267E-3' 0 -> '-56.267' addx095 add '-56267E-2' 0 -> '-562.67' addx096 add '-56267E-1' 0 -> '-5626.7' addx097 add '-56267E-0' 0 -> '-56267' addx098 add '-5E-10' 0 -> '-5E-10' addx099 add '-5E-7' 0 -> '-5E-7' addx100 add '-5E-6' 0 -> '-0.000005' addx101 add '-5E-5' 0 -> '-0.00005' addx102 add '-5E-4' 0 -> '-0.0005' addx103 add '-5E-1' 0 -> '-0.5' addx104 add '-5E0' 0 -> '-5' addx105 add '-5E1' 0 -> '-50' addx106 add '-5E5' 0 -> '-500000' addx107 add '-5E8' 0 -> '-500000000' addx108 add '-5E9' 0 -> '-5.00000000E+9' Rounded addx109 add '-5E10' 0 -> '-5.00000000E+10' Rounded addx110 add '-5E11' 0 -> '-5.00000000E+11' Rounded addx111 add '-5E100' 0 -> '-5.00000000E+100' Rounded -- more RHS swaps addx113 add 0 '-56267E-10' -> '-0.0000056267' addx114 add 0 '-56267E-6' -> '-0.056267' addx116 add 0 '-56267E-5' -> '-0.56267' addx117 add 0 '-56267E-4' -> '-5.6267' addx119 add 0 '-56267E-3' -> '-56.267' addx120 add 0 '-56267E-2' -> '-562.67' addx121 add 0 '-56267E-1' -> '-5626.7' addx122 add 0 '-56267E-0' -> '-56267' addx123 add 0 '-5E-10' -> '-5E-10' addx124 add 0 '-5E-7' -> '-5E-7' addx125 add 0 '-5E-6' -> '-0.000005' addx126 add 0 '-5E-5' -> '-0.00005' addx127 add 0 '-5E-4' -> '-0.0005' addx128 add 0 '-5E-1' -> '-0.5' addx129 add 0 '-5E0' -> '-5' addx130 add 0 '-5E1' -> '-50' addx131 add 0 '-5E5' -> '-500000' addx132 add 0 '-5E8' -> '-500000000' addx133 add 0 '-5E9' -> '-5.00000000E+9' Rounded addx134 add 0 '-5E10' -> '-5.00000000E+10' Rounded addx135 add 0 '-5E11' -> '-5.00000000E+11' Rounded addx136 add 0 '-5E100' -> '-5.00000000E+100' Rounded -- related addx137 add 1 '0E-12' -> '1.00000000' Rounded addx138 add -1 '0E-12' -> '-1.00000000' Rounded addx139 add '0E-12' 1 -> '1.00000000' Rounded addx140 add '0E-12' -1 -> '-1.00000000' Rounded addx141 add 1E+4 0.0000 -> '10000.0000' addx142 add 1E+4 0.00000 -> '10000.0000' Rounded addx143 add 0.000 1E+5 -> '100000.000' addx144 add 0.0000 1E+5 -> '100000.000' Rounded -- [some of the next group are really constructor tests] addx146 add '00.0' 0 -> '0.0' addx147 add '0.00' 0 -> '0.00' addx148 add 0 '0.00' -> '0.00' addx149 add 0 '00.0' -> '0.0' addx150 add '00.0' '0.00' -> '0.00' addx151 add '0.00' '00.0' -> '0.00' addx152 add '3' '.3' -> '3.3' addx153 add '3.' '.3' -> '3.3' addx154 add '3.0' '.3' -> '3.3' addx155 add '3.00' '.3' -> '3.30' addx156 add '3' '3' -> '6' addx157 add '3' '+3' -> '6' addx158 add '3' '-3' -> '0' addx159 add '0.3' '-0.3' -> '0.0' addx160 add '0.03' '-0.03' -> '0.00' -- try borderline precision, with carries, etc. precision: 15 addx161 add '1E+12' '-1' -> '999999999999' addx162 add '1E+12' '1.11' -> '1000000000001.11' addx163 add '1.11' '1E+12' -> '1000000000001.11' addx164 add '-1' '1E+12' -> '999999999999' addx165 add '7E+12' '-1' -> '6999999999999' addx166 add '7E+12' '1.11' -> '7000000000001.11' addx167 add '1.11' '7E+12' -> '7000000000001.11' addx168 add '-1' '7E+12' -> '6999999999999' -- 123456789012345 123456789012345 1 23456789012345 addx170 add '0.444444444444444' '0.555555555555563' -> '1.00000000000001' Inexact Rounded addx171 add '0.444444444444444' '0.555555555555562' -> '1.00000000000001' Inexact Rounded addx172 add '0.444444444444444' '0.555555555555561' -> '1.00000000000001' Inexact Rounded addx173 add '0.444444444444444' '0.555555555555560' -> '1.00000000000000' Inexact Rounded addx174 add '0.444444444444444' '0.555555555555559' -> '1.00000000000000' Inexact Rounded addx175 add '0.444444444444444' '0.555555555555558' -> '1.00000000000000' Inexact Rounded addx176 add '0.444444444444444' '0.555555555555557' -> '1.00000000000000' Inexact Rounded addx177 add '0.444444444444444' '0.555555555555556' -> '1.00000000000000' Rounded addx178 add '0.444444444444444' '0.555555555555555' -> '0.999999999999999' addx179 add '0.444444444444444' '0.555555555555554' -> '0.999999999999998' addx180 add '0.444444444444444' '0.555555555555553' -> '0.999999999999997' addx181 add '0.444444444444444' '0.555555555555552' -> '0.999999999999996' addx182 add '0.444444444444444' '0.555555555555551' -> '0.999999999999995' addx183 add '0.444444444444444' '0.555555555555550' -> '0.999999999999994' -- and some more, including residue effects and different roundings precision: 9 rounding: half_up addx200 add '123456789' 0 -> '123456789' addx201 add '123456789' 0.000000001 -> '123456789' Inexact Rounded addx202 add '123456789' 0.000001 -> '123456789' Inexact Rounded addx203 add '123456789' 0.1 -> '123456789' Inexact Rounded addx204 add '123456789' 0.4 -> '123456789' Inexact Rounded addx205 add '123456789' 0.49 -> '123456789' Inexact Rounded addx206 add '123456789' 0.499999 -> '123456789' Inexact Rounded addx207 add '123456789' 0.499999999 -> '123456789' Inexact Rounded addx208 add '123456789' 0.5 -> '123456790' Inexact Rounded addx209 add '123456789' 0.500000001 -> '123456790' Inexact Rounded addx210 add '123456789' 0.500001 -> '123456790' Inexact Rounded addx211 add '123456789' 0.51 -> '123456790' Inexact Rounded addx212 add '123456789' 0.6 -> '123456790' Inexact Rounded addx213 add '123456789' 0.9 -> '123456790' Inexact Rounded addx214 add '123456789' 0.99999 -> '123456790' Inexact Rounded addx215 add '123456789' 0.999999999 -> '123456790' Inexact Rounded addx216 add '123456789' 1 -> '123456790' addx217 add '123456789' 1.000000001 -> '123456790' Inexact Rounded addx218 add '123456789' 1.00001 -> '123456790' Inexact Rounded addx219 add '123456789' 1.1 -> '123456790' Inexact Rounded rounding: half_even addx220 add '123456789' 0 -> '123456789' addx221 add '123456789' 0.000000001 -> '123456789' Inexact Rounded addx222 add '123456789' 0.000001 -> '123456789' Inexact Rounded addx223 add '123456789' 0.1 -> '123456789' Inexact Rounded addx224 add '123456789' 0.4 -> '123456789' Inexact Rounded addx225 add '123456789' 0.49 -> '123456789' Inexact Rounded addx226 add '123456789' 0.499999 -> '123456789' Inexact Rounded addx227 add '123456789' 0.499999999 -> '123456789' Inexact Rounded addx228 add '123456789' 0.5 -> '123456790' Inexact Rounded addx229 add '123456789' 0.500000001 -> '123456790' Inexact Rounded addx230 add '123456789' 0.500001 -> '123456790' Inexact Rounded addx231 add '123456789' 0.51 -> '123456790' Inexact Rounded addx232 add '123456789' 0.6 -> '123456790' Inexact Rounded addx233 add '123456789' 0.9 -> '123456790' Inexact Rounded addx234 add '123456789' 0.99999 -> '123456790' Inexact Rounded addx235 add '123456789' 0.999999999 -> '123456790' Inexact Rounded addx236 add '123456789' 1 -> '123456790' addx237 add '123456789' 1.00000001 -> '123456790' Inexact Rounded addx238 add '123456789' 1.00001 -> '123456790' Inexact Rounded addx239 add '123456789' 1.1 -> '123456790' Inexact Rounded -- critical few with even bottom digit... addx240 add '123456788' 0.499999999 -> '123456788' Inexact Rounded addx241 add '123456788' 0.5 -> '123456788' Inexact Rounded addx242 add '123456788' 0.500000001 -> '123456789' Inexact Rounded rounding: down addx250 add '123456789' 0 -> '123456789' addx251 add '123456789' 0.000000001 -> '123456789' Inexact Rounded addx252 add '123456789' 0.000001 -> '123456789' Inexact Rounded addx253 add '123456789' 0.1 -> '123456789' Inexact Rounded addx254 add '123456789' 0.4 -> '123456789' Inexact Rounded addx255 add '123456789' 0.49 -> '123456789' Inexact Rounded addx256 add '123456789' 0.499999 -> '123456789' Inexact Rounded addx257 add '123456789' 0.499999999 -> '123456789' Inexact Rounded addx258 add '123456789' 0.5 -> '123456789' Inexact Rounded addx259 add '123456789' 0.500000001 -> '123456789' Inexact Rounded addx260 add '123456789' 0.500001 -> '123456789' Inexact Rounded addx261 add '123456789' 0.51 -> '123456789' Inexact Rounded addx262 add '123456789' 0.6 -> '123456789' Inexact Rounded addx263 add '123456789' 0.9 -> '123456789' Inexact Rounded addx264 add '123456789' 0.99999 -> '123456789' Inexact Rounded addx265 add '123456789' 0.999999999 -> '123456789' Inexact Rounded addx266 add '123456789' 1 -> '123456790' addx267 add '123456789' 1.00000001 -> '123456790' Inexact Rounded addx268 add '123456789' 1.00001 -> '123456790' Inexact Rounded addx269 add '123456789' 1.1 -> '123456790' Inexact Rounded -- input preparation tests (operands should not be rounded) precision: 3 rounding: half_up addx270 add '12345678900000' 9999999999999 -> '2.23E+13' Inexact Rounded addx271 add '9999999999999' 12345678900000 -> '2.23E+13' Inexact Rounded addx272 add '12E+3' '3444' -> '1.54E+4' Inexact Rounded addx273 add '12E+3' '3446' -> '1.54E+4' Inexact Rounded addx274 add '12E+3' '3449.9' -> '1.54E+4' Inexact Rounded addx275 add '12E+3' '3450.0' -> '1.55E+4' Inexact Rounded addx276 add '12E+3' '3450.1' -> '1.55E+4' Inexact Rounded addx277 add '12E+3' '3454' -> '1.55E+4' Inexact Rounded addx278 add '12E+3' '3456' -> '1.55E+4' Inexact Rounded addx281 add '3444' '12E+3' -> '1.54E+4' Inexact Rounded addx282 add '3446' '12E+3' -> '1.54E+4' Inexact Rounded addx283 add '3449.9' '12E+3' -> '1.54E+4' Inexact Rounded addx284 add '3450.0' '12E+3' -> '1.55E+4' Inexact Rounded addx285 add '3450.1' '12E+3' -> '1.55E+4' Inexact Rounded addx286 add '3454' '12E+3' -> '1.55E+4' Inexact Rounded addx287 add '3456' '12E+3' -> '1.55E+4' Inexact Rounded rounding: half_down addx291 add '3444' '12E+3' -> '1.54E+4' Inexact Rounded addx292 add '3446' '12E+3' -> '1.54E+4' Inexact Rounded addx293 add '3449.9' '12E+3' -> '1.54E+4' Inexact Rounded addx294 add '3450.0' '12E+3' -> '1.54E+4' Inexact Rounded addx295 add '3450.1' '12E+3' -> '1.55E+4' Inexact Rounded addx296 add '3454' '12E+3' -> '1.55E+4' Inexact Rounded addx297 add '3456' '12E+3' -> '1.55E+4' Inexact Rounded -- 1 in last place tests rounding: half_up addx301 add -1 1 -> 0 addx302 add 0 1 -> 1 addx303 add 1 1 -> 2 addx304 add 12 1 -> 13 addx305 add 98 1 -> 99 addx306 add 99 1 -> 100 addx307 add 100 1 -> 101 addx308 add 101 1 -> 102 addx309 add -1 -1 -> -2 addx310 add 0 -1 -> -1 addx311 add 1 -1 -> 0 addx312 add 12 -1 -> 11 addx313 add 98 -1 -> 97 addx314 add 99 -1 -> 98 addx315 add 100 -1 -> 99 addx316 add 101 -1 -> 100 addx321 add -0.01 0.01 -> 0.00 addx322 add 0.00 0.01 -> 0.01 addx323 add 0.01 0.01 -> 0.02 addx324 add 0.12 0.01 -> 0.13 addx325 add 0.98 0.01 -> 0.99 addx326 add 0.99 0.01 -> 1.00 addx327 add 1.00 0.01 -> 1.01 addx328 add 1.01 0.01 -> 1.02 addx329 add -0.01 -0.01 -> -0.02 addx330 add 0.00 -0.01 -> -0.01 addx331 add 0.01 -0.01 -> 0.00 addx332 add 0.12 -0.01 -> 0.11 addx333 add 0.98 -0.01 -> 0.97 addx334 add 0.99 -0.01 -> 0.98 addx335 add 1.00 -0.01 -> 0.99 addx336 add 1.01 -0.01 -> 1.00 -- some more cases where adding 0 affects the coefficient precision: 9 addx340 add 1E+3 0 -> 1000 addx341 add 1E+8 0 -> 100000000 addx342 add 1E+9 0 -> 1.00000000E+9 Rounded addx343 add 1E+10 0 -> 1.00000000E+10 Rounded -- which simply follow from these cases ... addx344 add 1E+3 1 -> 1001 addx345 add 1E+8 1 -> 100000001 addx346 add 1E+9 1 -> 1.00000000E+9 Inexact Rounded addx347 add 1E+10 1 -> 1.00000000E+10 Inexact Rounded addx348 add 1E+3 7 -> 1007 addx349 add 1E+8 7 -> 100000007 addx350 add 1E+9 7 -> 1.00000001E+9 Inexact Rounded addx351 add 1E+10 7 -> 1.00000000E+10 Inexact Rounded -- tryzeros cases precision: 7 rounding: half_up maxExponent: 92 minexponent: -92 addx361 add 0E+50 10000E+1 -> 1.0000E+5 addx362 add 10000E+1 0E-50 -> 100000.0 Rounded addx363 add 10000E+1 10000E-50 -> 100000.0 Rounded Inexact addx364 add 9.999999E+92 -9.999999E+92 -> 0E+86 -- a curiosity from JSR 13 testing rounding: half_down precision: 10 addx370 add 99999999 81512 -> 100081511 precision: 6 addx371 add 99999999 81512 -> 1.00082E+8 Rounded Inexact rounding: half_up precision: 10 addx372 add 99999999 81512 -> 100081511 precision: 6 addx373 add 99999999 81512 -> 1.00082E+8 Rounded Inexact rounding: half_even precision: 10 addx374 add 99999999 81512 -> 100081511 precision: 6 addx375 add 99999999 81512 -> 1.00082E+8 Rounded Inexact -- ulp replacement tests precision: 9 maxexponent: 999999999 minexponent: -999999999 addx400 add 1 77e-7 -> 1.0000077 addx401 add 1 77e-8 -> 1.00000077 addx402 add 1 77e-9 -> 1.00000008 Inexact Rounded addx403 add 1 77e-10 -> 1.00000001 Inexact Rounded addx404 add 1 77e-11 -> 1.00000000 Inexact Rounded addx405 add 1 77e-12 -> 1.00000000 Inexact Rounded addx406 add 1 77e-999 -> 1.00000000 Inexact Rounded addx407 add 1 77e-9999999 -> 1.00000000 Inexact Rounded addx410 add 10 77e-7 -> 10.0000077 addx411 add 10 77e-8 -> 10.0000008 Inexact Rounded addx412 add 10 77e-9 -> 10.0000001 Inexact Rounded addx413 add 10 77e-10 -> 10.0000000 Inexact Rounded addx414 add 10 77e-11 -> 10.0000000 Inexact Rounded addx415 add 10 77e-12 -> 10.0000000 Inexact Rounded addx416 add 10 77e-999 -> 10.0000000 Inexact Rounded addx417 add 10 77e-9999999 -> 10.0000000 Inexact Rounded addx420 add 77e-7 1 -> 1.0000077 addx421 add 77e-8 1 -> 1.00000077 addx422 add 77e-9 1 -> 1.00000008 Inexact Rounded addx423 add 77e-10 1 -> 1.00000001 Inexact Rounded addx424 add 77e-11 1 -> 1.00000000 Inexact Rounded addx425 add 77e-12 1 -> 1.00000000 Inexact Rounded addx426 add 77e-999 1 -> 1.00000000 Inexact Rounded addx427 add 77e-9999999 1 -> 1.00000000 Inexact Rounded addx430 add 77e-7 10 -> 10.0000077 addx431 add 77e-8 10 -> 10.0000008 Inexact Rounded addx432 add 77e-9 10 -> 10.0000001 Inexact Rounded addx433 add 77e-10 10 -> 10.0000000 Inexact Rounded addx434 add 77e-11 10 -> 10.0000000 Inexact Rounded addx435 add 77e-12 10 -> 10.0000000 Inexact Rounded addx436 add 77e-999 10 -> 10.0000000 Inexact Rounded addx437 add 77e-9999999 10 -> 10.0000000 Inexact Rounded -- negative ulps addx440 add 1 -77e-7 -> 0.9999923 addx441 add 1 -77e-8 -> 0.99999923 addx442 add 1 -77e-9 -> 0.999999923 addx443 add 1 -77e-10 -> 0.999999992 Inexact Rounded addx444 add 1 -77e-11 -> 0.999999999 Inexact Rounded addx445 add 1 -77e-12 -> 1.00000000 Inexact Rounded addx446 add 1 -77e-999 -> 1.00000000 Inexact Rounded addx447 add 1 -77e-9999999 -> 1.00000000 Inexact Rounded addx450 add 10 -77e-7 -> 9.9999923 addx451 add 10 -77e-8 -> 9.99999923 addx452 add 10 -77e-9 -> 9.99999992 Inexact Rounded addx453 add 10 -77e-10 -> 9.99999999 Inexact Rounded addx454 add 10 -77e-11 -> 10.0000000 Inexact Rounded addx455 add 10 -77e-12 -> 10.0000000 Inexact Rounded addx456 add 10 -77e-999 -> 10.0000000 Inexact Rounded addx457 add 10 -77e-9999999 -> 10.0000000 Inexact Rounded addx460 add -77e-7 1 -> 0.9999923 addx461 add -77e-8 1 -> 0.99999923 addx462 add -77e-9 1 -> 0.999999923 addx463 add -77e-10 1 -> 0.999999992 Inexact Rounded addx464 add -77e-11 1 -> 0.999999999 Inexact Rounded addx465 add -77e-12 1 -> 1.00000000 Inexact Rounded addx466 add -77e-999 1 -> 1.00000000 Inexact Rounded addx467 add -77e-9999999 1 -> 1.00000000 Inexact Rounded addx470 add -77e-7 10 -> 9.9999923 addx471 add -77e-8 10 -> 9.99999923 addx472 add -77e-9 10 -> 9.99999992 Inexact Rounded addx473 add -77e-10 10 -> 9.99999999 Inexact Rounded addx474 add -77e-11 10 -> 10.0000000 Inexact Rounded addx475 add -77e-12 10 -> 10.0000000 Inexact Rounded addx476 add -77e-999 10 -> 10.0000000 Inexact Rounded addx477 add -77e-9999999 10 -> 10.0000000 Inexact Rounded -- negative ulps addx480 add -1 77e-7 -> -0.9999923 addx481 add -1 77e-8 -> -0.99999923 addx482 add -1 77e-9 -> -0.999999923 addx483 add -1 77e-10 -> -0.999999992 Inexact Rounded addx484 add -1 77e-11 -> -0.999999999 Inexact Rounded addx485 add -1 77e-12 -> -1.00000000 Inexact Rounded addx486 add -1 77e-999 -> -1.00000000 Inexact Rounded addx487 add -1 77e-9999999 -> -1.00000000 Inexact Rounded addx490 add -10 77e-7 -> -9.9999923 addx491 add -10 77e-8 -> -9.99999923 addx492 add -10 77e-9 -> -9.99999992 Inexact Rounded addx493 add -10 77e-10 -> -9.99999999 Inexact Rounded addx494 add -10 77e-11 -> -10.0000000 Inexact Rounded addx495 add -10 77e-12 -> -10.0000000 Inexact Rounded addx496 add -10 77e-999 -> -10.0000000 Inexact Rounded addx497 add -10 77e-9999999 -> -10.0000000 Inexact Rounded addx500 add 77e-7 -1 -> -0.9999923 addx501 add 77e-8 -1 -> -0.99999923 addx502 add 77e-9 -1 -> -0.999999923 addx503 add 77e-10 -1 -> -0.999999992 Inexact Rounded addx504 add 77e-11 -1 -> -0.999999999 Inexact Rounded addx505 add 77e-12 -1 -> -1.00000000 Inexact Rounded addx506 add 77e-999 -1 -> -1.00000000 Inexact Rounded addx507 add 77e-9999999 -1 -> -1.00000000 Inexact Rounded addx510 add 77e-7 -10 -> -9.9999923 addx511 add 77e-8 -10 -> -9.99999923 addx512 add 77e-9 -10 -> -9.99999992 Inexact Rounded addx513 add 77e-10 -10 -> -9.99999999 Inexact Rounded addx514 add 77e-11 -10 -> -10.0000000 Inexact Rounded addx515 add 77e-12 -10 -> -10.0000000 Inexact Rounded addx516 add 77e-999 -10 -> -10.0000000 Inexact Rounded addx517 add 77e-9999999 -10 -> -10.0000000 Inexact Rounded -- long operands maxexponent: 999 minexponent: -999 precision: 9 addx521 add 12345678000 0 -> 1.23456780E+10 Rounded addx522 add 0 12345678000 -> 1.23456780E+10 Rounded addx523 add 1234567800 0 -> 1.23456780E+9 Rounded addx524 add 0 1234567800 -> 1.23456780E+9 Rounded addx525 add 1234567890 0 -> 1.23456789E+9 Rounded addx526 add 0 1234567890 -> 1.23456789E+9 Rounded addx527 add 1234567891 0 -> 1.23456789E+9 Inexact Rounded addx528 add 0 1234567891 -> 1.23456789E+9 Inexact Rounded addx529 add 12345678901 0 -> 1.23456789E+10 Inexact Rounded addx530 add 0 12345678901 -> 1.23456789E+10 Inexact Rounded addx531 add 1234567896 0 -> 1.23456790E+9 Inexact Rounded addx532 add 0 1234567896 -> 1.23456790E+9 Inexact Rounded precision: 15 -- still checking addx541 add 12345678000 0 -> 12345678000 addx542 add 0 12345678000 -> 12345678000 addx543 add 1234567800 0 -> 1234567800 addx544 add 0 1234567800 -> 1234567800 addx545 add 1234567890 0 -> 1234567890 addx546 add 0 1234567890 -> 1234567890 addx547 add 1234567891 0 -> 1234567891 addx548 add 0 1234567891 -> 1234567891 addx549 add 12345678901 0 -> 12345678901 addx550 add 0 12345678901 -> 12345678901 addx551 add 1234567896 0 -> 1234567896 addx552 add 0 1234567896 -> 1234567896 -- verify a query precision: 16 maxExponent: +394 minExponent: -393 rounding: down addx561 add 1e-398 9.000000000000000E+384 -> 9.000000000000000E+384 Inexact Rounded addx562 add 0 9.000000000000000E+384 -> 9.000000000000000E+384 Rounded -- and using decimal64 bounds (see also ddadd.decTest) precision: 16 maxExponent: +384 minExponent: -383 rounding: down addx563 add 1e-388 9.000000000000000E+374 -> 9.000000000000000E+374 Inexact Rounded addx564 add 0 9.000000000000000E+374 -> 9.000000000000000E+374 Rounded -- some more residue effects with extreme rounding precision: 9 rounding: half_up addx601 add 123456789 0.000001 -> 123456789 Inexact Rounded rounding: half_even addx602 add 123456789 0.000001 -> 123456789 Inexact Rounded rounding: half_down addx603 add 123456789 0.000001 -> 123456789 Inexact Rounded rounding: floor addx604 add 123456789 0.000001 -> 123456789 Inexact Rounded rounding: ceiling addx605 add 123456789 0.000001 -> 123456790 Inexact Rounded rounding: up addx606 add 123456789 0.000001 -> 123456790 Inexact Rounded rounding: down addx607 add 123456789 0.000001 -> 123456789 Inexact Rounded rounding: half_up addx611 add 123456789 -0.000001 -> 123456789 Inexact Rounded rounding: half_even addx612 add 123456789 -0.000001 -> 123456789 Inexact Rounded rounding: half_down addx613 add 123456789 -0.000001 -> 123456789 Inexact Rounded rounding: floor addx614 add 123456789 -0.000001 -> 123456788 Inexact Rounded rounding: ceiling addx615 add 123456789 -0.000001 -> 123456789 Inexact Rounded rounding: up addx616 add 123456789 -0.000001 -> 123456789 Inexact Rounded rounding: down addx617 add 123456789 -0.000001 -> 123456788 Inexact Rounded rounding: half_up addx621 add 123456789 0.499999 -> 123456789 Inexact Rounded rounding: half_even addx622 add 123456789 0.499999 -> 123456789 Inexact Rounded rounding: half_down addx623 add 123456789 0.499999 -> 123456789 Inexact Rounded rounding: floor addx624 add 123456789 0.499999 -> 123456789 Inexact Rounded rounding: ceiling addx625 add 123456789 0.499999 -> 123456790 Inexact Rounded rounding: up addx626 add 123456789 0.499999 -> 123456790 Inexact Rounded rounding: down addx627 add 123456789 0.499999 -> 123456789 Inexact Rounded rounding: half_up addx631 add 123456789 -0.499999 -> 123456789 Inexact Rounded rounding: half_even addx632 add 123456789 -0.499999 -> 123456789 Inexact Rounded rounding: half_down addx633 add 123456789 -0.499999 -> 123456789 Inexact Rounded rounding: floor addx634 add 123456789 -0.499999 -> 123456788 Inexact Rounded rounding: ceiling addx635 add 123456789 -0.499999 -> 123456789 Inexact Rounded rounding: up addx636 add 123456789 -0.499999 -> 123456789 Inexact Rounded rounding: down addx637 add 123456789 -0.499999 -> 123456788 Inexact Rounded rounding: half_up addx641 add 123456789 0.500001 -> 123456790 Inexact Rounded rounding: half_even addx642 add 123456789 0.500001 -> 123456790 Inexact Rounded rounding: half_down addx643 add 123456789 0.500001 -> 123456790 Inexact Rounded rounding: floor addx644 add 123456789 0.500001 -> 123456789 Inexact Rounded rounding: ceiling addx645 add 123456789 0.500001 -> 123456790 Inexact Rounded rounding: up addx646 add 123456789 0.500001 -> 123456790 Inexact Rounded rounding: down addx647 add 123456789 0.500001 -> 123456789 Inexact Rounded rounding: half_up addx651 add 123456789 -0.500001 -> 123456788 Inexact Rounded rounding: half_even addx652 add 123456789 -0.500001 -> 123456788 Inexact Rounded rounding: half_down addx653 add 123456789 -0.500001 -> 123456788 Inexact Rounded rounding: floor addx654 add 123456789 -0.500001 -> 123456788 Inexact Rounded rounding: ceiling addx655 add 123456789 -0.500001 -> 123456789 Inexact Rounded rounding: up addx656 add 123456789 -0.500001 -> 123456789 Inexact Rounded rounding: down addx657 add 123456789 -0.500001 -> 123456788 Inexact Rounded -- long operand triangle rounding: half_up precision: 37 addx660 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023638922337114834538 precision: 36 addx661 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102363892233711483454 Inexact Rounded precision: 35 addx662 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236389223371148345 Inexact Rounded precision: 34 addx663 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023638922337114835 Inexact Rounded precision: 33 addx664 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102363892233711483 Inexact Rounded precision: 32 addx665 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236389223371148 Inexact Rounded precision: 31 addx666 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023638922337115 Inexact Rounded precision: 30 addx667 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102363892233711 Inexact Rounded precision: 29 addx668 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236389223371 Inexact Rounded precision: 28 addx669 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023638922337 Inexact Rounded precision: 27 addx670 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102363892234 Inexact Rounded precision: 26 addx671 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236389223 Inexact Rounded precision: 25 addx672 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023638922 Inexact Rounded precision: 24 addx673 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102363892 Inexact Rounded precision: 23 addx674 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236389 Inexact Rounded precision: 22 addx675 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211023639 Inexact Rounded precision: 21 addx676 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102364 Inexact Rounded precision: 20 addx677 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110236 Inexact Rounded precision: 19 addx678 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211024 Inexact Rounded precision: 18 addx679 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221102 Inexact Rounded precision: 17 addx680 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422110 Inexact Rounded precision: 16 addx681 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42211 Inexact Rounded precision: 15 addx682 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4221 Inexact Rounded precision: 14 addx683 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.422 Inexact Rounded precision: 13 addx684 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.42 Inexact Rounded precision: 12 addx685 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166.4 Inexact Rounded precision: 11 addx686 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 98471174166 Inexact Rounded precision: 10 addx687 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.847117417E+10 Inexact Rounded precision: 9 addx688 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.84711742E+10 Inexact Rounded precision: 8 addx689 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.8471174E+10 Inexact Rounded precision: 7 addx690 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.847117E+10 Inexact Rounded precision: 6 addx691 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.84712E+10 Inexact Rounded precision: 5 addx692 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.8471E+10 Inexact Rounded precision: 4 addx693 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.847E+10 Inexact Rounded precision: 3 addx694 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.85E+10 Inexact Rounded precision: 2 addx695 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 9.8E+10 Inexact Rounded precision: 1 addx696 add 98471198160.56524417578665886060 -23994.14313393939743548945165462 -> 1E+11 Inexact Rounded -- more zeros, etc. rounding: half_up precision: 9 addx701 add 5.00 1.00E-3 -> 5.00100 addx702 add 00.00 0.000 -> 0.000 addx703 add 00.00 0E-3 -> 0.000 addx704 add 0E-3 00.00 -> 0.000 addx710 add 0E+3 00.00 -> 0.00 addx711 add 0E+3 00.0 -> 0.0 addx712 add 0E+3 00. -> 0 addx713 add 0E+3 00.E+1 -> 0E+1 addx714 add 0E+3 00.E+2 -> 0E+2 addx715 add 0E+3 00.E+3 -> 0E+3 addx716 add 0E+3 00.E+4 -> 0E+3 addx717 add 0E+3 00.E+5 -> 0E+3 addx718 add 0E+3 -00.0 -> 0.0 addx719 add 0E+3 -00. -> 0 addx731 add 0E+3 -00.E+1 -> 0E+1 addx720 add 00.00 0E+3 -> 0.00 addx721 add 00.0 0E+3 -> 0.0 addx722 add 00. 0E+3 -> 0 addx723 add 00.E+1 0E+3 -> 0E+1 addx724 add 00.E+2 0E+3 -> 0E+2 addx725 add 00.E+3 0E+3 -> 0E+3 addx726 add 00.E+4 0E+3 -> 0E+3 addx727 add 00.E+5 0E+3 -> 0E+3 addx728 add -00.00 0E+3 -> 0.00 addx729 add -00.0 0E+3 -> 0.0 addx730 add -00. 0E+3 -> 0 addx732 add 0 0 -> 0 addx733 add 0 -0 -> 0 addx734 add -0 0 -> 0 addx735 add -0 -0 -> -0 -- IEEE 854 special case addx736 add 1 -1 -> 0 addx737 add -1 -1 -> -2 addx738 add 1 1 -> 2 addx739 add -1 1 -> 0 addx741 add 0 -1 -> -1 addx742 add -0 -1 -> -1 addx743 add 0 1 -> 1 addx744 add -0 1 -> 1 addx745 add -1 0 -> -1 addx746 add -1 -0 -> -1 addx747 add 1 0 -> 1 addx748 add 1 -0 -> 1 addx751 add 0.0 -1 -> -1.0 addx752 add -0.0 -1 -> -1.0 addx753 add 0.0 1 -> 1.0 addx754 add -0.0 1 -> 1.0 addx755 add -1.0 0 -> -1.0 addx756 add -1.0 -0 -> -1.0 addx757 add 1.0 0 -> 1.0 addx758 add 1.0 -0 -> 1.0 addx761 add 0 -1.0 -> -1.0 addx762 add -0 -1.0 -> -1.0 addx763 add 0 1.0 -> 1.0 addx764 add -0 1.0 -> 1.0 addx765 add -1 0.0 -> -1.0 addx766 add -1 -0.0 -> -1.0 addx767 add 1 0.0 -> 1.0 addx768 add 1 -0.0 -> 1.0 addx771 add 0.0 -1.0 -> -1.0 addx772 add -0.0 -1.0 -> -1.0 addx773 add 0.0 1.0 -> 1.0 addx774 add -0.0 1.0 -> 1.0 addx775 add -1.0 0.0 -> -1.0 addx776 add -1.0 -0.0 -> -1.0 addx777 add 1.0 0.0 -> 1.0 addx778 add 1.0 -0.0 -> 1.0 -- Specials addx780 add -Inf -Inf -> -Infinity addx781 add -Inf -1000 -> -Infinity addx782 add -Inf -1 -> -Infinity addx783 add -Inf -0 -> -Infinity addx784 add -Inf 0 -> -Infinity addx785 add -Inf 1 -> -Infinity addx786 add -Inf 1000 -> -Infinity addx787 add -1000 -Inf -> -Infinity addx788 add -Inf -Inf -> -Infinity addx789 add -1 -Inf -> -Infinity addx790 add -0 -Inf -> -Infinity addx791 add 0 -Inf -> -Infinity addx792 add 1 -Inf -> -Infinity addx793 add 1000 -Inf -> -Infinity addx794 add Inf -Inf -> NaN Invalid_operation addx800 add Inf -Inf -> NaN Invalid_operation addx801 add Inf -1000 -> Infinity addx802 add Inf -1 -> Infinity addx803 add Inf -0 -> Infinity addx804 add Inf 0 -> Infinity addx805 add Inf 1 -> Infinity addx806 add Inf 1000 -> Infinity addx807 add Inf Inf -> Infinity addx808 add -1000 Inf -> Infinity addx809 add -Inf Inf -> NaN Invalid_operation addx810 add -1 Inf -> Infinity addx811 add -0 Inf -> Infinity addx812 add 0 Inf -> Infinity addx813 add 1 Inf -> Infinity addx814 add 1000 Inf -> Infinity addx815 add Inf Inf -> Infinity addx821 add NaN -Inf -> NaN addx822 add NaN -1000 -> NaN addx823 add NaN -1 -> NaN addx824 add NaN -0 -> NaN addx825 add NaN 0 -> NaN addx826 add NaN 1 -> NaN addx827 add NaN 1000 -> NaN addx828 add NaN Inf -> NaN addx829 add NaN NaN -> NaN addx830 add -Inf NaN -> NaN addx831 add -1000 NaN -> NaN addx832 add -1 NaN -> NaN addx833 add -0 NaN -> NaN addx834 add 0 NaN -> NaN addx835 add 1 NaN -> NaN addx836 add 1000 NaN -> NaN addx837 add Inf NaN -> NaN addx841 add sNaN -Inf -> NaN Invalid_operation addx842 add sNaN -1000 -> NaN Invalid_operation addx843 add sNaN -1 -> NaN Invalid_operation addx844 add sNaN -0 -> NaN Invalid_operation addx845 add sNaN 0 -> NaN Invalid_operation addx846 add sNaN 1 -> NaN Invalid_operation addx847 add sNaN 1000 -> NaN Invalid_operation addx848 add sNaN NaN -> NaN Invalid_operation addx849 add sNaN sNaN -> NaN Invalid_operation addx850 add NaN sNaN -> NaN Invalid_operation addx851 add -Inf sNaN -> NaN Invalid_operation addx852 add -1000 sNaN -> NaN Invalid_operation addx853 add -1 sNaN -> NaN Invalid_operation addx854 add -0 sNaN -> NaN Invalid_operation addx855 add 0 sNaN -> NaN Invalid_operation addx856 add 1 sNaN -> NaN Invalid_operation addx857 add 1000 sNaN -> NaN Invalid_operation addx858 add Inf sNaN -> NaN Invalid_operation addx859 add NaN sNaN -> NaN Invalid_operation -- propagating NaNs addx861 add NaN1 -Inf -> NaN1 addx862 add +NaN2 -1000 -> NaN2 addx863 add NaN3 1000 -> NaN3 addx864 add NaN4 Inf -> NaN4 addx865 add NaN5 +NaN6 -> NaN5 addx866 add -Inf NaN7 -> NaN7 addx867 add -1000 NaN8 -> NaN8 addx868 add 1000 NaN9 -> NaN9 addx869 add Inf +NaN10 -> NaN10 addx871 add sNaN11 -Inf -> NaN11 Invalid_operation addx872 add sNaN12 -1000 -> NaN12 Invalid_operation addx873 add sNaN13 1000 -> NaN13 Invalid_operation addx874 add sNaN14 NaN17 -> NaN14 Invalid_operation addx875 add sNaN15 sNaN18 -> NaN15 Invalid_operation addx876 add NaN16 sNaN19 -> NaN19 Invalid_operation addx877 add -Inf +sNaN20 -> NaN20 Invalid_operation addx878 add -1000 sNaN21 -> NaN21 Invalid_operation addx879 add 1000 sNaN22 -> NaN22 Invalid_operation addx880 add Inf sNaN23 -> NaN23 Invalid_operation addx881 add +NaN25 +sNaN24 -> NaN24 Invalid_operation addx882 add -NaN26 NaN28 -> -NaN26 addx883 add -sNaN27 sNaN29 -> -NaN27 Invalid_operation addx884 add 1000 -NaN30 -> -NaN30 addx885 add 1000 -sNaN31 -> -NaN31 Invalid_operation -- overflow, underflow and subnormal tests maxexponent: 999999999 minexponent: -999999999 precision: 9 addx890 add 1E+999999999 9E+999999999 -> Infinity Overflow Inexact Rounded addx891 add 9E+999999999 1E+999999999 -> Infinity Overflow Inexact Rounded addx892 add -1.1E-999999999 1E-999999999 -> -1E-1000000000 Subnormal addx893 add 1E-999999999 -1.1e-999999999 -> -1E-1000000000 Subnormal addx894 add -1.0001E-999999999 1E-999999999 -> -1E-1000000003 Subnormal addx895 add 1E-999999999 -1.0001e-999999999 -> -1E-1000000003 Subnormal addx896 add -1E+999999999 -9E+999999999 -> -Infinity Overflow Inexact Rounded addx897 add -9E+999999999 -1E+999999999 -> -Infinity Overflow Inexact Rounded addx898 add +1.1E-999999999 -1E-999999999 -> 1E-1000000000 Subnormal addx899 add -1E-999999999 +1.1e-999999999 -> 1E-1000000000 Subnormal addx900 add +1.0001E-999999999 -1E-999999999 -> 1E-1000000003 Subnormal addx901 add -1E-999999999 +1.0001e-999999999 -> 1E-1000000003 Subnormal addx902 add -1E+999999999 +9E+999999999 -> 8E+999999999 addx903 add -9E+999999999 +1E+999999999 -> -8E+999999999 precision: 3 addx904 add 0 -9.999E+999999999 -> -Infinity Inexact Overflow Rounded addx905 add -9.999E+999999999 0 -> -Infinity Inexact Overflow Rounded addx906 add 0 9.999E+999999999 -> Infinity Inexact Overflow Rounded addx907 add 9.999E+999999999 0 -> Infinity Inexact Overflow Rounded precision: 3 maxexponent: 999 minexponent: -999 addx910 add 1.00E-999 0 -> 1.00E-999 addx911 add 0.1E-999 0 -> 1E-1000 Subnormal addx912 add 0.10E-999 0 -> 1.0E-1000 Subnormal addx913 add 0.100E-999 0 -> 1.0E-1000 Subnormal Rounded addx914 add 0.01E-999 0 -> 1E-1001 Subnormal -- next is rounded to Nmin addx915 add 0.999E-999 0 -> 1.00E-999 Inexact Rounded Subnormal Underflow addx916 add 0.099E-999 0 -> 1.0E-1000 Inexact Rounded Subnormal Underflow addx917 add 0.009E-999 0 -> 1E-1001 Inexact Rounded Subnormal Underflow addx918 add 0.001E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped addx919 add 0.0009E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped addx920 add 0.0001E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped addx930 add -1.00E-999 0 -> -1.00E-999 addx931 add -0.1E-999 0 -> -1E-1000 Subnormal addx932 add -0.10E-999 0 -> -1.0E-1000 Subnormal addx933 add -0.100E-999 0 -> -1.0E-1000 Subnormal Rounded addx934 add -0.01E-999 0 -> -1E-1001 Subnormal -- next is rounded to Nmin addx935 add -0.999E-999 0 -> -1.00E-999 Inexact Rounded Subnormal Underflow addx936 add -0.099E-999 0 -> -1.0E-1000 Inexact Rounded Subnormal Underflow addx937 add -0.009E-999 0 -> -1E-1001 Inexact Rounded Subnormal Underflow addx938 add -0.001E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped addx939 add -0.0009E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped addx940 add -0.0001E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped -- some non-zero subnormal adds addx950 add 1.00E-999 0.1E-999 -> 1.10E-999 addx951 add 0.1E-999 0.1E-999 -> 2E-1000 Subnormal addx952 add 0.10E-999 0.1E-999 -> 2.0E-1000 Subnormal addx953 add 0.100E-999 0.1E-999 -> 2.0E-1000 Subnormal Rounded addx954 add 0.01E-999 0.1E-999 -> 1.1E-1000 Subnormal addx955 add 0.999E-999 0.1E-999 -> 1.10E-999 Inexact Rounded addx956 add 0.099E-999 0.1E-999 -> 2.0E-1000 Inexact Rounded Subnormal Underflow addx957 add 0.009E-999 0.1E-999 -> 1.1E-1000 Inexact Rounded Subnormal Underflow addx958 add 0.001E-999 0.1E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow addx959 add 0.0009E-999 0.1E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow addx960 add 0.0001E-999 0.1E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow -- negatives... addx961 add 1.00E-999 -0.1E-999 -> 9.0E-1000 Subnormal addx962 add 0.1E-999 -0.1E-999 -> 0E-1000 addx963 add 0.10E-999 -0.1E-999 -> 0E-1001 addx964 add 0.100E-999 -0.1E-999 -> 0E-1001 Clamped addx965 add 0.01E-999 -0.1E-999 -> -9E-1001 Subnormal addx966 add 0.999E-999 -0.1E-999 -> 9.0E-1000 Inexact Rounded Subnormal Underflow addx967 add 0.099E-999 -0.1E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped addx968 add 0.009E-999 -0.1E-999 -> -9E-1001 Inexact Rounded Subnormal Underflow addx969 add 0.001E-999 -0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow addx970 add 0.0009E-999 -0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow addx971 add 0.0001E-999 -0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow -- some 'real' numbers maxExponent: 384 minExponent: -383 precision: 8 addx566 add 99999061735E-394 0E-394 -> 9.999906E-384 Inexact Rounded Underflow Subnormal precision: 7 addx567 add 99999061735E-394 0E-394 -> 9.99991E-384 Inexact Rounded Underflow Subnormal precision: 6 addx568 add 99999061735E-394 0E-394 -> 9.9999E-384 Inexact Rounded Underflow Subnormal -- now the case where we can get underflow but the result is normal -- [note this can't happen if the operands are also bounded, as we -- cannot represent 1E-399, for example] precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 addx571 add 1E-383 0 -> 1E-383 addx572 add 1E-384 0 -> 1E-384 Subnormal addx573 add 1E-383 1E-384 -> 1.1E-383 addx574 subtract 1E-383 1E-384 -> 9E-384 Subnormal -- Here we explore the boundary of rounding a subnormal to Nmin addx575 subtract 1E-383 1E-398 -> 9.99999999999999E-384 Subnormal addx576 subtract 1E-383 1E-398 -> 9.99999999999999E-384 Subnormal addx577 subtract 1E-383 1E-399 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx578 subtract 1E-383 1E-400 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx579 subtract 1E-383 1E-401 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx580 subtract 1E-383 1E-402 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded -- check overflow edge case precision: 7 rounding: half_up maxExponent: 96 minExponent: -95 addx972 apply 9.999999E+96 -> 9.999999E+96 addx973 add 9.999999E+96 1 -> 9.999999E+96 Inexact Rounded addx974 add 9999999E+90 1 -> 9.999999E+96 Inexact Rounded addx975 add 9999999E+90 1E+90 -> Infinity Overflow Inexact Rounded addx976 add 9999999E+90 9E+89 -> Infinity Overflow Inexact Rounded addx977 add 9999999E+90 8E+89 -> Infinity Overflow Inexact Rounded addx978 add 9999999E+90 7E+89 -> Infinity Overflow Inexact Rounded addx979 add 9999999E+90 6E+89 -> Infinity Overflow Inexact Rounded addx980 add 9999999E+90 5E+89 -> Infinity Overflow Inexact Rounded addx981 add 9999999E+90 4E+89 -> 9.999999E+96 Inexact Rounded addx982 add 9999999E+90 3E+89 -> 9.999999E+96 Inexact Rounded addx983 add 9999999E+90 2E+89 -> 9.999999E+96 Inexact Rounded addx984 add 9999999E+90 1E+89 -> 9.999999E+96 Inexact Rounded addx985 apply -9.999999E+96 -> -9.999999E+96 addx986 add -9.999999E+96 -1 -> -9.999999E+96 Inexact Rounded addx987 add -9999999E+90 -1 -> -9.999999E+96 Inexact Rounded addx988 add -9999999E+90 -1E+90 -> -Infinity Overflow Inexact Rounded addx989 add -9999999E+90 -9E+89 -> -Infinity Overflow Inexact Rounded addx990 add -9999999E+90 -8E+89 -> -Infinity Overflow Inexact Rounded addx991 add -9999999E+90 -7E+89 -> -Infinity Overflow Inexact Rounded addx992 add -9999999E+90 -6E+89 -> -Infinity Overflow Inexact Rounded addx993 add -9999999E+90 -5E+89 -> -Infinity Overflow Inexact Rounded addx994 add -9999999E+90 -4E+89 -> -9.999999E+96 Inexact Rounded addx995 add -9999999E+90 -3E+89 -> -9.999999E+96 Inexact Rounded addx996 add -9999999E+90 -2E+89 -> -9.999999E+96 Inexact Rounded addx997 add -9999999E+90 -1E+89 -> -9.999999E+96 Inexact Rounded -- check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 -- Add: lhs and rhs 0 addx1001 add 1.52444E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1002 add 1.52445E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1003 add 1.52446E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1004 add 0 1.52444E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1005 add 0 1.52445E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1006 add 0 1.52446E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow -- Add: lhs >> rhs and vice versa addx1011 add 1.52444E-80 1E-100 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1012 add 1.52445E-80 1E-100 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1013 add 1.52446E-80 1E-100 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1014 add 1E-100 1.52444E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1015 add 1E-100 1.52445E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow addx1016 add 1E-100 1.52446E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow -- Add: lhs + rhs addition carried out addx1021 add 1.52443E-80 1.00001E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow addx1022 add 1.52444E-80 1.00001E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow addx1023 add 1.52445E-80 1.00001E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow addx1024 add 1.00001E-80 1.52443E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow addx1025 add 1.00001E-80 1.52444E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow addx1026 add 1.00001E-80 1.52445E-80 -> 2.524E-80 Inexact Rounded Subnormal Underflow -- And for round down full and subnormal results precision: 16 maxExponent: +384 minExponent: -383 rounding: down addx1100 add 1e+2 -1e-383 -> 99.99999999999999 Rounded Inexact addx1101 add 1e+1 -1e-383 -> 9.999999999999999 Rounded Inexact addx1103 add +1 -1e-383 -> 0.9999999999999999 Rounded Inexact addx1104 add 1e-1 -1e-383 -> 0.09999999999999999 Rounded Inexact addx1105 add 1e-2 -1e-383 -> 0.009999999999999999 Rounded Inexact addx1106 add 1e-3 -1e-383 -> 0.0009999999999999999 Rounded Inexact addx1107 add 1e-4 -1e-383 -> 0.00009999999999999999 Rounded Inexact addx1108 add 1e-5 -1e-383 -> 0.000009999999999999999 Rounded Inexact addx1109 add 1e-6 -1e-383 -> 9.999999999999999E-7 Rounded Inexact rounding: ceiling addx1110 add -1e+2 +1e-383 -> -99.99999999999999 Rounded Inexact addx1111 add -1e+1 +1e-383 -> -9.999999999999999 Rounded Inexact addx1113 add -1 +1e-383 -> -0.9999999999999999 Rounded Inexact addx1114 add -1e-1 +1e-383 -> -0.09999999999999999 Rounded Inexact addx1115 add -1e-2 +1e-383 -> -0.009999999999999999 Rounded Inexact addx1116 add -1e-3 +1e-383 -> -0.0009999999999999999 Rounded Inexact addx1117 add -1e-4 +1e-383 -> -0.00009999999999999999 Rounded Inexact addx1118 add -1e-5 +1e-383 -> -0.000009999999999999999 Rounded Inexact addx1119 add -1e-6 +1e-383 -> -9.999999999999999E-7 Rounded Inexact addx1120 add +1e-383 -1e+2 -> -99.99999999999999 Rounded Inexact addx1121 add +1e-383 -1e+1 -> -9.999999999999999 Rounded Inexact addx1123 add +1e-383 -1 -> -0.9999999999999999 Rounded Inexact addx1124 add +1e-383 -1e-1 -> -0.09999999999999999 Rounded Inexact addx1125 add +1e-383 -1e-2 -> -0.009999999999999999 Rounded Inexact addx1126 add +1e-383 -1e-3 -> -0.0009999999999999999 Rounded Inexact addx1127 add +1e-383 -1e-4 -> -0.00009999999999999999 Rounded Inexact addx1128 add +1e-383 -1e-5 -> -0.000009999999999999999 Rounded Inexact addx1129 add +1e-383 -1e-6 -> -9.999999999999999E-7 Rounded Inexact rounding: down precision: 7 maxExponent: +96 minExponent: -95 addx1130 add 1 -1e-200 -> 0.9999999 Rounded Inexact -- subnormal boundary addx1131 add 1.000000E-94 -1e-200 -> 9.999999E-95 Rounded Inexact addx1132 add 1.000001E-95 -1e-200 -> 1.000000E-95 Rounded Inexact addx1133 add 1.000000E-95 -1e-200 -> 9.99999E-96 Rounded Inexact Subnormal Underflow addx1134 add 0.999999E-95 -1e-200 -> 9.99998E-96 Rounded Inexact Subnormal Underflow addx1135 add 0.001000E-95 -1e-200 -> 9.99E-99 Rounded Inexact Subnormal Underflow addx1136 add 0.000999E-95 -1e-200 -> 9.98E-99 Rounded Inexact Subnormal Underflow addx1137 add 1.000000E-95 -1e-101 -> 9.99999E-96 Subnormal addx1138 add 10000E-101 -1e-200 -> 9.999E-98 Subnormal Inexact Rounded Underflow addx1139 add 1000E-101 -1e-200 -> 9.99E-99 Subnormal Inexact Rounded Underflow addx1140 add 100E-101 -1e-200 -> 9.9E-100 Subnormal Inexact Rounded Underflow addx1141 add 10E-101 -1e-200 -> 9E-101 Subnormal Inexact Rounded Underflow addx1142 add 1E-101 -1e-200 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped addx1143 add 0E-101 -1e-200 -> -0E-101 Subnormal Inexact Rounded Underflow Clamped addx1144 add 1E-102 -1e-200 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped addx1151 add 10000E-102 -1e-200 -> 9.99E-99 Subnormal Inexact Rounded Underflow addx1152 add 1000E-102 -1e-200 -> 9.9E-100 Subnormal Inexact Rounded Underflow addx1153 add 100E-102 -1e-200 -> 9E-101 Subnormal Inexact Rounded Underflow addx1154 add 10E-102 -1e-200 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped addx1155 add 1E-102 -1e-200 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped addx1156 add 0E-102 -1e-200 -> -0E-101 Subnormal Inexact Rounded Underflow Clamped addx1157 add 1E-103 -1e-200 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped addx1160 add 100E-105 -1e-101 -> -0E-101 Subnormal Inexact Rounded Underflow Clamped addx1161 add 100E-105 -1e-201 -> 0E-101 Subnormal Inexact Rounded Underflow Clamped -- tests based on Gunnar Degnbol's edge case precision: 15 rounding: half_up maxExponent: 384 minexponent: -383 addx1200 add 1E15 -0.5 -> 1.00000000000000E+15 Inexact Rounded addx1201 add 1E15 -0.50 -> 1.00000000000000E+15 Inexact Rounded addx1210 add 1E15 -0.51 -> 999999999999999 Inexact Rounded addx1211 add 1E15 -0.501 -> 999999999999999 Inexact Rounded addx1212 add 1E15 -0.5001 -> 999999999999999 Inexact Rounded addx1213 add 1E15 -0.50001 -> 999999999999999 Inexact Rounded addx1214 add 1E15 -0.500001 -> 999999999999999 Inexact Rounded addx1215 add 1E15 -0.5000001 -> 999999999999999 Inexact Rounded addx1216 add 1E15 -0.50000001 -> 999999999999999 Inexact Rounded addx1217 add 1E15 -0.500000001 -> 999999999999999 Inexact Rounded addx1218 add 1E15 -0.5000000001 -> 999999999999999 Inexact Rounded addx1219 add 1E15 -0.50000000001 -> 999999999999999 Inexact Rounded addx1220 add 1E15 -0.500000000001 -> 999999999999999 Inexact Rounded addx1221 add 1E15 -0.5000000000001 -> 999999999999999 Inexact Rounded addx1222 add 1E15 -0.50000000000001 -> 999999999999999 Inexact Rounded addx1223 add 1E15 -0.500000000000001 -> 999999999999999 Inexact Rounded addx1224 add 1E15 -0.5000000000000001 -> 999999999999999 Inexact Rounded addx1225 add 1E15 -0.5000000000000000 -> 1.00000000000000E+15 Inexact Rounded addx1230 add 1E15 -5000000.000000001 -> 999999995000000 Inexact Rounded precision: 16 addx1300 add 1E16 -0.5 -> 1.000000000000000E+16 Inexact Rounded addx1310 add 1E16 -0.51 -> 9999999999999999 Inexact Rounded addx1311 add 1E16 -0.501 -> 9999999999999999 Inexact Rounded addx1312 add 1E16 -0.5001 -> 9999999999999999 Inexact Rounded addx1313 add 1E16 -0.50001 -> 9999999999999999 Inexact Rounded addx1314 add 1E16 -0.500001 -> 9999999999999999 Inexact Rounded addx1315 add 1E16 -0.5000001 -> 9999999999999999 Inexact Rounded addx1316 add 1E16 -0.50000001 -> 9999999999999999 Inexact Rounded addx1317 add 1E16 -0.500000001 -> 9999999999999999 Inexact Rounded addx1318 add 1E16 -0.5000000001 -> 9999999999999999 Inexact Rounded addx1319 add 1E16 -0.50000000001 -> 9999999999999999 Inexact Rounded addx1320 add 1E16 -0.500000000001 -> 9999999999999999 Inexact Rounded addx1321 add 1E16 -0.5000000000001 -> 9999999999999999 Inexact Rounded addx1322 add 1E16 -0.50000000000001 -> 9999999999999999 Inexact Rounded addx1323 add 1E16 -0.500000000000001 -> 9999999999999999 Inexact Rounded addx1324 add 1E16 -0.5000000000000001 -> 9999999999999999 Inexact Rounded addx1325 add 1E16 -0.5000000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1326 add 1E16 -0.500000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1327 add 1E16 -0.50000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1328 add 1E16 -0.5000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1329 add 1E16 -0.500000000000 -> 1.000000000000000E+16 Inexact Rounded addx1330 add 1E16 -0.50000000000 -> 1.000000000000000E+16 Inexact Rounded addx1331 add 1E16 -0.5000000000 -> 1.000000000000000E+16 Inexact Rounded addx1332 add 1E16 -0.500000000 -> 1.000000000000000E+16 Inexact Rounded addx1333 add 1E16 -0.50000000 -> 1.000000000000000E+16 Inexact Rounded addx1334 add 1E16 -0.5000000 -> 1.000000000000000E+16 Inexact Rounded addx1335 add 1E16 -0.500000 -> 1.000000000000000E+16 Inexact Rounded addx1336 add 1E16 -0.50000 -> 1.000000000000000E+16 Inexact Rounded addx1337 add 1E16 -0.5000 -> 1.000000000000000E+16 Inexact Rounded addx1338 add 1E16 -0.500 -> 1.000000000000000E+16 Inexact Rounded addx1339 add 1E16 -0.50 -> 1.000000000000000E+16 Inexact Rounded addx1340 add 1E16 -5000000.000010001 -> 9999999995000000 Inexact Rounded addx1341 add 1E16 -5000000.000000001 -> 9999999995000000 Inexact Rounded addx1349 add 9999999999999999 0.4 -> 9999999999999999 Inexact Rounded addx1350 add 9999999999999999 0.49 -> 9999999999999999 Inexact Rounded addx1351 add 9999999999999999 0.499 -> 9999999999999999 Inexact Rounded addx1352 add 9999999999999999 0.4999 -> 9999999999999999 Inexact Rounded addx1353 add 9999999999999999 0.49999 -> 9999999999999999 Inexact Rounded addx1354 add 9999999999999999 0.499999 -> 9999999999999999 Inexact Rounded addx1355 add 9999999999999999 0.4999999 -> 9999999999999999 Inexact Rounded addx1356 add 9999999999999999 0.49999999 -> 9999999999999999 Inexact Rounded addx1357 add 9999999999999999 0.499999999 -> 9999999999999999 Inexact Rounded addx1358 add 9999999999999999 0.4999999999 -> 9999999999999999 Inexact Rounded addx1359 add 9999999999999999 0.49999999999 -> 9999999999999999 Inexact Rounded addx1360 add 9999999999999999 0.499999999999 -> 9999999999999999 Inexact Rounded addx1361 add 9999999999999999 0.4999999999999 -> 9999999999999999 Inexact Rounded addx1362 add 9999999999999999 0.49999999999999 -> 9999999999999999 Inexact Rounded addx1363 add 9999999999999999 0.499999999999999 -> 9999999999999999 Inexact Rounded addx1364 add 9999999999999999 0.4999999999999999 -> 9999999999999999 Inexact Rounded addx1365 add 9999999999999999 0.5000000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1367 add 9999999999999999 0.500000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1368 add 9999999999999999 0.50000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1369 add 9999999999999999 0.5000000000000 -> 1.000000000000000E+16 Inexact Rounded addx1370 add 9999999999999999 0.500000000000 -> 1.000000000000000E+16 Inexact Rounded addx1371 add 9999999999999999 0.50000000000 -> 1.000000000000000E+16 Inexact Rounded addx1372 add 9999999999999999 0.5000000000 -> 1.000000000000000E+16 Inexact Rounded addx1373 add 9999999999999999 0.500000000 -> 1.000000000000000E+16 Inexact Rounded addx1374 add 9999999999999999 0.50000000 -> 1.000000000000000E+16 Inexact Rounded addx1375 add 9999999999999999 0.5000000 -> 1.000000000000000E+16 Inexact Rounded addx1376 add 9999999999999999 0.500000 -> 1.000000000000000E+16 Inexact Rounded addx1377 add 9999999999999999 0.50000 -> 1.000000000000000E+16 Inexact Rounded addx1378 add 9999999999999999 0.5000 -> 1.000000000000000E+16 Inexact Rounded addx1379 add 9999999999999999 0.500 -> 1.000000000000000E+16 Inexact Rounded addx1380 add 9999999999999999 0.50 -> 1.000000000000000E+16 Inexact Rounded addx1381 add 9999999999999999 0.5 -> 1.000000000000000E+16 Inexact Rounded addx1382 add 9999999999999999 0.5000000000000001 -> 1.000000000000000E+16 Inexact Rounded addx1383 add 9999999999999999 0.500000000000001 -> 1.000000000000000E+16 Inexact Rounded addx1384 add 9999999999999999 0.50000000000001 -> 1.000000000000000E+16 Inexact Rounded addx1385 add 9999999999999999 0.5000000000001 -> 1.000000000000000E+16 Inexact Rounded addx1386 add 9999999999999999 0.500000000001 -> 1.000000000000000E+16 Inexact Rounded addx1387 add 9999999999999999 0.50000000001 -> 1.000000000000000E+16 Inexact Rounded addx1388 add 9999999999999999 0.5000000001 -> 1.000000000000000E+16 Inexact Rounded addx1389 add 9999999999999999 0.500000001 -> 1.000000000000000E+16 Inexact Rounded addx1390 add 9999999999999999 0.50000001 -> 1.000000000000000E+16 Inexact Rounded addx1391 add 9999999999999999 0.5000001 -> 1.000000000000000E+16 Inexact Rounded addx1392 add 9999999999999999 0.500001 -> 1.000000000000000E+16 Inexact Rounded addx1393 add 9999999999999999 0.50001 -> 1.000000000000000E+16 Inexact Rounded addx1394 add 9999999999999999 0.5001 -> 1.000000000000000E+16 Inexact Rounded addx1395 add 9999999999999999 0.501 -> 1.000000000000000E+16 Inexact Rounded addx1396 add 9999999999999999 0.51 -> 1.000000000000000E+16 Inexact Rounded -- More GD edge cases, where difference between the unadjusted -- exponents is larger than the maximum precision and one side is 0 precision: 15 rounding: half_up maxExponent: 384 minexponent: -383 addx1400 add 0 1.23456789012345 -> 1.23456789012345 addx1401 add 0 1.23456789012345E-1 -> 0.123456789012345 addx1402 add 0 1.23456789012345E-2 -> 0.0123456789012345 addx1403 add 0 1.23456789012345E-3 -> 0.00123456789012345 addx1404 add 0 1.23456789012345E-4 -> 0.000123456789012345 addx1405 add 0 1.23456789012345E-5 -> 0.0000123456789012345 addx1406 add 0 1.23456789012345E-6 -> 0.00000123456789012345 addx1407 add 0 1.23456789012345E-7 -> 1.23456789012345E-7 addx1408 add 0 1.23456789012345E-8 -> 1.23456789012345E-8 addx1409 add 0 1.23456789012345E-9 -> 1.23456789012345E-9 addx1410 add 0 1.23456789012345E-10 -> 1.23456789012345E-10 addx1411 add 0 1.23456789012345E-11 -> 1.23456789012345E-11 addx1412 add 0 1.23456789012345E-12 -> 1.23456789012345E-12 addx1413 add 0 1.23456789012345E-13 -> 1.23456789012345E-13 addx1414 add 0 1.23456789012345E-14 -> 1.23456789012345E-14 addx1415 add 0 1.23456789012345E-15 -> 1.23456789012345E-15 addx1416 add 0 1.23456789012345E-16 -> 1.23456789012345E-16 addx1417 add 0 1.23456789012345E-17 -> 1.23456789012345E-17 addx1418 add 0 1.23456789012345E-18 -> 1.23456789012345E-18 addx1419 add 0 1.23456789012345E-19 -> 1.23456789012345E-19 -- same, precision 16.. precision: 16 addx1420 add 0 1.123456789012345 -> 1.123456789012345 addx1421 add 0 1.123456789012345E-1 -> 0.1123456789012345 addx1422 add 0 1.123456789012345E-2 -> 0.01123456789012345 addx1423 add 0 1.123456789012345E-3 -> 0.001123456789012345 addx1424 add 0 1.123456789012345E-4 -> 0.0001123456789012345 addx1425 add 0 1.123456789012345E-5 -> 0.00001123456789012345 addx1426 add 0 1.123456789012345E-6 -> 0.000001123456789012345 addx1427 add 0 1.123456789012345E-7 -> 1.123456789012345E-7 addx1428 add 0 1.123456789012345E-8 -> 1.123456789012345E-8 addx1429 add 0 1.123456789012345E-9 -> 1.123456789012345E-9 addx1430 add 0 1.123456789012345E-10 -> 1.123456789012345E-10 addx1431 add 0 1.123456789012345E-11 -> 1.123456789012345E-11 addx1432 add 0 1.123456789012345E-12 -> 1.123456789012345E-12 addx1433 add 0 1.123456789012345E-13 -> 1.123456789012345E-13 addx1434 add 0 1.123456789012345E-14 -> 1.123456789012345E-14 addx1435 add 0 1.123456789012345E-15 -> 1.123456789012345E-15 addx1436 add 0 1.123456789012345E-16 -> 1.123456789012345E-16 addx1437 add 0 1.123456789012345E-17 -> 1.123456789012345E-17 addx1438 add 0 1.123456789012345E-18 -> 1.123456789012345E-18 addx1439 add 0 1.123456789012345E-19 -> 1.123456789012345E-19 -- same, reversed 0 addx1440 add 1.123456789012345 0 -> 1.123456789012345 addx1441 add 1.123456789012345E-1 0 -> 0.1123456789012345 addx1442 add 1.123456789012345E-2 0 -> 0.01123456789012345 addx1443 add 1.123456789012345E-3 0 -> 0.001123456789012345 addx1444 add 1.123456789012345E-4 0 -> 0.0001123456789012345 addx1445 add 1.123456789012345E-5 0 -> 0.00001123456789012345 addx1446 add 1.123456789012345E-6 0 -> 0.000001123456789012345 addx1447 add 1.123456789012345E-7 0 -> 1.123456789012345E-7 addx1448 add 1.123456789012345E-8 0 -> 1.123456789012345E-8 addx1449 add 1.123456789012345E-9 0 -> 1.123456789012345E-9 addx1450 add 1.123456789012345E-10 0 -> 1.123456789012345E-10 addx1451 add 1.123456789012345E-11 0 -> 1.123456789012345E-11 addx1452 add 1.123456789012345E-12 0 -> 1.123456789012345E-12 addx1453 add 1.123456789012345E-13 0 -> 1.123456789012345E-13 addx1454 add 1.123456789012345E-14 0 -> 1.123456789012345E-14 addx1455 add 1.123456789012345E-15 0 -> 1.123456789012345E-15 addx1456 add 1.123456789012345E-16 0 -> 1.123456789012345E-16 addx1457 add 1.123456789012345E-17 0 -> 1.123456789012345E-17 addx1458 add 1.123456789012345E-18 0 -> 1.123456789012345E-18 addx1459 add 1.123456789012345E-19 0 -> 1.123456789012345E-19 -- same, Es on the 0 addx1460 add 1.123456789012345 0E-0 -> 1.123456789012345 addx1461 add 1.123456789012345 0E-1 -> 1.123456789012345 addx1462 add 1.123456789012345 0E-2 -> 1.123456789012345 addx1463 add 1.123456789012345 0E-3 -> 1.123456789012345 addx1464 add 1.123456789012345 0E-4 -> 1.123456789012345 addx1465 add 1.123456789012345 0E-5 -> 1.123456789012345 addx1466 add 1.123456789012345 0E-6 -> 1.123456789012345 addx1467 add 1.123456789012345 0E-7 -> 1.123456789012345 addx1468 add 1.123456789012345 0E-8 -> 1.123456789012345 addx1469 add 1.123456789012345 0E-9 -> 1.123456789012345 addx1470 add 1.123456789012345 0E-10 -> 1.123456789012345 addx1471 add 1.123456789012345 0E-11 -> 1.123456789012345 addx1472 add 1.123456789012345 0E-12 -> 1.123456789012345 addx1473 add 1.123456789012345 0E-13 -> 1.123456789012345 addx1474 add 1.123456789012345 0E-14 -> 1.123456789012345 addx1475 add 1.123456789012345 0E-15 -> 1.123456789012345 -- next four flag Rounded because the 0 extends the result addx1476 add 1.123456789012345 0E-16 -> 1.123456789012345 Rounded addx1477 add 1.123456789012345 0E-17 -> 1.123456789012345 Rounded addx1478 add 1.123456789012345 0E-18 -> 1.123456789012345 Rounded addx1479 add 1.123456789012345 0E-19 -> 1.123456789012345 Rounded -- sum of two opposite-sign operands is exactly 0 and floor => -0 precision: 16 maxExponent: 384 minexponent: -383 rounding: half_up -- exact zeros from zeros addx1500 add 0 0E-19 -> 0E-19 addx1501 add -0 0E-19 -> 0E-19 addx1502 add 0 -0E-19 -> 0E-19 addx1503 add -0 -0E-19 -> -0E-19 addx1504 add 0E-400 0E-19 -> 0E-398 Clamped addx1505 add -0E-400 0E-19 -> 0E-398 Clamped addx1506 add 0E-400 -0E-19 -> 0E-398 Clamped addx1507 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1511 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1512 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1513 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx1514 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx1515 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1516 add -1E-401 1E-401 -> 0E-398 Clamped addx1517 add 1E-401 -1E-401 -> 0E-398 Clamped addx1518 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: half_down -- exact zeros from zeros addx1520 add 0 0E-19 -> 0E-19 addx1521 add -0 0E-19 -> 0E-19 addx1522 add 0 -0E-19 -> 0E-19 addx1523 add -0 -0E-19 -> -0E-19 addx1524 add 0E-400 0E-19 -> 0E-398 Clamped addx1525 add -0E-400 0E-19 -> 0E-398 Clamped addx1526 add 0E-400 -0E-19 -> 0E-398 Clamped addx1527 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1531 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1532 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1533 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx1534 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx1535 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1536 add -1E-401 1E-401 -> 0E-398 Clamped addx1537 add 1E-401 -1E-401 -> 0E-398 Clamped addx1538 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: half_even -- exact zeros from zeros addx1540 add 0 0E-19 -> 0E-19 addx1541 add -0 0E-19 -> 0E-19 addx1542 add 0 -0E-19 -> 0E-19 addx1543 add -0 -0E-19 -> -0E-19 addx1544 add 0E-400 0E-19 -> 0E-398 Clamped addx1545 add -0E-400 0E-19 -> 0E-398 Clamped addx1546 add 0E-400 -0E-19 -> 0E-398 Clamped addx1547 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1551 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1552 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1553 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx1554 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx1555 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1556 add -1E-401 1E-401 -> 0E-398 Clamped addx1557 add 1E-401 -1E-401 -> 0E-398 Clamped addx1558 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: up -- exact zeros from zeros addx1560 add 0 0E-19 -> 0E-19 addx1561 add -0 0E-19 -> 0E-19 addx1562 add 0 -0E-19 -> 0E-19 addx1563 add -0 -0E-19 -> -0E-19 addx1564 add 0E-400 0E-19 -> 0E-398 Clamped addx1565 add -0E-400 0E-19 -> 0E-398 Clamped addx1566 add 0E-400 -0E-19 -> 0E-398 Clamped addx1567 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1571 add 1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx1572 add -1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx1573 add 1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow addx1574 add -1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow -- some exact zeros from non-zeros addx1575 add 1E-401 1E-401 -> 1E-398 Subnormal Inexact Rounded Underflow addx1576 add -1E-401 1E-401 -> 0E-398 Clamped addx1577 add 1E-401 -1E-401 -> 0E-398 Clamped addx1578 add -1E-401 -1E-401 -> -1E-398 Subnormal Inexact Rounded Underflow rounding: down -- exact zeros from zeros addx1580 add 0 0E-19 -> 0E-19 addx1581 add -0 0E-19 -> 0E-19 addx1582 add 0 -0E-19 -> 0E-19 addx1583 add -0 -0E-19 -> -0E-19 addx1584 add 0E-400 0E-19 -> 0E-398 Clamped addx1585 add -0E-400 0E-19 -> 0E-398 Clamped addx1586 add 0E-400 -0E-19 -> 0E-398 Clamped addx1587 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1591 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1592 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1593 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx1594 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx1595 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1596 add -1E-401 1E-401 -> 0E-398 Clamped addx1597 add 1E-401 -1E-401 -> 0E-398 Clamped addx1598 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: ceiling -- exact zeros from zeros addx1600 add 0 0E-19 -> 0E-19 addx1601 add -0 0E-19 -> 0E-19 addx1602 add 0 -0E-19 -> 0E-19 addx1603 add -0 -0E-19 -> -0E-19 addx1604 add 0E-400 0E-19 -> 0E-398 Clamped addx1605 add -0E-400 0E-19 -> 0E-398 Clamped addx1606 add 0E-400 -0E-19 -> 0E-398 Clamped addx1607 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1611 add 1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx1612 add -1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx1613 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx1614 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx1615 add 1E-401 1E-401 -> 1E-398 Subnormal Inexact Rounded Underflow addx1616 add -1E-401 1E-401 -> 0E-398 Clamped addx1617 add 1E-401 -1E-401 -> 0E-398 Clamped addx1618 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- and the extra-special ugly case; unusual minuses marked by -- * rounding: floor -- exact zeros from zeros addx1620 add 0 0E-19 -> 0E-19 addx1621 add -0 0E-19 -> -0E-19 -- * addx1622 add 0 -0E-19 -> -0E-19 -- * addx1623 add -0 -0E-19 -> -0E-19 addx1624 add 0E-400 0E-19 -> 0E-398 Clamped addx1625 add -0E-400 0E-19 -> -0E-398 Clamped -- * addx1626 add 0E-400 -0E-19 -> -0E-398 Clamped -- * addx1627 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx1631 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1632 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1633 add 1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow addx1634 add -1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow -- some exact zeros from non-zeros addx1635 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx1636 add -1E-401 1E-401 -> -0E-398 Clamped -- * addx1637 add 1E-401 -1E-401 -> -0E-398 Clamped -- * addx1638 add -1E-401 -1E-401 -> -1E-398 Subnormal Inexact Rounded Underflow -- BigDecimal problem testcases 2006.01.23 precision: 16 maxExponent: 384 minexponent: -383 rounding: down precision: 7 addx1651 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 6 addx1652 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 5 addx1653 add 10001E+2 -2E+1 -> 1.0000E+6 Inexact Rounded precision: 4 addx1654 add 10001E+2 -2E+1 -> 1.000E+6 Inexact Rounded precision: 3 addx1655 add 10001E+2 -2E+1 -> 1.00E+6 Inexact Rounded precision: 2 addx1656 add 10001E+2 -2E+1 -> 1.0E+6 Inexact Rounded precision: 1 addx1657 add 10001E+2 -2E+1 -> 1E+6 Inexact Rounded rounding: half_even precision: 7 addx1661 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 6 addx1662 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 5 addx1663 add 10001E+2 -2E+1 -> 1.0001E+6 Inexact Rounded precision: 4 addx1664 add 10001E+2 -2E+1 -> 1.000E+6 Inexact Rounded precision: 3 addx1665 add 10001E+2 -2E+1 -> 1.00E+6 Inexact Rounded precision: 2 addx1666 add 10001E+2 -2E+1 -> 1.0E+6 Inexact Rounded precision: 1 addx1667 add 10001E+2 -2E+1 -> 1E+6 Inexact Rounded rounding: up precision: 7 addx1671 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 6 addx1672 add 10001E+2 -2E+1 -> 1.00008E+6 precision: 5 addx1673 add 10001E+2 -2E+1 -> 1.0001E+6 Inexact Rounded precision: 4 addx1674 add 10001E+2 -2E+1 -> 1.001E+6 Inexact Rounded precision: 3 addx1675 add 10001E+2 -2E+1 -> 1.01E+6 Inexact Rounded precision: 2 addx1676 add 10001E+2 -2E+1 -> 1.1E+6 Inexact Rounded precision: 1 addx1677 add 10001E+2 -2E+1 -> 2E+6 Inexact Rounded precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 -- Examples from SQL proposal (Krishna Kulkarni) addx1701 add 130E-2 120E-2 -> 2.50 addx1702 add 130E-2 12E-1 -> 2.50 addx1703 add 130E-2 1E0 -> 2.30 addx1704 add 1E2 1E4 -> 1.01E+4 addx1705 subtract 130E-2 120E-2 -> 0.10 addx1706 subtract 130E-2 12E-1 -> 0.10 addx1707 subtract 130E-2 1E0 -> 0.30 addx1708 subtract 1E2 1E4 -> -9.9E+3 ------------------------------------------------------------------------ -- Same as above, using decimal64 default parameters -- ------------------------------------------------------------------------ precision: 16 rounding: half_even maxExponent: 384 minexponent: -383 -- [first group are 'quick confidence check'] addx6001 add 1 1 -> 2 addx6002 add 2 3 -> 5 addx6003 add '5.75' '3.3' -> 9.05 addx6004 add '5' '-3' -> 2 addx6005 add '-5' '-3' -> -8 addx6006 add '-7' '2.5' -> -4.5 addx6007 add '0.7' '0.3' -> 1.0 addx6008 add '1.25' '1.25' -> 2.50 addx6009 add '1.23456789' '1.00000000' -> '2.23456789' addx6010 add '1.23456789' '1.00000011' -> '2.23456800' addx6011 add '0.44444444444444444' '0.55555555555555555' -> '1.000000000000000' Inexact Rounded addx6012 add '0.44444444444444440' '0.55555555555555555' -> '1.000000000000000' Inexact Rounded addx6013 add '0.44444444444444444' '0.55555555555555550' -> '0.9999999999999999' Inexact Rounded addx6014 add '0.444444444444444449' '0' -> '0.4444444444444444' Inexact Rounded addx6015 add '0.4444444444444444499' '0' -> '0.4444444444444444' Inexact Rounded addx6016 add '0.44444444444444444999' '0' -> '0.4444444444444444' Inexact Rounded addx6017 add '0.44444444444444445000' '0' -> '0.4444444444444444' Inexact Rounded addx6018 add '0.44444444444444445001' '0' -> '0.4444444444444445' Inexact Rounded addx6019 add '0.4444444444444444501' '0' -> '0.4444444444444445' Inexact Rounded addx6020 add '0.444444444444444451' '0' -> '0.4444444444444445' Inexact Rounded addx6021 add 0 1 -> 1 addx6022 add 1 1 -> 2 addx6023 add 2 1 -> 3 addx6024 add 3 1 -> 4 addx6025 add 4 1 -> 5 addx6026 add 5 1 -> 6 addx6027 add 6 1 -> 7 addx6028 add 7 1 -> 8 addx6029 add 8 1 -> 9 addx6030 add 9 1 -> 10 -- some carrying effects addx6031 add '0.9998' '0.0000' -> '0.9998' addx6032 add '0.9998' '0.0001' -> '0.9999' addx6033 add '0.9998' '0.0002' -> '1.0000' addx6034 add '0.9998' '0.0003' -> '1.0001' addx6035 add '70' '10000e+16' -> '1.000000000000000E+20' Inexact Rounded addx6036 add '700' '10000e+16' -> '1.000000000000000E+20' Inexact Rounded addx6037 add '7000' '10000e+16' -> '1.000000000000000E+20' Inexact Rounded addx6038 add '70000' '10000e+16' -> '1.000000000000001E+20' Inexact Rounded addx6039 add '700000' '10000e+16' -> '1.000000000000007E+20' Rounded -- symmetry: addx6040 add '10000e+16' '70' -> '1.000000000000000E+20' Inexact Rounded addx6041 add '10000e+16' '700' -> '1.000000000000000E+20' Inexact Rounded addx6042 add '10000e+16' '7000' -> '1.000000000000000E+20' Inexact Rounded addx6044 add '10000e+16' '70000' -> '1.000000000000001E+20' Inexact Rounded addx6045 add '10000e+16' '700000' -> '1.000000000000007E+20' Rounded addx6046 add '10000e+9' '7' -> '10000000000007' addx6047 add '10000e+9' '70' -> '10000000000070' addx6048 add '10000e+9' '700' -> '10000000000700' addx6049 add '10000e+9' '7000' -> '10000000007000' addx6050 add '10000e+9' '70000' -> '10000000070000' addx6051 add '10000e+9' '700000' -> '10000000700000' -- examples from decarith addx6053 add '12' '7.00' -> '19.00' addx6054 add '1.3' '-1.07' -> '0.23' addx6055 add '1.3' '-1.30' -> '0.00' addx6056 add '1.3' '-2.07' -> '-0.77' addx6057 add '1E+2' '1E+4' -> '1.01E+4' -- from above addx6060 add 1 '0.1' -> '1.1' addx6061 add 1 '0.01' -> '1.01' addx6062 add 1 '0.001' -> '1.001' addx6063 add 1 '0.0001' -> '1.0001' addx6064 add 1 '0.00001' -> '1.00001' addx6065 add 1 '0.000001' -> '1.000001' addx6066 add 1 '0.0000001' -> '1.0000001' addx6067 add 1 '0.00000001' -> '1.00000001' -- cancellation to integer addx6068 add 99999999999999123456789 -99999999999999E+9 -> 123456789 -- similar from FMA fun addx6069 add "-1234567890123455.234567890123454" "1234567890123456" -> 0.765432109876546 -- some funny zeros [in case of bad signum] addx6070 add 1 0 -> 1 addx6071 add 1 0. -> 1 addx6072 add 1 .0 -> 1.0 addx6073 add 1 0.0 -> 1.0 addx6074 add 1 0.00 -> 1.00 addx6075 add 0 1 -> 1 addx6076 add 0. 1 -> 1 addx6077 add .0 1 -> 1.0 addx6078 add 0.0 1 -> 1.0 addx6079 add 0.00 1 -> 1.00 -- some carries addx6080 add 9999999999999998 1 -> 9999999999999999 addx6081 add 9999999999999999 1 -> 1.000000000000000E+16 Rounded addx6082 add 999999999999999 1 -> 1000000000000000 addx6083 add 9999999999999 1 -> 10000000000000 addx6084 add 99999999999 1 -> 100000000000 addx6085 add 999999999 1 -> 1000000000 addx6086 add 9999999 1 -> 10000000 addx6087 add 99999 1 -> 100000 addx6088 add 999 1 -> 1000 addx6089 add 9 1 -> 10 -- more LHS swaps addx6090 add '-56267E-10' 0 -> '-0.0000056267' addx6091 add '-56267E-6' 0 -> '-0.056267' addx6092 add '-56267E-5' 0 -> '-0.56267' addx6093 add '-56267E-4' 0 -> '-5.6267' addx6094 add '-56267E-3' 0 -> '-56.267' addx6095 add '-56267E-2' 0 -> '-562.67' addx6096 add '-56267E-1' 0 -> '-5626.7' addx6097 add '-56267E-0' 0 -> '-56267' addx6098 add '-5E-10' 0 -> '-5E-10' addx6099 add '-5E-7' 0 -> '-5E-7' addx6100 add '-5E-6' 0 -> '-0.000005' addx6101 add '-5E-5' 0 -> '-0.00005' addx6102 add '-5E-4' 0 -> '-0.0005' addx6103 add '-5E-1' 0 -> '-0.5' addx6104 add '-5E0' 0 -> '-5' addx6105 add '-5E1' 0 -> '-50' addx6106 add '-5E5' 0 -> '-500000' addx6107 add '-5E15' 0 -> '-5000000000000000' addx6108 add '-5E16' 0 -> '-5.000000000000000E+16' Rounded addx6109 add '-5E17' 0 -> '-5.000000000000000E+17' Rounded addx6110 add '-5E18' 0 -> '-5.000000000000000E+18' Rounded addx6111 add '-5E100' 0 -> '-5.000000000000000E+100' Rounded -- more RHS swaps addx6113 add 0 '-56267E-10' -> '-0.0000056267' addx6114 add 0 '-56267E-6' -> '-0.056267' addx6116 add 0 '-56267E-5' -> '-0.56267' addx6117 add 0 '-56267E-4' -> '-5.6267' addx6119 add 0 '-56267E-3' -> '-56.267' addx6120 add 0 '-56267E-2' -> '-562.67' addx6121 add 0 '-56267E-1' -> '-5626.7' addx6122 add 0 '-56267E-0' -> '-56267' addx6123 add 0 '-5E-10' -> '-5E-10' addx6124 add 0 '-5E-7' -> '-5E-7' addx6125 add 0 '-5E-6' -> '-0.000005' addx6126 add 0 '-5E-5' -> '-0.00005' addx6127 add 0 '-5E-4' -> '-0.0005' addx6128 add 0 '-5E-1' -> '-0.5' addx6129 add 0 '-5E0' -> '-5' addx6130 add 0 '-5E1' -> '-50' addx6131 add 0 '-5E5' -> '-500000' addx6132 add 0 '-5E15' -> '-5000000000000000' addx6133 add 0 '-5E16' -> '-5.000000000000000E+16' Rounded addx6134 add 0 '-5E17' -> '-5.000000000000000E+17' Rounded addx6135 add 0 '-5E18' -> '-5.000000000000000E+18' Rounded addx6136 add 0 '-5E100' -> '-5.000000000000000E+100' Rounded -- related addx6137 add 1 '0E-19' -> '1.000000000000000' Rounded addx6138 add -1 '0E-19' -> '-1.000000000000000' Rounded addx6139 add '0E-19' 1 -> '1.000000000000000' Rounded addx6140 add '0E-19' -1 -> '-1.000000000000000' Rounded addx6141 add 1E+11 0.0000 -> '100000000000.0000' addx6142 add 1E+11 0.00000 -> '100000000000.0000' Rounded addx6143 add 0.000 1E+12 -> '1000000000000.000' addx6144 add 0.0000 1E+12 -> '1000000000000.000' Rounded -- [some of the next group are really constructor tests] addx6146 add '00.0' 0 -> '0.0' addx6147 add '0.00' 0 -> '0.00' addx6148 add 0 '0.00' -> '0.00' addx6149 add 0 '00.0' -> '0.0' addx6150 add '00.0' '0.00' -> '0.00' addx6151 add '0.00' '00.0' -> '0.00' addx6152 add '3' '.3' -> '3.3' addx6153 add '3.' '.3' -> '3.3' addx6154 add '3.0' '.3' -> '3.3' addx6155 add '3.00' '.3' -> '3.30' addx6156 add '3' '3' -> '6' addx6157 add '3' '+3' -> '6' addx6158 add '3' '-3' -> '0' addx6159 add '0.3' '-0.3' -> '0.0' addx6160 add '0.03' '-0.03' -> '0.00' -- try borderline precision, with carries, etc. addx6161 add '1E+13' '-1' -> '9999999999999' addx6162 add '1E+13' '1.11' -> '10000000000001.11' addx6163 add '1.11' '1E+13' -> '10000000000001.11' addx6164 add '-1' '1E+13' -> '9999999999999' addx6165 add '7E+13' '-1' -> '69999999999999' addx6166 add '7E+13' '1.11' -> '70000000000001.11' addx6167 add '1.11' '7E+13' -> '70000000000001.11' addx6168 add '-1' '7E+13' -> '69999999999999' -- 1234567890123456 1234567890123456 1 234567890123456 addx6170 add '0.4444444444444444' '0.5555555555555563' -> '1.000000000000001' Inexact Rounded addx6171 add '0.4444444444444444' '0.5555555555555562' -> '1.000000000000001' Inexact Rounded addx6172 add '0.4444444444444444' '0.5555555555555561' -> '1.000000000000000' Inexact Rounded addx6173 add '0.4444444444444444' '0.5555555555555560' -> '1.000000000000000' Inexact Rounded addx6174 add '0.4444444444444444' '0.5555555555555559' -> '1.000000000000000' Inexact Rounded addx6175 add '0.4444444444444444' '0.5555555555555558' -> '1.000000000000000' Inexact Rounded addx6176 add '0.4444444444444444' '0.5555555555555557' -> '1.000000000000000' Inexact Rounded addx6177 add '0.4444444444444444' '0.5555555555555556' -> '1.000000000000000' Rounded addx6178 add '0.4444444444444444' '0.5555555555555555' -> '0.9999999999999999' addx6179 add '0.4444444444444444' '0.5555555555555554' -> '0.9999999999999998' addx6180 add '0.4444444444444444' '0.5555555555555553' -> '0.9999999999999997' addx6181 add '0.4444444444444444' '0.5555555555555552' -> '0.9999999999999996' addx6182 add '0.4444444444444444' '0.5555555555555551' -> '0.9999999999999995' addx6183 add '0.4444444444444444' '0.5555555555555550' -> '0.9999999999999994' -- and some more, including residue effects and different roundings rounding: half_up addx6200 add '6543210123456789' 0 -> '6543210123456789' addx6201 add '6543210123456789' 0.000000001 -> '6543210123456789' Inexact Rounded addx6202 add '6543210123456789' 0.000001 -> '6543210123456789' Inexact Rounded addx6203 add '6543210123456789' 0.1 -> '6543210123456789' Inexact Rounded addx6204 add '6543210123456789' 0.4 -> '6543210123456789' Inexact Rounded addx6205 add '6543210123456789' 0.49 -> '6543210123456789' Inexact Rounded addx6206 add '6543210123456789' 0.499999 -> '6543210123456789' Inexact Rounded addx6207 add '6543210123456789' 0.499999999 -> '6543210123456789' Inexact Rounded addx6208 add '6543210123456789' 0.5 -> '6543210123456790' Inexact Rounded addx6209 add '6543210123456789' 0.500000001 -> '6543210123456790' Inexact Rounded addx6210 add '6543210123456789' 0.500001 -> '6543210123456790' Inexact Rounded addx6211 add '6543210123456789' 0.51 -> '6543210123456790' Inexact Rounded addx6212 add '6543210123456789' 0.6 -> '6543210123456790' Inexact Rounded addx6213 add '6543210123456789' 0.9 -> '6543210123456790' Inexact Rounded addx6214 add '6543210123456789' 0.99999 -> '6543210123456790' Inexact Rounded addx6215 add '6543210123456789' 0.999999999 -> '6543210123456790' Inexact Rounded addx6216 add '6543210123456789' 1 -> '6543210123456790' addx6217 add '6543210123456789' 1.000000001 -> '6543210123456790' Inexact Rounded addx6218 add '6543210123456789' 1.00001 -> '6543210123456790' Inexact Rounded addx6219 add '6543210123456789' 1.1 -> '6543210123456790' Inexact Rounded rounding: half_even addx6220 add '6543210123456789' 0 -> '6543210123456789' addx6221 add '6543210123456789' 0.000000001 -> '6543210123456789' Inexact Rounded addx6222 add '6543210123456789' 0.000001 -> '6543210123456789' Inexact Rounded addx6223 add '6543210123456789' 0.1 -> '6543210123456789' Inexact Rounded addx6224 add '6543210123456789' 0.4 -> '6543210123456789' Inexact Rounded addx6225 add '6543210123456789' 0.49 -> '6543210123456789' Inexact Rounded addx6226 add '6543210123456789' 0.499999 -> '6543210123456789' Inexact Rounded addx6227 add '6543210123456789' 0.499999999 -> '6543210123456789' Inexact Rounded addx6228 add '6543210123456789' 0.5 -> '6543210123456790' Inexact Rounded addx6229 add '6543210123456789' 0.500000001 -> '6543210123456790' Inexact Rounded addx6230 add '6543210123456789' 0.500001 -> '6543210123456790' Inexact Rounded addx6231 add '6543210123456789' 0.51 -> '6543210123456790' Inexact Rounded addx6232 add '6543210123456789' 0.6 -> '6543210123456790' Inexact Rounded addx6233 add '6543210123456789' 0.9 -> '6543210123456790' Inexact Rounded addx6234 add '6543210123456789' 0.99999 -> '6543210123456790' Inexact Rounded addx6235 add '6543210123456789' 0.999999999 -> '6543210123456790' Inexact Rounded addx6236 add '6543210123456789' 1 -> '6543210123456790' addx6237 add '6543210123456789' 1.00000001 -> '6543210123456790' Inexact Rounded addx6238 add '6543210123456789' 1.00001 -> '6543210123456790' Inexact Rounded addx6239 add '6543210123456789' 1.1 -> '6543210123456790' Inexact Rounded -- critical few with even bottom digit... addx6240 add '6543210123456788' 0.499999999 -> '6543210123456788' Inexact Rounded addx6241 add '6543210123456788' 0.5 -> '6543210123456788' Inexact Rounded addx6242 add '6543210123456788' 0.500000001 -> '6543210123456789' Inexact Rounded rounding: down addx6250 add '6543210123456789' 0 -> '6543210123456789' addx6251 add '6543210123456789' 0.000000001 -> '6543210123456789' Inexact Rounded addx6252 add '6543210123456789' 0.000001 -> '6543210123456789' Inexact Rounded addx6253 add '6543210123456789' 0.1 -> '6543210123456789' Inexact Rounded addx6254 add '6543210123456789' 0.4 -> '6543210123456789' Inexact Rounded addx6255 add '6543210123456789' 0.49 -> '6543210123456789' Inexact Rounded addx6256 add '6543210123456789' 0.499999 -> '6543210123456789' Inexact Rounded addx6257 add '6543210123456789' 0.499999999 -> '6543210123456789' Inexact Rounded addx6258 add '6543210123456789' 0.5 -> '6543210123456789' Inexact Rounded addx6259 add '6543210123456789' 0.500000001 -> '6543210123456789' Inexact Rounded addx6260 add '6543210123456789' 0.500001 -> '6543210123456789' Inexact Rounded addx6261 add '6543210123456789' 0.51 -> '6543210123456789' Inexact Rounded addx6262 add '6543210123456789' 0.6 -> '6543210123456789' Inexact Rounded addx6263 add '6543210123456789' 0.9 -> '6543210123456789' Inexact Rounded addx6264 add '6543210123456789' 0.99999 -> '6543210123456789' Inexact Rounded addx6265 add '6543210123456789' 0.999999999 -> '6543210123456789' Inexact Rounded addx6266 add '6543210123456789' 1 -> '6543210123456790' addx6267 add '6543210123456789' 1.00000001 -> '6543210123456790' Inexact Rounded addx6268 add '6543210123456789' 1.00001 -> '6543210123456790' Inexact Rounded addx6269 add '6543210123456789' 1.1 -> '6543210123456790' Inexact Rounded -- 1 in last place tests rounding: half_even addx6301 add -1 1 -> 0 addx6302 add 0 1 -> 1 addx6303 add 1 1 -> 2 addx6304 add 12 1 -> 13 addx6305 add 98 1 -> 99 addx6306 add 99 1 -> 100 addx6307 add 100 1 -> 101 addx6308 add 101 1 -> 102 addx6309 add -1 -1 -> -2 addx6310 add 0 -1 -> -1 addx6311 add 1 -1 -> 0 addx6312 add 12 -1 -> 11 addx6313 add 98 -1 -> 97 addx6314 add 99 -1 -> 98 addx6315 add 100 -1 -> 99 addx6316 add 101 -1 -> 100 addx6321 add -0.01 0.01 -> 0.00 addx6322 add 0.00 0.01 -> 0.01 addx6323 add 0.01 0.01 -> 0.02 addx6324 add 0.12 0.01 -> 0.13 addx6325 add 0.98 0.01 -> 0.99 addx6326 add 0.99 0.01 -> 1.00 addx6327 add 1.00 0.01 -> 1.01 addx6328 add 1.01 0.01 -> 1.02 addx6329 add -0.01 -0.01 -> -0.02 addx6330 add 0.00 -0.01 -> -0.01 addx6331 add 0.01 -0.01 -> 0.00 addx6332 add 0.12 -0.01 -> 0.11 addx6333 add 0.98 -0.01 -> 0.97 addx6334 add 0.99 -0.01 -> 0.98 addx6335 add 1.00 -0.01 -> 0.99 addx6336 add 1.01 -0.01 -> 1.00 -- some more cases where adding 0 affects the coefficient addx6340 add 1E+3 0 -> 1000 addx6341 add 1E+15 0 -> 1000000000000000 addx6342 add 1E+16 0 -> 1.000000000000000E+16 Rounded addx6343 add 1E+17 0 -> 1.000000000000000E+17 Rounded -- which simply follow from these cases ... addx6344 add 1E+3 1 -> 1001 addx6345 add 1E+15 1 -> 1000000000000001 addx6346 add 1E+16 1 -> 1.000000000000000E+16 Inexact Rounded addx6347 add 1E+17 1 -> 1.000000000000000E+17 Inexact Rounded addx6348 add 1E+3 7 -> 1007 addx6349 add 1E+15 7 -> 1000000000000007 addx6350 add 1E+16 7 -> 1.000000000000001E+16 Inexact Rounded addx6351 add 1E+17 7 -> 1.000000000000000E+17 Inexact Rounded -- tryzeros cases addx6361 add 0E+50 10000E+1 -> 1.0000E+5 addx6362 add 10000E+1 0E-50 -> 100000.0000000000 Rounded addx6363 add 10000E+1 10000E-50 -> 100000.0000000000 Rounded Inexact addx6364 add 12.34 0e-398 -> 12.34000000000000 Rounded -- ulp replacement tests addx6400 add 1 77e-14 -> 1.00000000000077 addx6401 add 1 77e-15 -> 1.000000000000077 addx6402 add 1 77e-16 -> 1.000000000000008 Inexact Rounded addx6403 add 1 77e-17 -> 1.000000000000001 Inexact Rounded addx6404 add 1 77e-18 -> 1.000000000000000 Inexact Rounded addx6405 add 1 77e-19 -> 1.000000000000000 Inexact Rounded addx6406 add 1 77e-99 -> 1.000000000000000 Inexact Rounded addx6410 add 10 77e-14 -> 10.00000000000077 addx6411 add 10 77e-15 -> 10.00000000000008 Inexact Rounded addx6412 add 10 77e-16 -> 10.00000000000001 Inexact Rounded addx6413 add 10 77e-17 -> 10.00000000000000 Inexact Rounded addx6414 add 10 77e-18 -> 10.00000000000000 Inexact Rounded addx6415 add 10 77e-19 -> 10.00000000000000 Inexact Rounded addx6416 add 10 77e-99 -> 10.00000000000000 Inexact Rounded addx6420 add 77e-14 1 -> 1.00000000000077 addx6421 add 77e-15 1 -> 1.000000000000077 addx6422 add 77e-16 1 -> 1.000000000000008 Inexact Rounded addx6423 add 77e-17 1 -> 1.000000000000001 Inexact Rounded addx6424 add 77e-18 1 -> 1.000000000000000 Inexact Rounded addx6425 add 77e-19 1 -> 1.000000000000000 Inexact Rounded addx6426 add 77e-99 1 -> 1.000000000000000 Inexact Rounded addx6430 add 77e-14 10 -> 10.00000000000077 addx6431 add 77e-15 10 -> 10.00000000000008 Inexact Rounded addx6432 add 77e-16 10 -> 10.00000000000001 Inexact Rounded addx6433 add 77e-17 10 -> 10.00000000000000 Inexact Rounded addx6434 add 77e-18 10 -> 10.00000000000000 Inexact Rounded addx6435 add 77e-19 10 -> 10.00000000000000 Inexact Rounded addx6436 add 77e-99 10 -> 10.00000000000000 Inexact Rounded -- negative ulps addx6440 add 1 -77e-14 -> 0.99999999999923 addx6441 add 1 -77e-15 -> 0.999999999999923 addx6442 add 1 -77e-16 -> 0.9999999999999923 addx6443 add 1 -77e-17 -> 0.9999999999999992 Inexact Rounded addx6444 add 1 -77e-18 -> 0.9999999999999999 Inexact Rounded addx6445 add 1 -77e-19 -> 1.000000000000000 Inexact Rounded addx6446 add 1 -77e-99 -> 1.000000000000000 Inexact Rounded addx6450 add 10 -77e-14 -> 9.99999999999923 addx6451 add 10 -77e-15 -> 9.999999999999923 addx6452 add 10 -77e-16 -> 9.999999999999992 Inexact Rounded addx6453 add 10 -77e-17 -> 9.999999999999999 Inexact Rounded addx6454 add 10 -77e-18 -> 10.00000000000000 Inexact Rounded addx6455 add 10 -77e-19 -> 10.00000000000000 Inexact Rounded addx6456 add 10 -77e-99 -> 10.00000000000000 Inexact Rounded addx6460 add -77e-14 1 -> 0.99999999999923 addx6461 add -77e-15 1 -> 0.999999999999923 addx6462 add -77e-16 1 -> 0.9999999999999923 addx6463 add -77e-17 1 -> 0.9999999999999992 Inexact Rounded addx6464 add -77e-18 1 -> 0.9999999999999999 Inexact Rounded addx6465 add -77e-19 1 -> 1.000000000000000 Inexact Rounded addx6466 add -77e-99 1 -> 1.000000000000000 Inexact Rounded addx6470 add -77e-14 10 -> 9.99999999999923 addx6471 add -77e-15 10 -> 9.999999999999923 addx6472 add -77e-16 10 -> 9.999999999999992 Inexact Rounded addx6473 add -77e-17 10 -> 9.999999999999999 Inexact Rounded addx6474 add -77e-18 10 -> 10.00000000000000 Inexact Rounded addx6475 add -77e-19 10 -> 10.00000000000000 Inexact Rounded addx6476 add -77e-99 10 -> 10.00000000000000 Inexact Rounded -- negative ulps addx6480 add -1 77e-14 -> -0.99999999999923 addx6481 add -1 77e-15 -> -0.999999999999923 addx6482 add -1 77e-16 -> -0.9999999999999923 addx6483 add -1 77e-17 -> -0.9999999999999992 Inexact Rounded addx6484 add -1 77e-18 -> -0.9999999999999999 Inexact Rounded addx6485 add -1 77e-19 -> -1.000000000000000 Inexact Rounded addx6486 add -1 77e-99 -> -1.000000000000000 Inexact Rounded addx6490 add -10 77e-14 -> -9.99999999999923 addx6491 add -10 77e-15 -> -9.999999999999923 addx6492 add -10 77e-16 -> -9.999999999999992 Inexact Rounded addx6493 add -10 77e-17 -> -9.999999999999999 Inexact Rounded addx6494 add -10 77e-18 -> -10.00000000000000 Inexact Rounded addx6495 add -10 77e-19 -> -10.00000000000000 Inexact Rounded addx6496 add -10 77e-99 -> -10.00000000000000 Inexact Rounded addx6500 add 77e-14 -1 -> -0.99999999999923 addx6501 add 77e-15 -1 -> -0.999999999999923 addx6502 add 77e-16 -1 -> -0.9999999999999923 addx6503 add 77e-17 -1 -> -0.9999999999999992 Inexact Rounded addx6504 add 77e-18 -1 -> -0.9999999999999999 Inexact Rounded addx6505 add 77e-19 -1 -> -1.000000000000000 Inexact Rounded addx6506 add 77e-99 -1 -> -1.000000000000000 Inexact Rounded addx6510 add 77e-14 -10 -> -9.99999999999923 addx6511 add 77e-15 -10 -> -9.999999999999923 addx6512 add 77e-16 -10 -> -9.999999999999992 Inexact Rounded addx6513 add 77e-17 -10 -> -9.999999999999999 Inexact Rounded addx6514 add 77e-18 -10 -> -10.00000000000000 Inexact Rounded addx6515 add 77e-19 -10 -> -10.00000000000000 Inexact Rounded addx6516 add 77e-99 -10 -> -10.00000000000000 Inexact Rounded -- long operands addx6521 add 101234562345678000 0 -> 1.012345623456780E+17 Rounded addx6522 add 0 101234562345678000 -> 1.012345623456780E+17 Rounded addx6523 add 10123456234567800 0 -> 1.012345623456780E+16 Rounded addx6524 add 0 10123456234567800 -> 1.012345623456780E+16 Rounded addx6525 add 10123456234567890 0 -> 1.012345623456789E+16 Rounded addx6526 add 0 10123456234567890 -> 1.012345623456789E+16 Rounded addx6527 add 10123456234567891 0 -> 1.012345623456789E+16 Inexact Rounded addx6528 add 0 10123456234567891 -> 1.012345623456789E+16 Inexact Rounded addx6529 add 101234562345678901 0 -> 1.012345623456789E+17 Inexact Rounded addx6530 add 0 101234562345678901 -> 1.012345623456789E+17 Inexact Rounded addx6531 add 10123456234567896 0 -> 1.012345623456790E+16 Inexact Rounded addx6532 add 0 10123456234567896 -> 1.012345623456790E+16 Inexact Rounded -- verify a query rounding: down addx6561 add 1e-398 9.000000000000000E+384 -> 9.000000000000000E+384 Inexact Rounded addx6562 add 0 9.000000000000000E+384 -> 9.000000000000000E+384 Rounded -- and using decimal64 bounds... rounding: down addx6563 add 1e-388 9.000000000000000E+374 -> 9.000000000000000E+374 Inexact Rounded addx6564 add 0 9.000000000000000E+374 -> 9.000000000000000E+374 Rounded -- more zeros, etc. rounding: half_even addx6701 add 5.00 1.00E-3 -> 5.00100 addx6702 add 00.00 0.000 -> 0.000 addx6703 add 00.00 0E-3 -> 0.000 addx6704 add 0E-3 00.00 -> 0.000 addx6710 add 0E+3 00.00 -> 0.00 addx6711 add 0E+3 00.0 -> 0.0 addx6712 add 0E+3 00. -> 0 addx6713 add 0E+3 00.E+1 -> 0E+1 addx6714 add 0E+3 00.E+2 -> 0E+2 addx6715 add 0E+3 00.E+3 -> 0E+3 addx6716 add 0E+3 00.E+4 -> 0E+3 addx6717 add 0E+3 00.E+5 -> 0E+3 addx6718 add 0E+3 -00.0 -> 0.0 addx6719 add 0E+3 -00. -> 0 addx6731 add 0E+3 -00.E+1 -> 0E+1 addx6720 add 00.00 0E+3 -> 0.00 addx6721 add 00.0 0E+3 -> 0.0 addx6722 add 00. 0E+3 -> 0 addx6723 add 00.E+1 0E+3 -> 0E+1 addx6724 add 00.E+2 0E+3 -> 0E+2 addx6725 add 00.E+3 0E+3 -> 0E+3 addx6726 add 00.E+4 0E+3 -> 0E+3 addx6727 add 00.E+5 0E+3 -> 0E+3 addx6728 add -00.00 0E+3 -> 0.00 addx6729 add -00.0 0E+3 -> 0.0 addx6730 add -00. 0E+3 -> 0 addx6732 add 0 0 -> 0 addx6733 add 0 -0 -> 0 addx6734 add -0 0 -> 0 addx6735 add -0 -0 -> -0 -- IEEE 854 special case addx6736 add 1 -1 -> 0 addx6737 add -1 -1 -> -2 addx6738 add 1 1 -> 2 addx6739 add -1 1 -> 0 addx6741 add 0 -1 -> -1 addx6742 add -0 -1 -> -1 addx6743 add 0 1 -> 1 addx6744 add -0 1 -> 1 addx6745 add -1 0 -> -1 addx6746 add -1 -0 -> -1 addx6747 add 1 0 -> 1 addx6748 add 1 -0 -> 1 addx6751 add 0.0 -1 -> -1.0 addx6752 add -0.0 -1 -> -1.0 addx6753 add 0.0 1 -> 1.0 addx6754 add -0.0 1 -> 1.0 addx6755 add -1.0 0 -> -1.0 addx6756 add -1.0 -0 -> -1.0 addx6757 add 1.0 0 -> 1.0 addx6758 add 1.0 -0 -> 1.0 addx6761 add 0 -1.0 -> -1.0 addx6762 add -0 -1.0 -> -1.0 addx6763 add 0 1.0 -> 1.0 addx6764 add -0 1.0 -> 1.0 addx6765 add -1 0.0 -> -1.0 addx6766 add -1 -0.0 -> -1.0 addx6767 add 1 0.0 -> 1.0 addx6768 add 1 -0.0 -> 1.0 addx6771 add 0.0 -1.0 -> -1.0 addx6772 add -0.0 -1.0 -> -1.0 addx6773 add 0.0 1.0 -> 1.0 addx6774 add -0.0 1.0 -> 1.0 addx6775 add -1.0 0.0 -> -1.0 addx6776 add -1.0 -0.0 -> -1.0 addx6777 add 1.0 0.0 -> 1.0 addx6778 add 1.0 -0.0 -> 1.0 -- Specials addx6780 add -Inf -Inf -> -Infinity addx6781 add -Inf -1000 -> -Infinity addx6782 add -Inf -1 -> -Infinity addx6783 add -Inf -0 -> -Infinity addx6784 add -Inf 0 -> -Infinity addx6785 add -Inf 1 -> -Infinity addx6786 add -Inf 1000 -> -Infinity addx6787 add -1000 -Inf -> -Infinity addx6788 add -Inf -Inf -> -Infinity addx6789 add -1 -Inf -> -Infinity addx6790 add -0 -Inf -> -Infinity addx6791 add 0 -Inf -> -Infinity addx6792 add 1 -Inf -> -Infinity addx6793 add 1000 -Inf -> -Infinity addx6794 add Inf -Inf -> NaN Invalid_operation addx6800 add Inf -Inf -> NaN Invalid_operation addx6801 add Inf -1000 -> Infinity addx6802 add Inf -1 -> Infinity addx6803 add Inf -0 -> Infinity addx6804 add Inf 0 -> Infinity addx6805 add Inf 1 -> Infinity addx6806 add Inf 1000 -> Infinity addx6807 add Inf Inf -> Infinity addx6808 add -1000 Inf -> Infinity addx6809 add -Inf Inf -> NaN Invalid_operation addx6810 add -1 Inf -> Infinity addx6811 add -0 Inf -> Infinity addx6812 add 0 Inf -> Infinity addx6813 add 1 Inf -> Infinity addx6814 add 1000 Inf -> Infinity addx6815 add Inf Inf -> Infinity addx6821 add NaN -Inf -> NaN addx6822 add NaN -1000 -> NaN addx6823 add NaN -1 -> NaN addx6824 add NaN -0 -> NaN addx6825 add NaN 0 -> NaN addx6826 add NaN 1 -> NaN addx6827 add NaN 1000 -> NaN addx6828 add NaN Inf -> NaN addx6829 add NaN NaN -> NaN addx6830 add -Inf NaN -> NaN addx6831 add -1000 NaN -> NaN addx6832 add -1 NaN -> NaN addx6833 add -0 NaN -> NaN addx6834 add 0 NaN -> NaN addx6835 add 1 NaN -> NaN addx6836 add 1000 NaN -> NaN addx6837 add Inf NaN -> NaN addx6841 add sNaN -Inf -> NaN Invalid_operation addx6842 add sNaN -1000 -> NaN Invalid_operation addx6843 add sNaN -1 -> NaN Invalid_operation addx6844 add sNaN -0 -> NaN Invalid_operation addx6845 add sNaN 0 -> NaN Invalid_operation addx6846 add sNaN 1 -> NaN Invalid_operation addx6847 add sNaN 1000 -> NaN Invalid_operation addx6848 add sNaN NaN -> NaN Invalid_operation addx6849 add sNaN sNaN -> NaN Invalid_operation addx6850 add NaN sNaN -> NaN Invalid_operation addx6851 add -Inf sNaN -> NaN Invalid_operation addx6852 add -1000 sNaN -> NaN Invalid_operation addx6853 add -1 sNaN -> NaN Invalid_operation addx6854 add -0 sNaN -> NaN Invalid_operation addx6855 add 0 sNaN -> NaN Invalid_operation addx6856 add 1 sNaN -> NaN Invalid_operation addx6857 add 1000 sNaN -> NaN Invalid_operation addx6858 add Inf sNaN -> NaN Invalid_operation addx6859 add NaN sNaN -> NaN Invalid_operation -- propagating NaNs addx6861 add NaN1 -Inf -> NaN1 addx6862 add +NaN2 -1000 -> NaN2 addx6863 add NaN3 1000 -> NaN3 addx6864 add NaN4 Inf -> NaN4 addx6865 add NaN5 +NaN6 -> NaN5 addx6866 add -Inf NaN7 -> NaN7 addx6867 add -1000 NaN8 -> NaN8 addx6868 add 1000 NaN9 -> NaN9 addx6869 add Inf +NaN10 -> NaN10 addx6871 add sNaN11 -Inf -> NaN11 Invalid_operation addx6872 add sNaN12 -1000 -> NaN12 Invalid_operation addx6873 add sNaN13 1000 -> NaN13 Invalid_operation addx6874 add sNaN14 NaN17 -> NaN14 Invalid_operation addx6875 add sNaN15 sNaN18 -> NaN15 Invalid_operation addx6876 add NaN16 sNaN19 -> NaN19 Invalid_operation addx6877 add -Inf +sNaN20 -> NaN20 Invalid_operation addx6878 add -1000 sNaN21 -> NaN21 Invalid_operation addx6879 add 1000 sNaN22 -> NaN22 Invalid_operation addx6880 add Inf sNaN23 -> NaN23 Invalid_operation addx6881 add +NaN25 +sNaN24 -> NaN24 Invalid_operation addx6882 add -NaN26 NaN28 -> -NaN26 addx6883 add -sNaN27 sNaN29 -> -NaN27 Invalid_operation addx6884 add 1000 -NaN30 -> -NaN30 addx6885 add 1000 -sNaN31 -> -NaN31 Invalid_operation -- now the case where we can get underflow but the result is normal -- [note this can't happen if the operands are also bounded, as we -- cannot represent 1E-399, for example] addx6571 add 1E-383 0 -> 1E-383 addx6572 add 1E-384 0 -> 1E-384 Subnormal addx6573 add 1E-383 1E-384 -> 1.1E-383 addx6574 subtract 1E-383 1E-384 -> 9E-384 Subnormal -- Here we explore the boundary of rounding a subnormal to Nmin addx6575 subtract 1E-383 1E-398 -> 9.99999999999999E-384 Subnormal addx6576 subtract 1E-383 1E-398 -> 9.99999999999999E-384 Subnormal addx6577 subtract 1E-383 1E-399 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx6578 subtract 1E-383 1E-400 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx6579 subtract 1E-383 1E-401 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded addx6580 subtract 1E-383 1E-402 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded -- check overflow edge case -- 1234567890123456 addx6972 apply 9.999999999999999E+384 -> 9.999999999999999E+384 addx6973 add 9.999999999999999E+384 1 -> 9.999999999999999E+384 Inexact Rounded addx6974 add 9999999999999999E+369 1 -> 9.999999999999999E+384 Inexact Rounded addx6975 add 9999999999999999E+369 1E+369 -> Infinity Overflow Inexact Rounded addx6976 add 9999999999999999E+369 9E+368 -> Infinity Overflow Inexact Rounded addx6977 add 9999999999999999E+369 8E+368 -> Infinity Overflow Inexact Rounded addx6978 add 9999999999999999E+369 7E+368 -> Infinity Overflow Inexact Rounded addx6979 add 9999999999999999E+369 6E+368 -> Infinity Overflow Inexact Rounded addx6980 add 9999999999999999E+369 5E+368 -> Infinity Overflow Inexact Rounded addx6981 add 9999999999999999E+369 4E+368 -> 9.999999999999999E+384 Inexact Rounded addx6982 add 9999999999999999E+369 3E+368 -> 9.999999999999999E+384 Inexact Rounded addx6983 add 9999999999999999E+369 2E+368 -> 9.999999999999999E+384 Inexact Rounded addx6984 add 9999999999999999E+369 1E+368 -> 9.999999999999999E+384 Inexact Rounded addx6985 apply -9.999999999999999E+384 -> -9.999999999999999E+384 addx6986 add -9.999999999999999E+384 -1 -> -9.999999999999999E+384 Inexact Rounded addx6987 add -9999999999999999E+369 -1 -> -9.999999999999999E+384 Inexact Rounded addx6988 add -9999999999999999E+369 -1E+369 -> -Infinity Overflow Inexact Rounded addx6989 add -9999999999999999E+369 -9E+368 -> -Infinity Overflow Inexact Rounded addx6990 add -9999999999999999E+369 -8E+368 -> -Infinity Overflow Inexact Rounded addx6991 add -9999999999999999E+369 -7E+368 -> -Infinity Overflow Inexact Rounded addx6992 add -9999999999999999E+369 -6E+368 -> -Infinity Overflow Inexact Rounded addx6993 add -9999999999999999E+369 -5E+368 -> -Infinity Overflow Inexact Rounded addx6994 add -9999999999999999E+369 -4E+368 -> -9.999999999999999E+384 Inexact Rounded addx6995 add -9999999999999999E+369 -3E+368 -> -9.999999999999999E+384 Inexact Rounded addx6996 add -9999999999999999E+369 -2E+368 -> -9.999999999999999E+384 Inexact Rounded addx6997 add -9999999999999999E+369 -1E+368 -> -9.999999999999999E+384 Inexact Rounded -- And for round down full and subnormal results rounding: down addx61100 add 1e+2 -1e-383 -> 99.99999999999999 Rounded Inexact addx61101 add 1e+1 -1e-383 -> 9.999999999999999 Rounded Inexact addx61103 add +1 -1e-383 -> 0.9999999999999999 Rounded Inexact addx61104 add 1e-1 -1e-383 -> 0.09999999999999999 Rounded Inexact addx61105 add 1e-2 -1e-383 -> 0.009999999999999999 Rounded Inexact addx61106 add 1e-3 -1e-383 -> 0.0009999999999999999 Rounded Inexact addx61107 add 1e-4 -1e-383 -> 0.00009999999999999999 Rounded Inexact addx61108 add 1e-5 -1e-383 -> 0.000009999999999999999 Rounded Inexact addx61109 add 1e-6 -1e-383 -> 9.999999999999999E-7 Rounded Inexact rounding: ceiling addx61110 add -1e+2 +1e-383 -> -99.99999999999999 Rounded Inexact addx61111 add -1e+1 +1e-383 -> -9.999999999999999 Rounded Inexact addx61113 add -1 +1e-383 -> -0.9999999999999999 Rounded Inexact addx61114 add -1e-1 +1e-383 -> -0.09999999999999999 Rounded Inexact addx61115 add -1e-2 +1e-383 -> -0.009999999999999999 Rounded Inexact addx61116 add -1e-3 +1e-383 -> -0.0009999999999999999 Rounded Inexact addx61117 add -1e-4 +1e-383 -> -0.00009999999999999999 Rounded Inexact addx61118 add -1e-5 +1e-383 -> -0.000009999999999999999 Rounded Inexact addx61119 add -1e-6 +1e-383 -> -9.999999999999999E-7 Rounded Inexact -- tests based on Gunnar Degnbol's edge case rounding: half_even addx61300 add 1E16 -0.5 -> 1.000000000000000E+16 Inexact Rounded addx61310 add 1E16 -0.51 -> 9999999999999999 Inexact Rounded addx61311 add 1E16 -0.501 -> 9999999999999999 Inexact Rounded addx61312 add 1E16 -0.5001 -> 9999999999999999 Inexact Rounded addx61313 add 1E16 -0.50001 -> 9999999999999999 Inexact Rounded addx61314 add 1E16 -0.500001 -> 9999999999999999 Inexact Rounded addx61315 add 1E16 -0.5000001 -> 9999999999999999 Inexact Rounded addx61316 add 1E16 -0.50000001 -> 9999999999999999 Inexact Rounded addx61317 add 1E16 -0.500000001 -> 9999999999999999 Inexact Rounded addx61318 add 1E16 -0.5000000001 -> 9999999999999999 Inexact Rounded addx61319 add 1E16 -0.50000000001 -> 9999999999999999 Inexact Rounded addx61320 add 1E16 -0.500000000001 -> 9999999999999999 Inexact Rounded addx61321 add 1E16 -0.5000000000001 -> 9999999999999999 Inexact Rounded addx61322 add 1E16 -0.50000000000001 -> 9999999999999999 Inexact Rounded addx61323 add 1E16 -0.500000000000001 -> 9999999999999999 Inexact Rounded addx61324 add 1E16 -0.5000000000000001 -> 9999999999999999 Inexact Rounded addx61325 add 1E16 -0.5000000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61326 add 1E16 -0.500000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61327 add 1E16 -0.50000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61328 add 1E16 -0.5000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61329 add 1E16 -0.500000000000 -> 1.000000000000000E+16 Inexact Rounded addx61330 add 1E16 -0.50000000000 -> 1.000000000000000E+16 Inexact Rounded addx61331 add 1E16 -0.5000000000 -> 1.000000000000000E+16 Inexact Rounded addx61332 add 1E16 -0.500000000 -> 1.000000000000000E+16 Inexact Rounded addx61333 add 1E16 -0.50000000 -> 1.000000000000000E+16 Inexact Rounded addx61334 add 1E16 -0.5000000 -> 1.000000000000000E+16 Inexact Rounded addx61335 add 1E16 -0.500000 -> 1.000000000000000E+16 Inexact Rounded addx61336 add 1E16 -0.50000 -> 1.000000000000000E+16 Inexact Rounded addx61337 add 1E16 -0.5000 -> 1.000000000000000E+16 Inexact Rounded addx61338 add 1E16 -0.500 -> 1.000000000000000E+16 Inexact Rounded addx61339 add 1E16 -0.50 -> 1.000000000000000E+16 Inexact Rounded addx61340 add 1E16 -5000000.000010001 -> 9999999995000000 Inexact Rounded addx61341 add 1E16 -5000000.000000001 -> 9999999995000000 Inexact Rounded addx61349 add 9999999999999999 0.4 -> 9999999999999999 Inexact Rounded addx61350 add 9999999999999999 0.49 -> 9999999999999999 Inexact Rounded addx61351 add 9999999999999999 0.499 -> 9999999999999999 Inexact Rounded addx61352 add 9999999999999999 0.4999 -> 9999999999999999 Inexact Rounded addx61353 add 9999999999999999 0.49999 -> 9999999999999999 Inexact Rounded addx61354 add 9999999999999999 0.499999 -> 9999999999999999 Inexact Rounded addx61355 add 9999999999999999 0.4999999 -> 9999999999999999 Inexact Rounded addx61356 add 9999999999999999 0.49999999 -> 9999999999999999 Inexact Rounded addx61357 add 9999999999999999 0.499999999 -> 9999999999999999 Inexact Rounded addx61358 add 9999999999999999 0.4999999999 -> 9999999999999999 Inexact Rounded addx61359 add 9999999999999999 0.49999999999 -> 9999999999999999 Inexact Rounded addx61360 add 9999999999999999 0.499999999999 -> 9999999999999999 Inexact Rounded addx61361 add 9999999999999999 0.4999999999999 -> 9999999999999999 Inexact Rounded addx61362 add 9999999999999999 0.49999999999999 -> 9999999999999999 Inexact Rounded addx61363 add 9999999999999999 0.499999999999999 -> 9999999999999999 Inexact Rounded addx61364 add 9999999999999999 0.4999999999999999 -> 9999999999999999 Inexact Rounded addx61365 add 9999999999999999 0.5000000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61367 add 9999999999999999 0.500000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61368 add 9999999999999999 0.50000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61369 add 9999999999999999 0.5000000000000 -> 1.000000000000000E+16 Inexact Rounded addx61370 add 9999999999999999 0.500000000000 -> 1.000000000000000E+16 Inexact Rounded addx61371 add 9999999999999999 0.50000000000 -> 1.000000000000000E+16 Inexact Rounded addx61372 add 9999999999999999 0.5000000000 -> 1.000000000000000E+16 Inexact Rounded addx61373 add 9999999999999999 0.500000000 -> 1.000000000000000E+16 Inexact Rounded addx61374 add 9999999999999999 0.50000000 -> 1.000000000000000E+16 Inexact Rounded addx61375 add 9999999999999999 0.5000000 -> 1.000000000000000E+16 Inexact Rounded addx61376 add 9999999999999999 0.500000 -> 1.000000000000000E+16 Inexact Rounded addx61377 add 9999999999999999 0.50000 -> 1.000000000000000E+16 Inexact Rounded addx61378 add 9999999999999999 0.5000 -> 1.000000000000000E+16 Inexact Rounded addx61379 add 9999999999999999 0.500 -> 1.000000000000000E+16 Inexact Rounded addx61380 add 9999999999999999 0.50 -> 1.000000000000000E+16 Inexact Rounded addx61381 add 9999999999999999 0.5 -> 1.000000000000000E+16 Inexact Rounded addx61382 add 9999999999999999 0.5000000000000001 -> 1.000000000000000E+16 Inexact Rounded addx61383 add 9999999999999999 0.500000000000001 -> 1.000000000000000E+16 Inexact Rounded addx61384 add 9999999999999999 0.50000000000001 -> 1.000000000000000E+16 Inexact Rounded addx61385 add 9999999999999999 0.5000000000001 -> 1.000000000000000E+16 Inexact Rounded addx61386 add 9999999999999999 0.500000000001 -> 1.000000000000000E+16 Inexact Rounded addx61387 add 9999999999999999 0.50000000001 -> 1.000000000000000E+16 Inexact Rounded addx61388 add 9999999999999999 0.5000000001 -> 1.000000000000000E+16 Inexact Rounded addx61389 add 9999999999999999 0.500000001 -> 1.000000000000000E+16 Inexact Rounded addx61390 add 9999999999999999 0.50000001 -> 1.000000000000000E+16 Inexact Rounded addx61391 add 9999999999999999 0.5000001 -> 1.000000000000000E+16 Inexact Rounded addx61392 add 9999999999999999 0.500001 -> 1.000000000000000E+16 Inexact Rounded addx61393 add 9999999999999999 0.50001 -> 1.000000000000000E+16 Inexact Rounded addx61394 add 9999999999999999 0.5001 -> 1.000000000000000E+16 Inexact Rounded addx61395 add 9999999999999999 0.501 -> 1.000000000000000E+16 Inexact Rounded addx61396 add 9999999999999999 0.51 -> 1.000000000000000E+16 Inexact Rounded -- More GD edge cases, where difference between the unadjusted -- exponents is larger than the maximum precision and one side is 0 addx61420 add 0 1.123456789012345 -> 1.123456789012345 addx61421 add 0 1.123456789012345E-1 -> 0.1123456789012345 addx61422 add 0 1.123456789012345E-2 -> 0.01123456789012345 addx61423 add 0 1.123456789012345E-3 -> 0.001123456789012345 addx61424 add 0 1.123456789012345E-4 -> 0.0001123456789012345 addx61425 add 0 1.123456789012345E-5 -> 0.00001123456789012345 addx61426 add 0 1.123456789012345E-6 -> 0.000001123456789012345 addx61427 add 0 1.123456789012345E-7 -> 1.123456789012345E-7 addx61428 add 0 1.123456789012345E-8 -> 1.123456789012345E-8 addx61429 add 0 1.123456789012345E-9 -> 1.123456789012345E-9 addx61430 add 0 1.123456789012345E-10 -> 1.123456789012345E-10 addx61431 add 0 1.123456789012345E-11 -> 1.123456789012345E-11 addx61432 add 0 1.123456789012345E-12 -> 1.123456789012345E-12 addx61433 add 0 1.123456789012345E-13 -> 1.123456789012345E-13 addx61434 add 0 1.123456789012345E-14 -> 1.123456789012345E-14 addx61435 add 0 1.123456789012345E-15 -> 1.123456789012345E-15 addx61436 add 0 1.123456789012345E-16 -> 1.123456789012345E-16 addx61437 add 0 1.123456789012345E-17 -> 1.123456789012345E-17 addx61438 add 0 1.123456789012345E-18 -> 1.123456789012345E-18 addx61439 add 0 1.123456789012345E-19 -> 1.123456789012345E-19 -- same, reversed 0 addx61440 add 1.123456789012345 0 -> 1.123456789012345 addx61441 add 1.123456789012345E-1 0 -> 0.1123456789012345 addx61442 add 1.123456789012345E-2 0 -> 0.01123456789012345 addx61443 add 1.123456789012345E-3 0 -> 0.001123456789012345 addx61444 add 1.123456789012345E-4 0 -> 0.0001123456789012345 addx61445 add 1.123456789012345E-5 0 -> 0.00001123456789012345 addx61446 add 1.123456789012345E-6 0 -> 0.000001123456789012345 addx61447 add 1.123456789012345E-7 0 -> 1.123456789012345E-7 addx61448 add 1.123456789012345E-8 0 -> 1.123456789012345E-8 addx61449 add 1.123456789012345E-9 0 -> 1.123456789012345E-9 addx61450 add 1.123456789012345E-10 0 -> 1.123456789012345E-10 addx61451 add 1.123456789012345E-11 0 -> 1.123456789012345E-11 addx61452 add 1.123456789012345E-12 0 -> 1.123456789012345E-12 addx61453 add 1.123456789012345E-13 0 -> 1.123456789012345E-13 addx61454 add 1.123456789012345E-14 0 -> 1.123456789012345E-14 addx61455 add 1.123456789012345E-15 0 -> 1.123456789012345E-15 addx61456 add 1.123456789012345E-16 0 -> 1.123456789012345E-16 addx61457 add 1.123456789012345E-17 0 -> 1.123456789012345E-17 addx61458 add 1.123456789012345E-18 0 -> 1.123456789012345E-18 addx61459 add 1.123456789012345E-19 0 -> 1.123456789012345E-19 -- same, Es on the 0 addx61460 add 1.123456789012345 0E-0 -> 1.123456789012345 addx61461 add 1.123456789012345 0E-1 -> 1.123456789012345 addx61462 add 1.123456789012345 0E-2 -> 1.123456789012345 addx61463 add 1.123456789012345 0E-3 -> 1.123456789012345 addx61464 add 1.123456789012345 0E-4 -> 1.123456789012345 addx61465 add 1.123456789012345 0E-5 -> 1.123456789012345 addx61466 add 1.123456789012345 0E-6 -> 1.123456789012345 addx61467 add 1.123456789012345 0E-7 -> 1.123456789012345 addx61468 add 1.123456789012345 0E-8 -> 1.123456789012345 addx61469 add 1.123456789012345 0E-9 -> 1.123456789012345 addx61470 add 1.123456789012345 0E-10 -> 1.123456789012345 addx61471 add 1.123456789012345 0E-11 -> 1.123456789012345 addx61472 add 1.123456789012345 0E-12 -> 1.123456789012345 addx61473 add 1.123456789012345 0E-13 -> 1.123456789012345 addx61474 add 1.123456789012345 0E-14 -> 1.123456789012345 addx61475 add 1.123456789012345 0E-15 -> 1.123456789012345 -- next four flag Rounded because the 0 extends the result addx61476 add 1.123456789012345 0E-16 -> 1.123456789012345 Rounded addx61477 add 1.123456789012345 0E-17 -> 1.123456789012345 Rounded addx61478 add 1.123456789012345 0E-18 -> 1.123456789012345 Rounded addx61479 add 1.123456789012345 0E-19 -> 1.123456789012345 Rounded -- sum of two opposite-sign operands is exactly 0 and floor => -0 rounding: half_up -- exact zeros from zeros addx61500 add 0 0E-19 -> 0E-19 addx61501 add -0 0E-19 -> 0E-19 addx61502 add 0 -0E-19 -> 0E-19 addx61503 add -0 -0E-19 -> -0E-19 addx61504 add 0E-400 0E-19 -> 0E-398 Clamped addx61505 add -0E-400 0E-19 -> 0E-398 Clamped addx61506 add 0E-400 -0E-19 -> 0E-398 Clamped addx61507 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61511 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61512 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61513 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx61514 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx61515 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61516 add -1E-401 1E-401 -> 0E-398 Clamped addx61517 add 1E-401 -1E-401 -> 0E-398 Clamped addx61518 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: half_down -- exact zeros from zeros addx61520 add 0 0E-19 -> 0E-19 addx61521 add -0 0E-19 -> 0E-19 addx61522 add 0 -0E-19 -> 0E-19 addx61523 add -0 -0E-19 -> -0E-19 addx61524 add 0E-400 0E-19 -> 0E-398 Clamped addx61525 add -0E-400 0E-19 -> 0E-398 Clamped addx61526 add 0E-400 -0E-19 -> 0E-398 Clamped addx61527 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61531 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61532 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61533 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx61534 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx61535 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61536 add -1E-401 1E-401 -> 0E-398 Clamped addx61537 add 1E-401 -1E-401 -> 0E-398 Clamped addx61538 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: half_even -- exact zeros from zeros addx61540 add 0 0E-19 -> 0E-19 addx61541 add -0 0E-19 -> 0E-19 addx61542 add 0 -0E-19 -> 0E-19 addx61543 add -0 -0E-19 -> -0E-19 addx61544 add 0E-400 0E-19 -> 0E-398 Clamped addx61545 add -0E-400 0E-19 -> 0E-398 Clamped addx61546 add 0E-400 -0E-19 -> 0E-398 Clamped addx61547 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61551 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61552 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61553 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx61554 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx61555 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61556 add -1E-401 1E-401 -> 0E-398 Clamped addx61557 add 1E-401 -1E-401 -> 0E-398 Clamped addx61558 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: up -- exact zeros from zeros addx61560 add 0 0E-19 -> 0E-19 addx61561 add -0 0E-19 -> 0E-19 addx61562 add 0 -0E-19 -> 0E-19 addx61563 add -0 -0E-19 -> -0E-19 addx61564 add 0E-400 0E-19 -> 0E-398 Clamped addx61565 add -0E-400 0E-19 -> 0E-398 Clamped addx61566 add 0E-400 -0E-19 -> 0E-398 Clamped addx61567 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61571 add 1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx61572 add -1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx61573 add 1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow addx61574 add -1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow -- some exact zeros from non-zeros addx61575 add 1E-401 1E-401 -> 1E-398 Subnormal Inexact Rounded Underflow addx61576 add -1E-401 1E-401 -> 0E-398 Clamped addx61577 add 1E-401 -1E-401 -> 0E-398 Clamped addx61578 add -1E-401 -1E-401 -> -1E-398 Subnormal Inexact Rounded Underflow rounding: down -- exact zeros from zeros addx61580 add 0 0E-19 -> 0E-19 addx61581 add -0 0E-19 -> 0E-19 addx61582 add 0 -0E-19 -> 0E-19 addx61583 add -0 -0E-19 -> -0E-19 addx61584 add 0E-400 0E-19 -> 0E-398 Clamped addx61585 add -0E-400 0E-19 -> 0E-398 Clamped addx61586 add 0E-400 -0E-19 -> 0E-398 Clamped addx61587 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61591 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61592 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61593 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx61594 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx61595 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61596 add -1E-401 1E-401 -> 0E-398 Clamped addx61597 add 1E-401 -1E-401 -> 0E-398 Clamped addx61598 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped rounding: ceiling -- exact zeros from zeros addx61600 add 0 0E-19 -> 0E-19 addx61601 add -0 0E-19 -> 0E-19 addx61602 add 0 -0E-19 -> 0E-19 addx61603 add -0 -0E-19 -> -0E-19 addx61604 add 0E-400 0E-19 -> 0E-398 Clamped addx61605 add -0E-400 0E-19 -> 0E-398 Clamped addx61606 add 0E-400 -0E-19 -> 0E-398 Clamped addx61607 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61611 add 1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx61612 add -1E-401 1E-400 -> 1E-398 Subnormal Inexact Rounded Underflow addx61613 add 1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped addx61614 add -1E-401 -1E-400 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- some exact zeros from non-zeros addx61615 add 1E-401 1E-401 -> 1E-398 Subnormal Inexact Rounded Underflow addx61616 add -1E-401 1E-401 -> 0E-398 Clamped addx61617 add 1E-401 -1E-401 -> 0E-398 Clamped addx61618 add -1E-401 -1E-401 -> -0E-398 Subnormal Inexact Rounded Underflow Clamped -- and the extra-special ugly case; unusual minuses marked by -- * rounding: floor -- exact zeros from zeros addx61620 add 0 0E-19 -> 0E-19 addx61621 add -0 0E-19 -> -0E-19 -- * addx61622 add 0 -0E-19 -> -0E-19 -- * addx61623 add -0 -0E-19 -> -0E-19 addx61624 add 0E-400 0E-19 -> 0E-398 Clamped addx61625 add -0E-400 0E-19 -> -0E-398 Clamped -- * addx61626 add 0E-400 -0E-19 -> -0E-398 Clamped -- * addx61627 add -0E-400 -0E-19 -> -0E-398 Clamped -- inexact zeros addx61631 add 1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61632 add -1E-401 1E-400 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61633 add 1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow addx61634 add -1E-401 -1E-400 -> -1E-398 Subnormal Inexact Rounded Underflow -- some exact zeros from non-zeros addx61635 add 1E-401 1E-401 -> 0E-398 Subnormal Inexact Rounded Underflow Clamped addx61636 add -1E-401 1E-401 -> -0E-398 Clamped -- * addx61637 add 1E-401 -1E-401 -> -0E-398 Clamped -- * addx61638 add -1E-401 -1E-401 -> -1E-398 Subnormal Inexact Rounded Underflow -- Examples from SQL proposal (Krishna Kulkarni) addx61701 add 130E-2 120E-2 -> 2.50 addx61702 add 130E-2 12E-1 -> 2.50 addx61703 add 130E-2 1E0 -> 2.30 addx61704 add 1E2 1E4 -> 1.01E+4 addx61705 subtract 130E-2 120E-2 -> 0.10 addx61706 subtract 130E-2 12E-1 -> 0.10 addx61707 subtract 130E-2 1E0 -> 0.30 addx61708 subtract 1E2 1E4 -> -9.9E+3 -- Gappy coefficients; check residue handling even with full coefficient gap rounding: half_even addx62001 add 1234567890123456 1 -> 1234567890123457 addx62002 add 1234567890123456 0.6 -> 1234567890123457 Inexact Rounded addx62003 add 1234567890123456 0.06 -> 1234567890123456 Inexact Rounded addx62004 add 1234567890123456 6E-3 -> 1234567890123456 Inexact Rounded addx62005 add 1234567890123456 6E-4 -> 1234567890123456 Inexact Rounded addx62006 add 1234567890123456 6E-5 -> 1234567890123456 Inexact Rounded addx62007 add 1234567890123456 6E-6 -> 1234567890123456 Inexact Rounded addx62008 add 1234567890123456 6E-7 -> 1234567890123456 Inexact Rounded addx62009 add 1234567890123456 6E-8 -> 1234567890123456 Inexact Rounded addx62010 add 1234567890123456 6E-9 -> 1234567890123456 Inexact Rounded addx62011 add 1234567890123456 6E-10 -> 1234567890123456 Inexact Rounded addx62012 add 1234567890123456 6E-11 -> 1234567890123456 Inexact Rounded addx62013 add 1234567890123456 6E-12 -> 1234567890123456 Inexact Rounded addx62014 add 1234567890123456 6E-13 -> 1234567890123456 Inexact Rounded addx62015 add 1234567890123456 6E-14 -> 1234567890123456 Inexact Rounded addx62016 add 1234567890123456 6E-15 -> 1234567890123456 Inexact Rounded addx62017 add 1234567890123456 6E-16 -> 1234567890123456 Inexact Rounded addx62018 add 1234567890123456 6E-17 -> 1234567890123456 Inexact Rounded addx62019 add 1234567890123456 6E-18 -> 1234567890123456 Inexact Rounded addx62020 add 1234567890123456 6E-19 -> 1234567890123456 Inexact Rounded addx62021 add 1234567890123456 6E-20 -> 1234567890123456 Inexact Rounded -- widening second argument at gap addx62030 add 12345678 1 -> 12345679 addx62031 add 12345678 0.1 -> 12345678.1 addx62032 add 12345678 0.12 -> 12345678.12 addx62033 add 12345678 0.123 -> 12345678.123 addx62034 add 12345678 0.1234 -> 12345678.1234 addx62035 add 12345678 0.12345 -> 12345678.12345 addx62036 add 12345678 0.123456 -> 12345678.123456 addx62037 add 12345678 0.1234567 -> 12345678.1234567 addx62038 add 12345678 0.12345678 -> 12345678.12345678 addx62039 add 12345678 0.123456789 -> 12345678.12345679 Inexact Rounded addx62040 add 12345678 0.123456785 -> 12345678.12345678 Inexact Rounded addx62041 add 12345678 0.1234567850 -> 12345678.12345678 Inexact Rounded addx62042 add 12345678 0.1234567851 -> 12345678.12345679 Inexact Rounded addx62043 add 12345678 0.12345678501 -> 12345678.12345679 Inexact Rounded addx62044 add 12345678 0.123456785001 -> 12345678.12345679 Inexact Rounded addx62045 add 12345678 0.1234567850001 -> 12345678.12345679 Inexact Rounded addx62046 add 12345678 0.12345678500001 -> 12345678.12345679 Inexact Rounded addx62047 add 12345678 0.123456785000001 -> 12345678.12345679 Inexact Rounded addx62048 add 12345678 0.1234567850000001 -> 12345678.12345679 Inexact Rounded addx62049 add 12345678 0.1234567850000000 -> 12345678.12345678 Inexact Rounded -- 90123456 rounding: half_even addx62050 add 12345678 0.0234567750000000 -> 12345678.02345678 Inexact Rounded addx62051 add 12345678 0.0034567750000000 -> 12345678.00345678 Inexact Rounded addx62052 add 12345678 0.0004567750000000 -> 12345678.00045678 Inexact Rounded addx62053 add 12345678 0.0000567750000000 -> 12345678.00005678 Inexact Rounded addx62054 add 12345678 0.0000067750000000 -> 12345678.00000678 Inexact Rounded addx62055 add 12345678 0.0000007750000000 -> 12345678.00000078 Inexact Rounded addx62056 add 12345678 0.0000000750000000 -> 12345678.00000008 Inexact Rounded addx62057 add 12345678 0.0000000050000000 -> 12345678.00000000 Inexact Rounded addx62060 add 12345678 0.0234567750000001 -> 12345678.02345678 Inexact Rounded addx62061 add 12345678 0.0034567750000001 -> 12345678.00345678 Inexact Rounded addx62062 add 12345678 0.0004567750000001 -> 12345678.00045678 Inexact Rounded addx62063 add 12345678 0.0000567750000001 -> 12345678.00005678 Inexact Rounded addx62064 add 12345678 0.0000067750000001 -> 12345678.00000678 Inexact Rounded addx62065 add 12345678 0.0000007750000001 -> 12345678.00000078 Inexact Rounded addx62066 add 12345678 0.0000000750000001 -> 12345678.00000008 Inexact Rounded addx62067 add 12345678 0.0000000050000001 -> 12345678.00000001 Inexact Rounded -- far-out residues (full coefficient gap is 16+15 digits) rounding: up addx62070 add 12345678 1E-8 -> 12345678.00000001 addx62071 add 12345678 1E-9 -> 12345678.00000001 Inexact Rounded addx62072 add 12345678 1E-10 -> 12345678.00000001 Inexact Rounded addx62073 add 12345678 1E-11 -> 12345678.00000001 Inexact Rounded addx62074 add 12345678 1E-12 -> 12345678.00000001 Inexact Rounded addx62075 add 12345678 1E-13 -> 12345678.00000001 Inexact Rounded addx62076 add 12345678 1E-14 -> 12345678.00000001 Inexact Rounded addx62077 add 12345678 1E-15 -> 12345678.00000001 Inexact Rounded addx62078 add 12345678 1E-16 -> 12345678.00000001 Inexact Rounded addx62079 add 12345678 1E-17 -> 12345678.00000001 Inexact Rounded addx62080 add 12345678 1E-18 -> 12345678.00000001 Inexact Rounded addx62081 add 12345678 1E-19 -> 12345678.00000001 Inexact Rounded addx62082 add 12345678 1E-20 -> 12345678.00000001 Inexact Rounded addx62083 add 12345678 1E-25 -> 12345678.00000001 Inexact Rounded addx62084 add 12345678 1E-30 -> 12345678.00000001 Inexact Rounded addx62085 add 12345678 1E-31 -> 12345678.00000001 Inexact Rounded addx62086 add 12345678 1E-32 -> 12345678.00000001 Inexact Rounded addx62087 add 12345678 1E-33 -> 12345678.00000001 Inexact Rounded addx62088 add 12345678 1E-34 -> 12345678.00000001 Inexact Rounded addx62089 add 12345678 1E-35 -> 12345678.00000001 Inexact Rounded -- payload decapitate precision: 5 addx62100 add 11 sNaN123456789 -> NaN56789 Invalid_operation addx62101 add -11 -sNaN123456789 -> -NaN56789 Invalid_operation addx62102 add 11 NaN123456789 -> NaN56789 addx62103 add -11 -NaN123456789 -> -NaN56789 -- Null tests addx9990 add 10 # -> NaN Invalid_operation addx9991 add # 10 -> NaN Invalid_operation apd-3.2.1/testdata/base.decTest000066400000000000000000001723441450022325000163250ustar00rootroot00000000000000------------------------------------------------------------------------ -- base.decTest -- base decimal <--> string conversions -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 -- This file tests base conversions from string to a decimal number -- and back to a string (in either Scientific or Engineering form) -- Note that unlike other operations the operand is subject to rounding -- to conform to emax and precision settings (that is, numbers will -- conform to rules and exponent will be in permitted range). precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 basx001 toSci 0 -> 0 basx002 toSci 1 -> 1 basx003 toSci 1.0 -> 1.0 basx004 toSci 1.00 -> 1.00 basx005 toSci 10 -> 10 basx006 toSci 1000 -> 1000 basx007 toSci 10.0 -> 10.0 basx008 toSci 10.1 -> 10.1 basx009 toSci 10.4 -> 10.4 basx010 toSci 10.5 -> 10.5 basx011 toSci 10.6 -> 10.6 basx012 toSci 10.9 -> 10.9 basx013 toSci 11.0 -> 11.0 basx014 toSci 1.234 -> 1.234 basx015 toSci 0.123 -> 0.123 basx016 toSci 0.012 -> 0.012 basx017 toSci -0 -> -0 basx018 toSci -0.0 -> -0.0 basx019 toSci -00.00 -> -0.00 basx021 toSci -1 -> -1 basx022 toSci -1.0 -> -1.0 basx023 toSci -0.1 -> -0.1 basx024 toSci -9.1 -> -9.1 basx025 toSci -9.11 -> -9.11 basx026 toSci -9.119 -> -9.119 basx027 toSci -9.999 -> -9.999 basx030 toSci '123456789.123456' -> '123456789.123456' basx031 toSci '123456789.000000' -> '123456789.000000' basx032 toSci '123456789123456' -> '123456789123456' basx033 toSci '0.0000123456789' -> '0.0000123456789' basx034 toSci '0.00000123456789' -> '0.00000123456789' basx035 toSci '0.000000123456789' -> '1.23456789E-7' basx036 toSci '0.0000000123456789' -> '1.23456789E-8' basx037 toSci '0.123456789012344' -> '0.123456789012344' basx038 toSci '0.123456789012345' -> '0.123456789012345' -- String [many more examples are implicitly tested elsewhere] -- strings without E cannot generate E in result basx040 toSci "12" -> '12' basx041 toSci "-76" -> '-76' basx042 toSci "12.76" -> '12.76' basx043 toSci "+12.76" -> '12.76' basx044 toSci "012.76" -> '12.76' basx045 toSci "+0.003" -> '0.003' basx046 toSci "17." -> '17' basx047 toSci ".5" -> '0.5' basx048 toSci "044" -> '44' basx049 toSci "0044" -> '44' basx050 toSci "0.0005" -> '0.0005' basx051 toSci "00.00005" -> '0.00005' basx052 toSci "0.000005" -> '0.000005' basx053 toSci "0.0000050" -> '0.0000050' basx054 toSci "0.0000005" -> '5E-7' basx055 toSci "0.00000005" -> '5E-8' basx056 toSci "12345678.543210" -> '12345678.543210' basx057 toSci "2345678.543210" -> '2345678.543210' basx058 toSci "345678.543210" -> '345678.543210' basx059 toSci "0345678.54321" -> '345678.54321' basx060 toSci "345678.5432" -> '345678.5432' basx061 toSci "+345678.5432" -> '345678.5432' basx062 toSci "+0345678.5432" -> '345678.5432' basx063 toSci "+00345678.5432" -> '345678.5432' basx064 toSci "-345678.5432" -> '-345678.5432' basx065 toSci "-0345678.5432" -> '-345678.5432' basx066 toSci "-00345678.5432" -> '-345678.5432' -- examples basx067 toSci "5E-6" -> '0.000005' basx068 toSci "50E-7" -> '0.0000050' basx069 toSci "5E-7" -> '5E-7' -- [No exotics as no Unicode] -- rounded with dots in all (including edge) places basx071 toSci .1234567890123456123 -> 0.1234567890123456 Inexact Rounded basx072 toSci 1.234567890123456123 -> 1.234567890123456 Inexact Rounded basx073 toSci 12.34567890123456123 -> 12.34567890123456 Inexact Rounded basx074 toSci 123.4567890123456123 -> 123.4567890123456 Inexact Rounded basx075 toSci 1234.567890123456123 -> 1234.567890123456 Inexact Rounded basx076 toSci 12345.67890123456123 -> 12345.67890123456 Inexact Rounded basx077 toSci 123456.7890123456123 -> 123456.7890123456 Inexact Rounded basx078 toSci 1234567.890123456123 -> 1234567.890123456 Inexact Rounded basx079 toSci 12345678.90123456123 -> 12345678.90123456 Inexact Rounded basx080 toSci 123456789.0123456123 -> 123456789.0123456 Inexact Rounded basx081 toSci 1234567890.123456123 -> 1234567890.123456 Inexact Rounded basx082 toSci 12345678901.23456123 -> 12345678901.23456 Inexact Rounded basx083 toSci 123456789012.3456123 -> 123456789012.3456 Inexact Rounded basx084 toSci 1234567890123.456123 -> 1234567890123.456 Inexact Rounded basx085 toSci 12345678901234.56123 -> 12345678901234.56 Inexact Rounded basx086 toSci 123456789012345.6123 -> 123456789012345.6 Inexact Rounded basx087 toSci 1234567890123456.123 -> 1234567890123456 Inexact Rounded basx088 toSci 12345678901234561.23 -> 1.234567890123456E+16 Inexact Rounded basx089 toSci 123456789012345612.3 -> 1.234567890123456E+17 Inexact Rounded basx090 toSci 1234567890123456123. -> 1.234567890123456E+18 Inexact Rounded -- Numbers with E basx130 toSci "0.000E-1" -> '0.0000' basx131 toSci "0.000E-2" -> '0.00000' basx132 toSci "0.000E-3" -> '0.000000' basx133 toSci "0.000E-4" -> '0E-7' basx134 toSci "0.00E-2" -> '0.0000' basx135 toSci "0.00E-3" -> '0.00000' basx136 toSci "0.00E-4" -> '0.000000' basx137 toSci "0.00E-5" -> '0E-7' basx138 toSci "+0E+9" -> '0E+9' basx139 toSci "-0E+9" -> '-0E+9' basx140 toSci "1E+9" -> '1E+9' basx141 toSci "1e+09" -> '1E+9' basx142 toSci "1E+90" -> '1E+90' basx143 toSci "+1E+009" -> '1E+9' basx144 toSci "0E+9" -> '0E+9' basx145 toSci "1E+9" -> '1E+9' basx146 toSci "1E+09" -> '1E+9' basx147 toSci "1e+90" -> '1E+90' basx148 toSci "1E+009" -> '1E+9' basx149 toSci "000E+9" -> '0E+9' basx150 toSci "1E9" -> '1E+9' basx151 toSci "1e09" -> '1E+9' basx152 toSci "1E90" -> '1E+90' basx153 toSci "1E009" -> '1E+9' basx154 toSci "0E9" -> '0E+9' basx155 toSci "0.000e+0" -> '0.000' basx156 toSci "0.000E-1" -> '0.0000' basx157 toSci "4E+9" -> '4E+9' basx158 toSci "44E+9" -> '4.4E+10' basx159 toSci "0.73e-7" -> '7.3E-8' basx160 toSci "00E+9" -> '0E+9' basx161 toSci "00E-9" -> '0E-9' basx162 toSci "10E+9" -> '1.0E+10' basx163 toSci "10E+09" -> '1.0E+10' basx164 toSci "10e+90" -> '1.0E+91' basx165 toSci "10E+009" -> '1.0E+10' basx166 toSci "100e+9" -> '1.00E+11' basx167 toSci "100e+09" -> '1.00E+11' basx168 toSci "100E+90" -> '1.00E+92' basx169 toSci "100e+009" -> '1.00E+11' basx170 toSci "1.265" -> '1.265' basx171 toSci "1.265E-20" -> '1.265E-20' basx172 toSci "1.265E-8" -> '1.265E-8' basx173 toSci "1.265E-4" -> '0.0001265' basx174 toSci "1.265E-3" -> '0.001265' basx175 toSci "1.265E-2" -> '0.01265' basx176 toSci "1.265E-1" -> '0.1265' basx177 toSci "1.265E-0" -> '1.265' basx178 toSci "1.265E+1" -> '12.65' basx179 toSci "1.265E+2" -> '126.5' basx180 toSci "1.265E+3" -> '1265' basx181 toSci "1.265E+4" -> '1.265E+4' basx182 toSci "1.265E+8" -> '1.265E+8' basx183 toSci "1.265E+20" -> '1.265E+20' basx190 toSci "12.65" -> '12.65' basx191 toSci "12.65E-20" -> '1.265E-19' basx192 toSci "12.65E-8" -> '1.265E-7' basx193 toSci "12.65E-4" -> '0.001265' basx194 toSci "12.65E-3" -> '0.01265' basx195 toSci "12.65E-2" -> '0.1265' basx196 toSci "12.65E-1" -> '1.265' basx197 toSci "12.65E-0" -> '12.65' basx198 toSci "12.65E+1" -> '126.5' basx199 toSci "12.65E+2" -> '1265' basx200 toSci "12.65E+3" -> '1.265E+4' basx201 toSci "12.65E+4" -> '1.265E+5' basx202 toSci "12.65E+8" -> '1.265E+9' basx203 toSci "12.65E+20" -> '1.265E+21' basx210 toSci "126.5" -> '126.5' basx211 toSci "126.5E-20" -> '1.265E-18' basx212 toSci "126.5E-8" -> '0.000001265' basx213 toSci "126.5E-4" -> '0.01265' basx214 toSci "126.5E-3" -> '0.1265' basx215 toSci "126.5E-2" -> '1.265' basx216 toSci "126.5E-1" -> '12.65' basx217 toSci "126.5E-0" -> '126.5' basx218 toSci "126.5E+1" -> '1265' basx219 toSci "126.5E+2" -> '1.265E+4' basx220 toSci "126.5E+3" -> '1.265E+5' basx221 toSci "126.5E+4" -> '1.265E+6' basx222 toSci "126.5E+8" -> '1.265E+10' basx223 toSci "126.5E+20" -> '1.265E+22' basx230 toSci "1265" -> '1265' basx231 toSci "1265E-20" -> '1.265E-17' basx232 toSci "1265E-8" -> '0.00001265' basx233 toSci "1265E-4" -> '0.1265' basx234 toSci "1265E-3" -> '1.265' basx235 toSci "1265E-2" -> '12.65' basx236 toSci "1265E-1" -> '126.5' basx237 toSci "1265E-0" -> '1265' basx238 toSci "1265E+1" -> '1.265E+4' basx239 toSci "1265E+2" -> '1.265E+5' basx240 toSci "1265E+3" -> '1.265E+6' basx241 toSci "1265E+4" -> '1.265E+7' basx242 toSci "1265E+8" -> '1.265E+11' basx243 toSci "1265E+20" -> '1.265E+23' basx250 toSci "0.1265" -> '0.1265' basx251 toSci "0.1265E-20" -> '1.265E-21' basx252 toSci "0.1265E-8" -> '1.265E-9' basx253 toSci "0.1265E-4" -> '0.00001265' basx254 toSci "0.1265E-3" -> '0.0001265' basx255 toSci "0.1265E-2" -> '0.001265' basx256 toSci "0.1265E-1" -> '0.01265' basx257 toSci "0.1265E-0" -> '0.1265' basx258 toSci "0.1265E+1" -> '1.265' basx259 toSci "0.1265E+2" -> '12.65' basx260 toSci "0.1265E+3" -> '126.5' basx261 toSci "0.1265E+4" -> '1265' basx262 toSci "0.1265E+8" -> '1.265E+7' basx263 toSci "0.1265E+20" -> '1.265E+19' -- some more negative zeros [systematic tests below] basx290 toSci "-0.000E-1" -> '-0.0000' basx291 toSci "-0.000E-2" -> '-0.00000' basx292 toSci "-0.000E-3" -> '-0.000000' basx293 toSci "-0.000E-4" -> '-0E-7' basx294 toSci "-0.00E-2" -> '-0.0000' basx295 toSci "-0.00E-3" -> '-0.00000' basx296 toSci "-0.0E-2" -> '-0.000' basx297 toSci "-0.0E-3" -> '-0.0000' basx298 toSci "-0E-2" -> '-0.00' basx299 toSci "-0E-3" -> '-0.000' -- Engineering notation tests basx301 toSci 10e12 -> 1.0E+13 basx302 toEng 10e12 -> 10E+12 basx303 toSci 10e11 -> 1.0E+12 basx304 toEng 10e11 -> 1.0E+12 basx305 toSci 10e10 -> 1.0E+11 basx306 toEng 10e10 -> 100E+9 basx307 toSci 10e9 -> 1.0E+10 basx308 toEng 10e9 -> 10E+9 basx309 toSci 10e8 -> 1.0E+9 basx310 toEng 10e8 -> 1.0E+9 basx311 toSci 10e7 -> 1.0E+8 basx312 toEng 10e7 -> 100E+6 basx313 toSci 10e6 -> 1.0E+7 basx314 toEng 10e6 -> 10E+6 basx315 toSci 10e5 -> 1.0E+6 basx316 toEng 10e5 -> 1.0E+6 basx317 toSci 10e4 -> 1.0E+5 basx318 toEng 10e4 -> 100E+3 basx319 toSci 10e3 -> 1.0E+4 basx320 toEng 10e3 -> 10E+3 basx321 toSci 10e2 -> 1.0E+3 basx322 toEng 10e2 -> 1.0E+3 basx323 toSci 10e1 -> 1.0E+2 basx324 toEng 10e1 -> 100 basx325 toSci 10e0 -> 10 basx326 toEng 10e0 -> 10 basx327 toSci 10e-1 -> 1.0 basx328 toEng 10e-1 -> 1.0 basx329 toSci 10e-2 -> 0.10 basx330 toEng 10e-2 -> 0.10 basx331 toSci 10e-3 -> 0.010 basx332 toEng 10e-3 -> 0.010 basx333 toSci 10e-4 -> 0.0010 basx334 toEng 10e-4 -> 0.0010 basx335 toSci 10e-5 -> 0.00010 basx336 toEng 10e-5 -> 0.00010 basx337 toSci 10e-6 -> 0.000010 basx338 toEng 10e-6 -> 0.000010 basx339 toSci 10e-7 -> 0.0000010 basx340 toEng 10e-7 -> 0.0000010 basx341 toSci 10e-8 -> 1.0E-7 basx342 toEng 10e-8 -> 100E-9 basx343 toSci 10e-9 -> 1.0E-8 basx344 toEng 10e-9 -> 10E-9 basx345 toSci 10e-10 -> 1.0E-9 basx346 toEng 10e-10 -> 1.0E-9 basx347 toSci 10e-11 -> 1.0E-10 basx348 toEng 10e-11 -> 100E-12 basx349 toSci 10e-12 -> 1.0E-11 basx350 toEng 10e-12 -> 10E-12 basx351 toSci 10e-13 -> 1.0E-12 basx352 toEng 10e-13 -> 1.0E-12 basx361 toSci 7E12 -> 7E+12 basx362 toEng 7E12 -> 7E+12 basx363 toSci 7E11 -> 7E+11 basx364 toEng 7E11 -> 700E+9 basx365 toSci 7E10 -> 7E+10 basx366 toEng 7E10 -> 70E+9 basx367 toSci 7E9 -> 7E+9 basx368 toEng 7E9 -> 7E+9 basx369 toSci 7E8 -> 7E+8 basx370 toEng 7E8 -> 700E+6 basx371 toSci 7E7 -> 7E+7 basx372 toEng 7E7 -> 70E+6 basx373 toSci 7E6 -> 7E+6 basx374 toEng 7E6 -> 7E+6 basx375 toSci 7E5 -> 7E+5 basx376 toEng 7E5 -> 700E+3 basx377 toSci 7E4 -> 7E+4 basx378 toEng 7E4 -> 70E+3 basx379 toSci 7E3 -> 7E+3 basx380 toEng 7E3 -> 7E+3 basx381 toSci 7E2 -> 7E+2 basx382 toEng 7E2 -> 700 basx383 toSci 7E1 -> 7E+1 basx384 toEng 7E1 -> 70 basx385 toSci 7E0 -> 7 basx386 toEng 7E0 -> 7 basx387 toSci 7E-1 -> 0.7 basx388 toEng 7E-1 -> 0.7 basx389 toSci 7E-2 -> 0.07 basx390 toEng 7E-2 -> 0.07 basx391 toSci 7E-3 -> 0.007 basx392 toEng 7E-3 -> 0.007 basx393 toSci 7E-4 -> 0.0007 basx394 toEng 7E-4 -> 0.0007 basx395 toSci 7E-5 -> 0.00007 basx396 toEng 7E-5 -> 0.00007 basx397 toSci 7E-6 -> 0.000007 basx398 toEng 7E-6 -> 0.000007 basx399 toSci 7E-7 -> 7E-7 basx400 toEng 7E-7 -> 700E-9 basx401 toSci 7E-8 -> 7E-8 basx402 toEng 7E-8 -> 70E-9 basx403 toSci 7E-9 -> 7E-9 basx404 toEng 7E-9 -> 7E-9 basx405 toSci 7E-10 -> 7E-10 basx406 toEng 7E-10 -> 700E-12 basx407 toSci 7E-11 -> 7E-11 basx408 toEng 7E-11 -> 70E-12 basx409 toSci 7E-12 -> 7E-12 basx410 toEng 7E-12 -> 7E-12 basx411 toSci 7E-13 -> 7E-13 basx412 toEng 7E-13 -> 700E-15 -- Exacts remain exact up to precision .. precision: 9 basx420 toSci 100 -> 100 basx421 toEng 100 -> 100 basx422 toSci 1000 -> 1000 basx423 toEng 1000 -> 1000 basx424 toSci 999.9 -> 999.9 basx425 toEng 999.9 -> 999.9 basx426 toSci 1000.0 -> 1000.0 basx427 toEng 1000.0 -> 1000.0 basx428 toSci 1000.1 -> 1000.1 basx429 toEng 1000.1 -> 1000.1 basx430 toSci 10000 -> 10000 basx431 toEng 10000 -> 10000 basx432 toSci 100000 -> 100000 basx433 toEng 100000 -> 100000 basx434 toSci 1000000 -> 1000000 basx435 toEng 1000000 -> 1000000 basx436 toSci 10000000 -> 10000000 basx437 toEng 10000000 -> 10000000 basx438 toSci 100000000 -> 100000000 basx439 toEng 100000000 -> 100000000 basx440 toSci 1000000000 -> 1.00000000E+9 Rounded basx441 toEng 1000000000 -> 1.00000000E+9 Rounded basx442 toSci 1000000000 -> 1.00000000E+9 Rounded basx443 toEng 1000000000 -> 1.00000000E+9 Rounded basx444 toSci 1000000003 -> 1.00000000E+9 Rounded Inexact basx445 toEng 1000000003 -> 1.00000000E+9 Rounded Inexact basx446 toSci 1000000005 -> 1.00000001E+9 Rounded Inexact basx447 toEng 1000000005 -> 1.00000001E+9 Rounded Inexact basx448 toSci 10000000050 -> 1.00000001E+10 Rounded Inexact basx449 toEng 10000000050 -> 10.0000001E+9 Rounded Inexact basx450 toSci 1000000009 -> 1.00000001E+9 Rounded Inexact basx451 toEng 1000000009 -> 1.00000001E+9 Rounded Inexact basx452 toSci 10000000000 -> 1.00000000E+10 Rounded basx453 toEng 10000000000 -> 10.0000000E+9 Rounded basx454 toSci 10000000003 -> 1.00000000E+10 Rounded Inexact basx455 toEng 10000000003 -> 10.0000000E+9 Rounded Inexact basx456 toSci 10000000005 -> 1.00000000E+10 Rounded Inexact basx457 toEng 10000000005 -> 10.0000000E+9 Rounded Inexact basx458 toSci 10000000009 -> 1.00000000E+10 Rounded Inexact basx459 toEng 10000000009 -> 10.0000000E+9 Rounded Inexact basx460 toSci 100000000000 -> 1.00000000E+11 Rounded basx461 toEng 100000000000 -> 100.000000E+9 Rounded basx462 toSci 100000000300 -> 1.00000000E+11 Rounded Inexact basx463 toEng 100000000300 -> 100.000000E+9 Rounded Inexact basx464 toSci 100000000500 -> 1.00000001E+11 Rounded Inexact basx465 toEng 100000000500 -> 100.000001E+9 Rounded Inexact basx466 toSci 100000000900 -> 1.00000001E+11 Rounded Inexact basx467 toEng 100000000900 -> 100.000001E+9 Rounded Inexact basx468 toSci 1000000000000 -> 1.00000000E+12 Rounded basx469 toEng 1000000000000 -> 1.00000000E+12 Rounded basx470 toSci 1000000003000 -> 1.00000000E+12 Rounded Inexact basx471 toEng 1000000003000 -> 1.00000000E+12 Rounded Inexact basx472 toSci 1000000005000 -> 1.00000001E+12 Rounded Inexact basx473 toEng 1000000005000 -> 1.00000001E+12 Rounded Inexact basx474 toSci 1000000009000 -> 1.00000001E+12 Rounded Inexact basx475 toEng 1000000009000 -> 1.00000001E+12 Rounded Inexact -- all-nines rounding precision: 9 rounding: half_up basx270 toSci 999999999 -> 999999999 basx271 toSci 9999999990 -> 9.99999999E+9 Rounded basx272 toSci 9999999991 -> 9.99999999E+9 Rounded Inexact basx273 toSci 9999999992 -> 9.99999999E+9 Rounded Inexact basx274 toSci 9999999993 -> 9.99999999E+9 Rounded Inexact basx275 toSci 9999999994 -> 9.99999999E+9 Rounded Inexact basx276 toSci 9999999995 -> 1.00000000E+10 Rounded Inexact basx277 toSci 9999999996 -> 1.00000000E+10 Rounded Inexact basx278 toSci 9999999997 -> 1.00000000E+10 Rounded Inexact basx279 toSci 9999999998 -> 1.00000000E+10 Rounded Inexact basx280 toSci 9999999999 -> 1.00000000E+10 Rounded Inexact basx281 toSci 9999999999999999 -> 1.00000000E+16 Rounded Inexact -- check rounding modes heeded precision: 5 rounding: ceiling bsrx401 toSci 1.23450 -> 1.2345 Rounded bsrx402 toSci 1.234549 -> 1.2346 Rounded Inexact bsrx403 toSci 1.234550 -> 1.2346 Rounded Inexact bsrx404 toSci 1.234551 -> 1.2346 Rounded Inexact rounding: up bsrx405 toSci 1.23450 -> 1.2345 Rounded bsrx406 toSci 1.234549 -> 1.2346 Rounded Inexact bsrx407 toSci 1.234550 -> 1.2346 Rounded Inexact bsrx408 toSci 1.234551 -> 1.2346 Rounded Inexact rounding: floor bsrx410 toSci 1.23450 -> 1.2345 Rounded bsrx411 toSci 1.234549 -> 1.2345 Rounded Inexact bsrx412 toSci 1.234550 -> 1.2345 Rounded Inexact bsrx413 toSci 1.234551 -> 1.2345 Rounded Inexact rounding: half_down bsrx415 toSci 1.23450 -> 1.2345 Rounded bsrx416 toSci 1.234549 -> 1.2345 Rounded Inexact bsrx417 toSci 1.234550 -> 1.2345 Rounded Inexact bsrx418 toSci 1.234650 -> 1.2346 Rounded Inexact bsrx419 toSci 1.234551 -> 1.2346 Rounded Inexact rounding: half_even bsrx421 toSci 1.23450 -> 1.2345 Rounded bsrx422 toSci 1.234549 -> 1.2345 Rounded Inexact bsrx423 toSci 1.234550 -> 1.2346 Rounded Inexact bsrx424 toSci 1.234650 -> 1.2346 Rounded Inexact bsrx425 toSci 1.234551 -> 1.2346 Rounded Inexact rounding: down bsrx426 toSci 1.23450 -> 1.2345 Rounded bsrx427 toSci 1.234549 -> 1.2345 Rounded Inexact bsrx428 toSci 1.234550 -> 1.2345 Rounded Inexact bsrx429 toSci 1.234551 -> 1.2345 Rounded Inexact rounding: half_up bsrx431 toSci 1.23450 -> 1.2345 Rounded bsrx432 toSci 1.234549 -> 1.2345 Rounded Inexact bsrx433 toSci 1.234550 -> 1.2346 Rounded Inexact bsrx434 toSci 1.234650 -> 1.2347 Rounded Inexact bsrx435 toSci 1.234551 -> 1.2346 Rounded Inexact -- negatives rounding: ceiling bsrx501 toSci -1.23450 -> -1.2345 Rounded bsrx502 toSci -1.234549 -> -1.2345 Rounded Inexact bsrx503 toSci -1.234550 -> -1.2345 Rounded Inexact bsrx504 toSci -1.234551 -> -1.2345 Rounded Inexact rounding: up bsrx505 toSci -1.23450 -> -1.2345 Rounded bsrx506 toSci -1.234549 -> -1.2346 Rounded Inexact bsrx507 toSci -1.234550 -> -1.2346 Rounded Inexact bsrx508 toSci -1.234551 -> -1.2346 Rounded Inexact rounding: floor bsrx510 toSci -1.23450 -> -1.2345 Rounded bsrx511 toSci -1.234549 -> -1.2346 Rounded Inexact bsrx512 toSci -1.234550 -> -1.2346 Rounded Inexact bsrx513 toSci -1.234551 -> -1.2346 Rounded Inexact rounding: half_down bsrx515 toSci -1.23450 -> -1.2345 Rounded bsrx516 toSci -1.234549 -> -1.2345 Rounded Inexact bsrx517 toSci -1.234550 -> -1.2345 Rounded Inexact bsrx518 toSci -1.234650 -> -1.2346 Rounded Inexact bsrx519 toSci -1.234551 -> -1.2346 Rounded Inexact rounding: half_even bsrx521 toSci -1.23450 -> -1.2345 Rounded bsrx522 toSci -1.234549 -> -1.2345 Rounded Inexact bsrx523 toSci -1.234550 -> -1.2346 Rounded Inexact bsrx524 toSci -1.234650 -> -1.2346 Rounded Inexact bsrx525 toSci -1.234551 -> -1.2346 Rounded Inexact rounding: down bsrx526 toSci -1.23450 -> -1.2345 Rounded bsrx527 toSci -1.234549 -> -1.2345 Rounded Inexact bsrx528 toSci -1.234550 -> -1.2345 Rounded Inexact bsrx529 toSci -1.234551 -> -1.2345 Rounded Inexact rounding: half_up bsrx531 toSci -1.23450 -> -1.2345 Rounded bsrx532 toSci -1.234549 -> -1.2345 Rounded Inexact bsrx533 toSci -1.234550 -> -1.2346 Rounded Inexact bsrx534 toSci -1.234650 -> -1.2347 Rounded Inexact bsrx535 toSci -1.234551 -> -1.2346 Rounded Inexact -- a few larger exponents maxExponent: 999999999 minExponent: -999999999 basx480 toSci "0.09e999" -> '9E+997' basx481 toSci "0.9e999" -> '9E+998' basx482 toSci "9e999" -> '9E+999' basx483 toSci "9.9e999" -> '9.9E+999' basx484 toSci "9.99e999" -> '9.99E+999' basx485 toSci "9.99e-999" -> '9.99E-999' basx486 toSci "9.9e-999" -> '9.9E-999' basx487 toSci "9e-999" -> '9E-999' basx489 toSci "99e-999" -> '9.9E-998' basx490 toSci "999e-999" -> '9.99E-997' basx491 toSci '0.9e-998' -> '9E-999' basx492 toSci '0.09e-997' -> '9E-999' basx493 toSci '0.1e1000' -> '1E+999' basx494 toSci '10e-1000' -> '1.0E-999' rounding: half_up precision: 9 -- The 'baddies' tests from DiagBigDecimal, plus some new ones basx500 toSci '1..2' -> NaN Conversion_syntax basx501 toSci '.' -> NaN Conversion_syntax basx502 toSci '..' -> NaN Conversion_syntax basx503 toSci '++1' -> NaN Conversion_syntax basx504 toSci '--1' -> NaN Conversion_syntax basx505 toSci '-+1' -> NaN Conversion_syntax basx506 toSci '+-1' -> NaN Conversion_syntax basx507 toSci '12e' -> NaN Conversion_syntax basx508 toSci '12e++' -> NaN Conversion_syntax basx509 toSci '12f4' -> NaN Conversion_syntax basx510 toSci ' +1' -> NaN Conversion_syntax basx511 toSci '+ 1' -> NaN Conversion_syntax basx512 toSci '12 ' -> NaN Conversion_syntax basx513 toSci ' + 1' -> NaN Conversion_syntax basx514 toSci ' - 1 ' -> NaN Conversion_syntax basx515 toSci 'x' -> NaN Conversion_syntax basx516 toSci '-1-' -> NaN Conversion_syntax basx517 toSci '12-' -> NaN Conversion_syntax basx518 toSci '3+' -> NaN Conversion_syntax basx519 toSci '' -> NaN Conversion_syntax basx520 toSci '1e-' -> NaN Conversion_syntax basx521 toSci '7e99999a' -> NaN Conversion_syntax basx522 toSci '7e123567890x' -> NaN Conversion_syntax basx523 toSci '7e12356789012x' -> NaN Conversion_syntax basx524 toSci '' -> NaN Conversion_syntax basx525 toSci 'e100' -> NaN Conversion_syntax basx526 toSci '\u0e5a' -> NaN Conversion_syntax basx527 toSci '\u0b65' -> NaN Conversion_syntax basx528 toSci '123,65' -> NaN Conversion_syntax basx529 toSci '1.34.5' -> NaN Conversion_syntax basx530 toSci '.123.5' -> NaN Conversion_syntax basx531 toSci '01.35.' -> NaN Conversion_syntax basx532 toSci '01.35-' -> NaN Conversion_syntax basx533 toSci '0000..' -> NaN Conversion_syntax basx534 toSci '.0000.' -> NaN Conversion_syntax basx535 toSci '00..00' -> NaN Conversion_syntax basx536 toSci '111e*123' -> NaN Conversion_syntax basx537 toSci '111e123-' -> NaN Conversion_syntax basx538 toSci '111e+12+' -> NaN Conversion_syntax basx539 toSci '111e1-3-' -> NaN Conversion_syntax basx540 toSci '111e1*23' -> NaN Conversion_syntax basx541 toSci '111e1e+3' -> NaN Conversion_syntax basx542 toSci '1e1.0' -> NaN Conversion_syntax basx543 toSci '1e123e' -> NaN Conversion_syntax basx544 toSci 'ten' -> NaN Conversion_syntax basx545 toSci 'ONE' -> NaN Conversion_syntax basx546 toSci '1e.1' -> NaN Conversion_syntax basx547 toSci '1e1.' -> NaN Conversion_syntax basx548 toSci '1ee' -> NaN Conversion_syntax basx549 toSci 'e+1' -> NaN Conversion_syntax basx550 toSci '1.23.4' -> NaN Conversion_syntax basx551 toSci '1.2.1' -> NaN Conversion_syntax basx552 toSci '1E+1.2' -> NaN Conversion_syntax basx553 toSci '1E+1.2.3' -> NaN Conversion_syntax basx554 toSci '1E++1' -> NaN Conversion_syntax basx555 toSci '1E--1' -> NaN Conversion_syntax basx556 toSci '1E+-1' -> NaN Conversion_syntax basx557 toSci '1E-+1' -> NaN Conversion_syntax basx558 toSci '1E''1' -> NaN Conversion_syntax basx559 toSci "1E""1" -> NaN Conversion_syntax basx560 toSci "1E""""" -> NaN Conversion_syntax -- Near-specials basx561 toSci "qNaN" -> NaN Conversion_syntax basx562 toSci "NaNq" -> NaN Conversion_syntax basx563 toSci "NaNs" -> NaN Conversion_syntax basx564 toSci "Infi" -> NaN Conversion_syntax basx565 toSci "Infin" -> NaN Conversion_syntax basx566 toSci "Infini" -> NaN Conversion_syntax basx567 toSci "Infinit" -> NaN Conversion_syntax basx568 toSci "-Infinit" -> NaN Conversion_syntax basx569 toSci "0Inf" -> NaN Conversion_syntax basx570 toSci "9Inf" -> NaN Conversion_syntax basx571 toSci "-0Inf" -> NaN Conversion_syntax basx572 toSci "-9Inf" -> NaN Conversion_syntax basx573 toSci "-sNa" -> NaN Conversion_syntax basx574 toSci "xNaN" -> NaN Conversion_syntax basx575 toSci "0sNaN" -> NaN Conversion_syntax -- some baddies with dots and Es and dots and specials basx576 toSci 'e+1' -> NaN Conversion_syntax basx577 toSci '.e+1' -> NaN Conversion_syntax basx578 toSci '+.e+1' -> NaN Conversion_syntax basx579 toSci '-.e+' -> NaN Conversion_syntax basx580 toSci '-.e' -> NaN Conversion_syntax basx581 toSci 'E+1' -> NaN Conversion_syntax basx582 toSci '.E+1' -> NaN Conversion_syntax basx583 toSci '+.E+1' -> NaN Conversion_syntax basx584 toSci '-.E+' -> NaN Conversion_syntax basx585 toSci '-.E' -> NaN Conversion_syntax basx586 toSci '.NaN' -> NaN Conversion_syntax basx587 toSci '-.NaN' -> NaN Conversion_syntax basx588 toSci '+.sNaN' -> NaN Conversion_syntax basx589 toSci '+.Inf' -> NaN Conversion_syntax basx590 toSci '.Infinity' -> NaN Conversion_syntax -- Zeros basx601 toSci 0.000000000 -> 0E-9 basx602 toSci 0.00000000 -> 0E-8 basx603 toSci 0.0000000 -> 0E-7 basx604 toSci 0.000000 -> 0.000000 basx605 toSci 0.00000 -> 0.00000 basx606 toSci 0.0000 -> 0.0000 basx607 toSci 0.000 -> 0.000 basx608 toSci 0.00 -> 0.00 basx609 toSci 0.0 -> 0.0 basx610 toSci .0 -> 0.0 basx611 toSci 0. -> 0 basx612 toSci -.0 -> -0.0 basx613 toSci -0. -> -0 basx614 toSci -0.0 -> -0.0 basx615 toSci -0.00 -> -0.00 basx616 toSci -0.000 -> -0.000 basx617 toSci -0.0000 -> -0.0000 basx618 toSci -0.00000 -> -0.00000 basx619 toSci -0.000000 -> -0.000000 basx620 toSci -0.0000000 -> -0E-7 basx621 toSci -0.00000000 -> -0E-8 basx622 toSci -0.000000000 -> -0E-9 basx630 toSci 0.00E+0 -> 0.00 basx631 toSci 0.00E+1 -> 0.0 basx632 toSci 0.00E+2 -> 0 basx633 toSci 0.00E+3 -> 0E+1 basx634 toSci 0.00E+4 -> 0E+2 basx635 toSci 0.00E+5 -> 0E+3 basx636 toSci 0.00E+6 -> 0E+4 basx637 toSci 0.00E+7 -> 0E+5 basx638 toSci 0.00E+8 -> 0E+6 basx639 toSci 0.00E+9 -> 0E+7 basx640 toSci 0.0E+0 -> 0.0 basx641 toSci 0.0E+1 -> 0 basx642 toSci 0.0E+2 -> 0E+1 basx643 toSci 0.0E+3 -> 0E+2 basx644 toSci 0.0E+4 -> 0E+3 basx645 toSci 0.0E+5 -> 0E+4 basx646 toSci 0.0E+6 -> 0E+5 basx647 toSci 0.0E+7 -> 0E+6 basx648 toSci 0.0E+8 -> 0E+7 basx649 toSci 0.0E+9 -> 0E+8 basx650 toSci 0E+0 -> 0 basx651 toSci 0E+1 -> 0E+1 basx652 toSci 0E+2 -> 0E+2 basx653 toSci 0E+3 -> 0E+3 basx654 toSci 0E+4 -> 0E+4 basx655 toSci 0E+5 -> 0E+5 basx656 toSci 0E+6 -> 0E+6 basx657 toSci 0E+7 -> 0E+7 basx658 toSci 0E+8 -> 0E+8 basx659 toSci 0E+9 -> 0E+9 basx660 toSci 0.0E-0 -> 0.0 basx661 toSci 0.0E-1 -> 0.00 basx662 toSci 0.0E-2 -> 0.000 basx663 toSci 0.0E-3 -> 0.0000 basx664 toSci 0.0E-4 -> 0.00000 basx665 toSci 0.0E-5 -> 0.000000 basx666 toSci 0.0E-6 -> 0E-7 basx667 toSci 0.0E-7 -> 0E-8 basx668 toSci 0.0E-8 -> 0E-9 basx669 toSci 0.0E-9 -> 0E-10 basx670 toSci 0.00E-0 -> 0.00 basx671 toSci 0.00E-1 -> 0.000 basx672 toSci 0.00E-2 -> 0.0000 basx673 toSci 0.00E-3 -> 0.00000 basx674 toSci 0.00E-4 -> 0.000000 basx675 toSci 0.00E-5 -> 0E-7 basx676 toSci 0.00E-6 -> 0E-8 basx677 toSci 0.00E-7 -> 0E-9 basx678 toSci 0.00E-8 -> 0E-10 basx679 toSci 0.00E-9 -> 0E-11 basx680 toSci 000000. -> 0 basx681 toSci 00000. -> 0 basx682 toSci 0000. -> 0 basx683 toSci 000. -> 0 basx684 toSci 00. -> 0 basx685 toSci 0. -> 0 basx686 toSci +00000. -> 0 basx687 toSci -00000. -> -0 basx688 toSci +0. -> 0 basx689 toSci -0. -> -0 -- Specials precision: 4 basx700 toSci "NaN" -> NaN basx701 toSci "nan" -> NaN basx702 toSci "nAn" -> NaN basx703 toSci "NAN" -> NaN basx704 toSci "+NaN" -> NaN basx705 toSci "+nan" -> NaN basx706 toSci "+nAn" -> NaN basx707 toSci "+NAN" -> NaN basx708 toSci "-NaN" -> -NaN basx709 toSci "-nan" -> -NaN basx710 toSci "-nAn" -> -NaN basx711 toSci "-NAN" -> -NaN basx712 toSci 'NaN0' -> NaN basx713 toSci 'NaN1' -> NaN1 basx714 toSci 'NaN12' -> NaN12 basx715 toSci 'NaN123' -> NaN123 basx716 toSci 'NaN1234' -> NaN1234 basx717 toSci 'NaN01' -> NaN1 basx718 toSci 'NaN012' -> NaN12 basx719 toSci 'NaN0123' -> NaN123 basx720 toSci 'NaN01234' -> NaN1234 basx721 toSci 'NaN001' -> NaN1 basx722 toSci 'NaN0012' -> NaN12 basx723 toSci 'NaN00123' -> NaN123 basx724 toSci 'NaN001234' -> NaN1234 basx725 toSci 'NaN12345' -> NaN Conversion_syntax basx726 toSci 'NaN123e+1' -> NaN Conversion_syntax basx727 toSci 'NaN12.45' -> NaN Conversion_syntax basx728 toSci 'NaN-12' -> NaN Conversion_syntax basx729 toSci 'NaN+12' -> NaN Conversion_syntax basx730 toSci "sNaN" -> sNaN basx731 toSci "snan" -> sNaN basx732 toSci "SnAn" -> sNaN basx733 toSci "SNAN" -> sNaN basx734 toSci "+sNaN" -> sNaN basx735 toSci "+snan" -> sNaN basx736 toSci "+SnAn" -> sNaN basx737 toSci "+SNAN" -> sNaN basx738 toSci "-sNaN" -> -sNaN basx739 toSci "-snan" -> -sNaN basx740 toSci "-SnAn" -> -sNaN basx741 toSci "-SNAN" -> -sNaN basx742 toSci 'sNaN0000' -> sNaN basx743 toSci 'sNaN7' -> sNaN7 basx744 toSci 'sNaN007234' -> sNaN7234 basx745 toSci 'sNaN72345' -> NaN Conversion_syntax basx746 toSci 'sNaN72.45' -> NaN Conversion_syntax basx747 toSci 'sNaN-72' -> NaN Conversion_syntax basx748 toSci "Inf" -> Infinity basx749 toSci "inf" -> Infinity basx750 toSci "iNf" -> Infinity basx751 toSci "INF" -> Infinity basx752 toSci "+Inf" -> Infinity basx753 toSci "+inf" -> Infinity basx754 toSci "+iNf" -> Infinity basx755 toSci "+INF" -> Infinity basx756 toSci "-Inf" -> -Infinity basx757 toSci "-inf" -> -Infinity basx758 toSci "-iNf" -> -Infinity basx759 toSci "-INF" -> -Infinity basx760 toSci "Infinity" -> Infinity basx761 toSci "infinity" -> Infinity basx762 toSci "iNfInItY" -> Infinity basx763 toSci "INFINITY" -> Infinity basx764 toSci "+Infinity" -> Infinity basx765 toSci "+infinity" -> Infinity basx766 toSci "+iNfInItY" -> Infinity basx767 toSci "+INFINITY" -> Infinity basx768 toSci "-Infinity" -> -Infinity basx769 toSci "-infinity" -> -Infinity basx770 toSci "-iNfInItY" -> -Infinity basx771 toSci "-INFINITY" -> -Infinity -- Specials and zeros for toEng basx772 toEng "NaN" -> NaN basx773 toEng "-Infinity" -> -Infinity basx774 toEng "-sNaN" -> -sNaN basx775 toEng "-NaN" -> -NaN basx776 toEng "+Infinity" -> Infinity basx778 toEng "+sNaN" -> sNaN basx779 toEng "+NaN" -> NaN basx780 toEng "INFINITY" -> Infinity basx781 toEng "SNAN" -> sNaN basx782 toEng "NAN" -> NaN basx783 toEng "infinity" -> Infinity basx784 toEng "snan" -> sNaN basx785 toEng "nan" -> NaN basx786 toEng "InFINITY" -> Infinity basx787 toEng "SnAN" -> sNaN basx788 toEng "nAN" -> NaN basx789 toEng "iNfinity" -> Infinity basx790 toEng "sNan" -> sNaN basx791 toEng "Nan" -> NaN basx792 toEng "Infinity" -> Infinity basx793 toEng "sNaN" -> sNaN -- Zero toEng, etc. basx800 toEng 0e+1 -> "0.00E+3" -- doc example basx801 toEng 0.000000000 -> 0E-9 basx802 toEng 0.00000000 -> 0.00E-6 basx803 toEng 0.0000000 -> 0.0E-6 basx804 toEng 0.000000 -> 0.000000 basx805 toEng 0.00000 -> 0.00000 basx806 toEng 0.0000 -> 0.0000 basx807 toEng 0.000 -> 0.000 basx808 toEng 0.00 -> 0.00 basx809 toEng 0.0 -> 0.0 basx810 toEng .0 -> 0.0 basx811 toEng 0. -> 0 basx812 toEng -.0 -> -0.0 basx813 toEng -0. -> -0 basx814 toEng -0.0 -> -0.0 basx815 toEng -0.00 -> -0.00 basx816 toEng -0.000 -> -0.000 basx817 toEng -0.0000 -> -0.0000 basx818 toEng -0.00000 -> -0.00000 basx819 toEng -0.000000 -> -0.000000 basx820 toEng -0.0000000 -> -0.0E-6 basx821 toEng -0.00000000 -> -0.00E-6 basx822 toEng -0.000000000 -> -0E-9 basx830 toEng 0.00E+0 -> 0.00 basx831 toEng 0.00E+1 -> 0.0 basx832 toEng 0.00E+2 -> 0 basx833 toEng 0.00E+3 -> 0.00E+3 basx834 toEng 0.00E+4 -> 0.0E+3 basx835 toEng 0.00E+5 -> 0E+3 basx836 toEng 0.00E+6 -> 0.00E+6 basx837 toEng 0.00E+7 -> 0.0E+6 basx838 toEng 0.00E+8 -> 0E+6 basx839 toEng 0.00E+9 -> 0.00E+9 basx840 toEng 0.0E+0 -> 0.0 basx841 toEng 0.0E+1 -> 0 basx842 toEng 0.0E+2 -> 0.00E+3 basx843 toEng 0.0E+3 -> 0.0E+3 basx844 toEng 0.0E+4 -> 0E+3 basx845 toEng 0.0E+5 -> 0.00E+6 basx846 toEng 0.0E+6 -> 0.0E+6 basx847 toEng 0.0E+7 -> 0E+6 basx848 toEng 0.0E+8 -> 0.00E+9 basx849 toEng 0.0E+9 -> 0.0E+9 basx850 toEng 0E+0 -> 0 basx851 toEng 0E+1 -> 0.00E+3 basx852 toEng 0E+2 -> 0.0E+3 basx853 toEng 0E+3 -> 0E+3 basx854 toEng 0E+4 -> 0.00E+6 basx855 toEng 0E+5 -> 0.0E+6 basx856 toEng 0E+6 -> 0E+6 basx857 toEng 0E+7 -> 0.00E+9 basx858 toEng 0E+8 -> 0.0E+9 basx859 toEng 0E+9 -> 0E+9 basx860 toEng 0.0E-0 -> 0.0 basx861 toEng 0.0E-1 -> 0.00 basx862 toEng 0.0E-2 -> 0.000 basx863 toEng 0.0E-3 -> 0.0000 basx864 toEng 0.0E-4 -> 0.00000 basx865 toEng 0.0E-5 -> 0.000000 basx866 toEng 0.0E-6 -> 0.0E-6 basx867 toEng 0.0E-7 -> 0.00E-6 basx868 toEng 0.0E-8 -> 0E-9 basx869 toEng 0.0E-9 -> 0.0E-9 basx870 toEng 0.00E-0 -> 0.00 basx871 toEng 0.00E-1 -> 0.000 basx872 toEng 0.00E-2 -> 0.0000 basx873 toEng 0.00E-3 -> 0.00000 basx874 toEng 0.00E-4 -> 0.000000 basx875 toEng 0.00E-5 -> 0.0E-6 basx876 toEng 0.00E-6 -> 0.00E-6 basx877 toEng 0.00E-7 -> 0E-9 basx878 toEng 0.00E-8 -> 0.0E-9 basx879 toEng 0.00E-9 -> 0.00E-9 rounding: half_up precision: 9 -- subnormals and overflows basx906 toSci '99e999999999' -> Infinity Overflow Inexact Rounded basx907 toSci '999e999999999' -> Infinity Overflow Inexact Rounded basx908 toSci '0.9e-999999999' -> 9E-1000000000 Subnormal basx909 toSci '0.09e-999999999' -> 9E-1000000001 Subnormal basx910 toSci '0.1e1000000000' -> 1E+999999999 basx911 toSci '10e-1000000000' -> 1.0E-999999999 basx912 toSci '0.9e9999999999' -> Infinity Overflow Inexact Rounded basx913 toSci '99e-9999999999' -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx914 toSci '111e9999999999' -> Infinity Overflow Inexact Rounded basx915 toSci '1111e-9999999999' -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx916 toSci '1111e-99999999999' -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx917 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded -- negatives the same basx918 toSci '-99e999999999' -> -Infinity Overflow Inexact Rounded basx919 toSci '-999e999999999' -> -Infinity Overflow Inexact Rounded basx920 toSci '-0.9e-999999999' -> -9E-1000000000 Subnormal basx921 toSci '-0.09e-999999999' -> -9E-1000000001 Subnormal basx922 toSci '-0.1e1000000000' -> -1E+999999999 basx923 toSci '-10e-1000000000' -> -1.0E-999999999 basx924 toSci '-0.9e9999999999' -> -Infinity Overflow Inexact Rounded basx925 toSci '-99e-9999999999' -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx926 toSci '-111e9999999999' -> -Infinity Overflow Inexact Rounded basx927 toSci '-1111e-9999999999' -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx928 toSci '-1111e-99999999999' -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped basx929 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: ceiling basx930 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded basx931 toSci '-7e1000000000' -> -9.99999999E+999999999 Overflow Inexact Rounded rounding: up basx932 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded basx933 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: down basx934 toSci '7e1000000000' -> 9.99999999E+999999999 Overflow Inexact Rounded basx935 toSci '-7e1000000000' -> -9.99999999E+999999999 Overflow Inexact Rounded rounding: floor basx936 toSci '7e1000000000' -> 9.99999999E+999999999 Overflow Inexact Rounded basx937 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: half_up basx938 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded basx939 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: half_even basx940 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded basx941 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: half_down basx942 toSci '7e1000000000' -> Infinity Overflow Inexact Rounded basx943 toSci '-7e1000000000' -> -Infinity Overflow Inexact Rounded rounding: half_even -- Giga exponent initial tests maxExponent: 999999999 minExponent: -999999999 basx951 toSci '99e999' -> '9.9E+1000' basx952 toSci '999e999' -> '9.99E+1001' basx953 toSci '0.9e-999' -> '9E-1000' basx954 toSci '0.09e-999' -> '9E-1001' basx955 toSci '0.1e1001' -> '1E+1000' basx956 toSci '10e-1001' -> '1.0E-1000' basx957 toSci '0.9e9999' -> '9E+9998' basx958 toSci '99e-9999' -> '9.9E-9998' basx959 toSci '111e9997' -> '1.11E+9999' basx960 toSci '1111e-9999' -> '1.111E-9996' basx961 toSci '99e9999' -> '9.9E+10000' basx962 toSci '999e9999' -> '9.99E+10001' basx963 toSci '0.9e-9999' -> '9E-10000' basx964 toSci '0.09e-9999' -> '9E-10001' basx965 toSci '0.1e10001' -> '1E+10000' basx966 toSci '10e-10001' -> '1.0E-10000' basx967 toSci '0.9e99999' -> '9E+99998' basx968 toSci '99e-99999' -> '9.9E-99998' basx969 toSci '111e99999' -> '1.11E+100001' basx970 toSci '1111e-99999' -> '1.111E-99996' basx971 toSci "0.09e999999999" -> '9E+999999997' basx972 toSci "0.9e999999999" -> '9E+999999998' basx973 toSci "9e999999999" -> '9E+999999999' basx974 toSci "9.9e999999999" -> '9.9E+999999999' basx975 toSci "9.99e999999999" -> '9.99E+999999999' basx976 toSci "9.99e-999999999" -> '9.99E-999999999' basx977 toSci "9.9e-999999999" -> '9.9E-999999999' basx978 toSci "9e-999999999" -> '9E-999999999' basx979 toSci "99e-999999999" -> '9.9E-999999998' basx980 toSci "999e-999999999" -> '9.99E-999999997' -- Varying exponent maximums precision: 5 maxexponent: 0 minexponent: 0 emax001 toSci -1E+2 -> -Infinity Overflow Inexact Rounded emax002 toSci -100 -> -Infinity Overflow Inexact Rounded emax003 toSci -10 -> -Infinity Overflow Inexact Rounded emax004 toSci -9.9 -> -9.9 emax005 toSci -9 -> -9 emax006 toSci -1 -> -1 emax007 toSci 0 -> 0 emax008 toSci 1 -> 1 emax009 toSci 9 -> 9 emax010 toSci 9.9 -> 9.9 emax011 toSci 10 -> Infinity Overflow Inexact Rounded emax012 toSci 100 -> Infinity Overflow Inexact Rounded emax013 toSci 1E+2 -> Infinity Overflow Inexact Rounded emax014 toSci 0.99 -> 0.99 Subnormal emax015 toSci 0.1 -> 0.1 Subnormal emax016 toSci 0.01 -> 0.01 Subnormal emax017 toSci 1E-1 -> 0.1 Subnormal emax018 toSci 1E-2 -> 0.01 Subnormal maxexponent: 1 minexponent: -1 emax100 toSci -1E+3 -> -Infinity Overflow Inexact Rounded emax101 toSci -1E+2 -> -Infinity Overflow Inexact Rounded emax102 toSci -100 -> -Infinity Overflow Inexact Rounded emax103 toSci -10 -> -10 emax104 toSci -9.9 -> -9.9 emax105 toSci -9 -> -9 emax106 toSci -1 -> -1 emax107 toSci 0 -> 0 emax108 toSci 1 -> 1 emax109 toSci 9 -> 9 emax110 toSci 9.9 -> 9.9 emax111 toSci 10 -> 10 emax112 toSci 100 -> Infinity Overflow Inexact Rounded emax113 toSci 1E+2 -> Infinity Overflow Inexact Rounded emax114 toSci 1E+3 -> Infinity Overflow Inexact Rounded emax115 toSci 0.99 -> 0.99 emax116 toSci 0.1 -> 0.1 emax117 toSci 0.01 -> 0.01 Subnormal emax118 toSci 1E-1 -> 0.1 emax119 toSci 1E-2 -> 0.01 Subnormal emax120 toSci 1E-3 -> 0.001 Subnormal emax121 toSci 1.1E-3 -> 0.0011 Subnormal emax122 toSci 1.11E-3 -> 0.00111 Subnormal emax123 toSci 1.111E-3 -> 0.00111 Subnormal Underflow Inexact Rounded emax124 toSci 1.1111E-3 -> 0.00111 Subnormal Underflow Inexact Rounded emax125 toSci 1.11111E-3 -> 0.00111 Subnormal Underflow Inexact Rounded maxexponent: 2 minexponent: -2 precision: 9 emax200 toSci -1E+3 -> -Infinity Overflow Inexact Rounded emax201 toSci -1E+2 -> -1E+2 emax202 toSci -100 -> -100 emax203 toSci -10 -> -10 emax204 toSci -9.9 -> -9.9 emax205 toSci -9 -> -9 emax206 toSci -1 -> -1 emax207 toSci 0 -> 0 emax208 toSci 1 -> 1 emax209 toSci 9 -> 9 emax210 toSci 9.9 -> 9.9 emax211 toSci 10 -> 10 emax212 toSci 100 -> 100 emax213 toSci 1E+2 -> 1E+2 emax214 toSci 1E+3 -> Infinity Overflow Inexact Rounded emax215 toSci 0.99 -> 0.99 emax216 toSci 0.1 -> 0.1 emax217 toSci 0.01 -> 0.01 emax218 toSci 0.001 -> 0.001 Subnormal emax219 toSci 1E-1 -> 0.1 emax220 toSci 1E-2 -> 0.01 emax221 toSci 1E-3 -> 0.001 Subnormal emax222 toSci 1E-4 -> 0.0001 Subnormal emax223 toSci 1E-5 -> 0.00001 Subnormal emax224 toSci 1E-6 -> 0.000001 Subnormal emax225 toSci 1E-7 -> 1E-7 Subnormal emax226 toSci 1E-8 -> 1E-8 Subnormal emax227 toSci 1E-9 -> 1E-9 Subnormal emax228 toSci 1E-10 -> 1E-10 Subnormal emax229 toSci 1E-11 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped emax230 toSci 1E-12 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped maxexponent: 7 minexponent: -7 emax231 toSci 1E-8 -> 1E-8 Subnormal emax232 toSci 1E-7 -> 1E-7 emax233 toSci 1E-6 -> 0.000001 emax234 toSci 1E-5 -> 0.00001 emax235 toSci 1E+5 -> 1E+5 emax236 toSci 1E+6 -> 1E+6 emax237 toSci 1E+7 -> 1E+7 emax238 toSci 1E+8 -> Infinity Overflow Inexact Rounded maxexponent: 9 minexponent: -9 emax240 toSci 1E-21 -> 0E-17 Subnormal Underflow Inexact Rounded Clamped emax241 toSci 1E-10 -> 1E-10 Subnormal emax242 toSci 1E-9 -> 1E-9 emax243 toSci 1E-8 -> 1E-8 emax244 toSci 1E-7 -> 1E-7 emax245 toSci 1E+7 -> 1E+7 emax246 toSci 1E+8 -> 1E+8 emax247 toSci 1E+9 -> 1E+9 emax248 toSci 1E+10 -> Infinity Overflow Inexact Rounded maxexponent: 10 -- boundary minexponent: -10 emax250 toSci 1E-21 -> 0E-18 Underflow Subnormal Inexact Rounded Clamped emax251 toSci 1E-11 -> 1E-11 Subnormal emax252 toSci 1E-10 -> 1E-10 emax253 toSci 1E-9 -> 1E-9 emax254 toSci 1E-8 -> 1E-8 emax255 toSci 1E+8 -> 1E+8 emax256 toSci 1E+9 -> 1E+9 emax257 toSci 1E+10 -> 1E+10 emax258 toSci 1E+11 -> Infinity Overflow Inexact Rounded emax260 toSci 1.00E-21 -> 0E-18 Underflow Subnormal Inexact Rounded Clamped emax261 toSci 1.00E-11 -> 1.00E-11 Subnormal emax262 toSci 1.00E-10 -> 1.00E-10 emax263 toSci 1.00E-9 -> 1.00E-9 emax264 toSci 1.00E-8 -> 1.00E-8 emax265 toSci 1.00E+8 -> 1.00E+8 emax266 toSci 1.00E+9 -> 1.00E+9 emax267 toSci 1.00E+10 -> 1.00E+10 emax268 toSci 1.00E+11 -> Infinity Overflow Inexact Rounded emax270 toSci 9.99E-21 -> 0E-18 Underflow Subnormal Inexact Rounded Clamped emax271 toSci 9.99E-11 -> 9.99E-11 Subnormal emax272 toSci 9.99E-10 -> 9.99E-10 emax273 toSci 9.99E-9 -> 9.99E-9 emax274 toSci 9.99E-8 -> 9.99E-8 emax275 toSci 9.99E+8 -> 9.99E+8 emax276 toSci 9.99E+9 -> 9.99E+9 emax277 toSci 9.99E+10 -> 9.99E+10 emax278 toSci 9.99E+11 -> Infinity Overflow Inexact Rounded maxexponent: 99 minexponent: -99 emax280 toSci 1E-120 -> 0E-107 Underflow Subnormal Inexact Rounded Clamped emax281 toSci 1E-100 -> 1E-100 Subnormal emax282 toSci 1E-99 -> 1E-99 emax283 toSci 1E-98 -> 1E-98 emax284 toSci 1E+98 -> 1E+98 emax285 toSci 1E+99 -> 1E+99 emax286 toSci 1E+100 -> Infinity Overflow Inexact Rounded maxexponent: 999 minexponent: -999 emax291 toSci 1E-1000 -> 1E-1000 Subnormal emax292 toSci 1E-999 -> 1E-999 emax293 toSci 1E+999 -> 1E+999 emax294 toSci 1E+1000 -> Infinity Overflow Inexact Rounded maxexponent: 9999 minexponent: -9999 emax301 toSci 1E-10000 -> 1E-10000 Subnormal emax302 toSci 1E-9999 -> 1E-9999 emax303 toSci 1E+9999 -> 1E+9999 emax304 toSci 1E+10000 -> Infinity Overflow Inexact Rounded maxexponent: 99999 minexponent: -99999 emax311 toSci 1E-100000 -> 1E-100000 Subnormal emax312 toSci 1E-99999 -> 1E-99999 emax313 toSci 1E+99999 -> 1E+99999 emax314 toSci 1E+100000 -> Infinity Overflow Inexact Rounded maxexponent: 999999 minexponent: -999999 emax321 toSci 1E-1000000 -> 1E-1000000 Subnormal emax322 toSci 1E-999999 -> 1E-999999 emax323 toSci 1E+999999 -> 1E+999999 emax324 toSci 1E+1000000 -> Infinity Overflow Inexact Rounded maxexponent: 9999999 minexponent: -9999999 emax331 toSci 1E-10000000 -> 1E-10000000 Subnormal emax332 toSci 1E-9999999 -> 1E-9999999 emax333 toSci 1E+9999999 -> 1E+9999999 emax334 toSci 1E+10000000 -> Infinity Overflow Inexact Rounded maxexponent: 99999999 minexponent: -99999999 emax341 toSci 1E-100000000 -> 1E-100000000 Subnormal emax342 toSci 1E-99999999 -> 1E-99999999 emax343 toSci 1E+99999999 -> 1E+99999999 emax344 toSci 1E+100000000 -> Infinity Overflow Inexact Rounded maxexponent: 999999999 minexponent: -999999999 emax347 toSci 1E-1000000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped emax348 toSci 1E-1000000007 -> 1E-1000000007 Subnormal emax349 toSci 1E-1000000000 -> 1E-1000000000 Subnormal emax350 toSci 1E-999999999 -> 1E-999999999 emax351 toSci 1E+999999999 -> 1E+999999999 emax352 toSci 1E+1000000000 -> Infinity Overflow Inexact Rounded emax353 toSci 1.000E-1000000000 -> 1.000E-1000000000 Subnormal emax354 toSci 1.000E-999999999 -> 1.000E-999999999 emax355 toSci 1.000E+999999999 -> 1.000E+999999999 emax356 toSci 1.000E+1000000000 -> Infinity Overflow Inexact Rounded emax357 toSci 1.001E-1000000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped emax358 toSci 1.001E-1000000007 -> 1E-1000000007 Subnormal Inexact Rounded Underflow emax359 toSci 1.001E-1000000000 -> 1.001E-1000000000 Subnormal emax360 toSci 1.001E-999999999 -> 1.001E-999999999 emax361 toSci 1.001E+999999999 -> 1.001E+999999999 emax362 toSci 1.001E+1000000000 -> Infinity Overflow Inexact Rounded emax363 toSci 9.000E-1000000000 -> 9.000E-1000000000 Subnormal emax364 toSci 9.000E-999999999 -> 9.000E-999999999 emax365 toSci 9.000E+999999999 -> 9.000E+999999999 emax366 toSci 9.000E+1000000000 -> Infinity Overflow Inexact Rounded emax367 toSci 9.999E-1000000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped emax368 toSci 9.999E-1000000008 -> 1E-1000000007 Underflow Subnormal Inexact Rounded emax369 toSci 9.999E-1000000007 -> 1.0E-1000000006 Underflow Subnormal Inexact Rounded emax370 toSci 9.999E-1000000000 -> 9.999E-1000000000 Subnormal emax371 toSci 9.999E-999999999 -> 9.999E-999999999 emax372 toSci 9.999E+999999999 -> 9.999E+999999999 emax373 toSci 9.999E+1000000000 -> Infinity Overflow Inexact Rounded emax374 toSci -1E-1000000000 -> -1E-1000000000 Subnormal emax375 toSci -1E-999999999 -> -1E-999999999 emax376 toSci -1E+999999999 -> -1E+999999999 emax377 toSci -1E+1000000000 -> -Infinity Overflow Inexact Rounded emax378 toSci -1.000E-1000000000 -> -1.000E-1000000000 Subnormal emax379 toSci -1.000E-999999999 -> -1.000E-999999999 emax380 toSci -1.000E+999999999 -> -1.000E+999999999 emax381 toSci -1.000E+1000000000 -> -Infinity Overflow Inexact Rounded emax382 toSci -1.001E-1000000008 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped emax383 toSci -1.001E-999999999 -> -1.001E-999999999 emax384 toSci -1.001E+999999999 -> -1.001E+999999999 emax385 toSci -1.001E+1000000000 -> -Infinity Overflow Inexact Rounded emax386 toSci -9.000E-1000000123 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped emax387 toSci -9.000E-999999999 -> -9.000E-999999999 emax388 toSci -9.000E+999999999 -> -9.000E+999999999 emax389 toSci -9.000E+1000000000 -> -Infinity Overflow Inexact Rounded emax390 toSci -9.999E-1000000008 -> -1E-1000000007 Underflow Subnormal Inexact Rounded emax391 toSci -9.999E-999999999 -> -9.999E-999999999 emax392 toSci -9.999E+999999999 -> -9.999E+999999999 emax393 toSci -9.999E+1000000000 -> -Infinity Overflow Inexact Rounded -- Now check 854 rounding of subnormals and proper underflow to 0 precision: 5 maxExponent: 999 minexponent: -999 rounding: half_even emax400 toSci 1.0000E-999 -> 1.0000E-999 emax401 toSci 0.1E-999 -> 1E-1000 Subnormal emax402 toSci 0.1000E-999 -> 1.000E-1000 Subnormal emax403 toSci 0.0100E-999 -> 1.00E-1001 Subnormal emax404 toSci 0.0010E-999 -> 1.0E-1002 Subnormal emax405 toSci 0.0001E-999 -> 1E-1003 Subnormal emax406 toSci 0.00010E-999 -> 1E-1003 Subnormal Rounded emax407 toSci 0.00013E-999 -> 1E-1003 Underflow Subnormal Inexact Rounded emax408 toSci 0.00015E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax409 toSci 0.00017E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax410 toSci 0.00023E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax411 toSci 0.00025E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax412 toSci 0.00027E-999 -> 3E-1003 Underflow Subnormal Inexact Rounded emax413 toSci 0.000149E-999 -> 1E-1003 Underflow Subnormal Inexact Rounded emax414 toSci 0.000150E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax415 toSci 0.000151E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax416 toSci 0.000249E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax417 toSci 0.000250E-999 -> 2E-1003 Underflow Subnormal Inexact Rounded emax418 toSci 0.000251E-999 -> 3E-1003 Underflow Subnormal Inexact Rounded emax419 toSci 0.00009E-999 -> 1E-1003 Underflow Subnormal Inexact Rounded emax420 toSci 0.00005E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax421 toSci 0.00003E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax422 toSci 0.000009E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax423 toSci 0.000005E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax424 toSci 0.000003E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax425 toSci 0.001049E-999 -> 1.0E-1002 Underflow Subnormal Inexact Rounded emax426 toSci 0.001050E-999 -> 1.0E-1002 Underflow Subnormal Inexact Rounded emax427 toSci 0.001051E-999 -> 1.1E-1002 Underflow Subnormal Inexact Rounded emax428 toSci 0.001149E-999 -> 1.1E-1002 Underflow Subnormal Inexact Rounded emax429 toSci 0.001150E-999 -> 1.2E-1002 Underflow Subnormal Inexact Rounded emax430 toSci 0.001151E-999 -> 1.2E-1002 Underflow Subnormal Inexact Rounded emax432 toSci 0.010049E-999 -> 1.00E-1001 Underflow Subnormal Inexact Rounded emax433 toSci 0.010050E-999 -> 1.00E-1001 Underflow Subnormal Inexact Rounded emax434 toSci 0.010051E-999 -> 1.01E-1001 Underflow Subnormal Inexact Rounded emax435 toSci 0.010149E-999 -> 1.01E-1001 Underflow Subnormal Inexact Rounded emax436 toSci 0.010150E-999 -> 1.02E-1001 Underflow Subnormal Inexact Rounded emax437 toSci 0.010151E-999 -> 1.02E-1001 Underflow Subnormal Inexact Rounded emax440 toSci 0.10103E-999 -> 1.010E-1000 Underflow Subnormal Inexact Rounded emax441 toSci 0.10105E-999 -> 1.010E-1000 Underflow Subnormal Inexact Rounded emax442 toSci 0.10107E-999 -> 1.011E-1000 Underflow Subnormal Inexact Rounded emax443 toSci 0.10113E-999 -> 1.011E-1000 Underflow Subnormal Inexact Rounded emax444 toSci 0.10115E-999 -> 1.012E-1000 Underflow Subnormal Inexact Rounded emax445 toSci 0.10117E-999 -> 1.012E-1000 Underflow Subnormal Inexact Rounded emax450 toSci 1.10730E-1000 -> 1.107E-1000 Underflow Subnormal Inexact Rounded emax451 toSci 1.10750E-1000 -> 1.108E-1000 Underflow Subnormal Inexact Rounded emax452 toSci 1.10770E-1000 -> 1.108E-1000 Underflow Subnormal Inexact Rounded emax453 toSci 1.10830E-1000 -> 1.108E-1000 Underflow Subnormal Inexact Rounded emax454 toSci 1.10850E-1000 -> 1.108E-1000 Underflow Subnormal Inexact Rounded emax455 toSci 1.10870E-1000 -> 1.109E-1000 Underflow Subnormal Inexact Rounded -- make sure sign OK emax456 toSci -0.10103E-999 -> -1.010E-1000 Underflow Subnormal Inexact Rounded emax457 toSci -0.10105E-999 -> -1.010E-1000 Underflow Subnormal Inexact Rounded emax458 toSci -0.10107E-999 -> -1.011E-1000 Underflow Subnormal Inexact Rounded emax459 toSci -0.10113E-999 -> -1.011E-1000 Underflow Subnormal Inexact Rounded emax460 toSci -0.10115E-999 -> -1.012E-1000 Underflow Subnormal Inexact Rounded emax461 toSci -0.10117E-999 -> -1.012E-1000 Underflow Subnormal Inexact Rounded -- '999s' cases emax464 toSci 999999E-999 -> 1.0000E-993 Inexact Rounded emax465 toSci 99999.0E-999 -> 9.9999E-995 Rounded emax466 toSci 99999.E-999 -> 9.9999E-995 emax467 toSci 9999.9E-999 -> 9.9999E-996 emax468 toSci 999.99E-999 -> 9.9999E-997 emax469 toSci 99.999E-999 -> 9.9999E-998 emax470 toSci 9.9999E-999 -> 9.9999E-999 emax471 toSci 0.99999E-999 -> 1.0000E-999 Underflow Subnormal Inexact Rounded emax472 toSci 0.099999E-999 -> 1.000E-1000 Underflow Subnormal Inexact Rounded emax473 toSci 0.0099999E-999 -> 1.00E-1001 Underflow Subnormal Inexact Rounded emax474 toSci 0.00099999E-999 -> 1.0E-1002 Underflow Subnormal Inexact Rounded emax475 toSci 0.000099999E-999 -> 1E-1003 Underflow Subnormal Inexact Rounded emax476 toSci 0.0000099999E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax477 toSci 0.00000099999E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped emax478 toSci 0.000000099999E-999 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped -- Exponents with insignificant leading zeros precision: 16 maxExponent: 999999999 minexponent: -999999999 basx1001 toSci 1e999999999 -> 1E+999999999 basx1002 toSci 1e0999999999 -> 1E+999999999 basx1003 toSci 1e00999999999 -> 1E+999999999 basx1004 toSci 1e000999999999 -> 1E+999999999 basx1005 toSci 1e000000000000999999999 -> 1E+999999999 basx1006 toSci 1e000000000001000000007 -> Infinity Overflow Inexact Rounded basx1007 toSci 1e-999999999 -> 1E-999999999 basx1008 toSci 1e-0999999999 -> 1E-999999999 basx1009 toSci 1e-00999999999 -> 1E-999999999 basx1010 toSci 1e-000999999999 -> 1E-999999999 basx1011 toSci 1e-000000000000999999999 -> 1E-999999999 basx1012 toSci 1e-000000000001000000007 -> 1E-1000000007 Subnormal -- Edge cases for int32 exponents... basx1021 tosci 1e+2147483649 -> Infinity Overflow Inexact Rounded basx1022 tosci 1e+2147483648 -> Infinity Overflow Inexact Rounded basx1023 tosci 1e+2147483647 -> Infinity Overflow Inexact Rounded basx1024 tosci 1e-2147483647 -> 0E-1000000014 Underflow Subnormal Inexact Rounded Clamped basx1025 tosci 1e-2147483648 -> 0E-1000000014 Underflow Subnormal Inexact Rounded Clamped basx1026 tosci 1e-2147483649 -> 0E-1000000014 Underflow Subnormal Inexact Rounded Clamped -- same unbalanced precision: 7 maxExponent: 96 minexponent: -95 basx1031 tosci 1e+2147483649 -> Infinity Overflow Inexact Rounded basx1032 tosci 1e+2147483648 -> Infinity Overflow Inexact Rounded basx1033 tosci 1e+2147483647 -> Infinity Overflow Inexact Rounded basx1034 tosci 1e-2147483647 -> 0E-101 Underflow Subnormal Inexact Rounded Clamped basx1035 tosci 1e-2147483648 -> 0E-101 Underflow Subnormal Inexact Rounded Clamped basx1036 tosci 1e-2147483649 -> 0E-101 Underflow Subnormal Inexact Rounded Clamped -- check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 basx1041 toSci 1.52444E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow basx1042 toSci 1.52445E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow basx1043 toSci 1.52446E-80 -> 1.524E-80 Inexact Rounded Subnormal Underflow -- clamped zeros [see also clamp.decTest] precision: 34 maxExponent: 6144 minExponent: -6143 basx1061 apply 0e+10000 -> 0E+6144 Clamped basx1062 apply 0e-10000 -> 0E-6176 Clamped basx1063 apply -0e+10000 -> -0E+6144 Clamped basx1064 apply -0e-10000 -> -0E-6176 Clamped precision: 16 maxExponent: 384 minExponent: -383 basx1065 apply 0e+10000 -> 0E+384 Clamped basx1066 apply 0e-10000 -> 0E-398 Clamped basx1067 apply -0e+10000 -> -0E+384 Clamped basx1068 apply -0e-10000 -> -0E-398 Clamped -- same with IEEE clamping clamp: 1 precision: 34 maxExponent: 6144 minExponent: -6143 basx1071 apply 0e+10000 -> 0E+6111 Clamped basx1072 apply 0e-10000 -> 0E-6176 Clamped basx1073 apply -0e+10000 -> -0E+6111 Clamped basx1074 apply -0e-10000 -> -0E-6176 Clamped precision: 16 maxExponent: 384 minExponent: -383 basx1075 apply 0e+10000 -> 0E+369 Clamped basx1076 apply 0e-10000 -> 0E-398 Clamped basx1077 apply -0e+10000 -> -0E+369 Clamped basx1078 apply -0e-10000 -> -0E-398 Clamped apd-3.2.1/testdata/compare.decTest000066400000000000000000000731471450022325000170420ustar00rootroot00000000000000------------------------------------------------------------------------ -- compare.decTest -- decimal comparison that allows quiet NaNs -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- Note that we cannot assume add/subtract tests cover paths adequately, -- here, because the code might be quite different (comparison cannot -- overflow or underflow, so actual subtractions are not necessary). extended: 1 precision: 9 rounding: half_up maxExponent: 999 minexponent: -999 -- sanity checks comx001 compare -2 -2 -> 0 comx002 compare -2 -1 -> -1 comx003 compare -2 0 -> -1 comx004 compare -2 1 -> -1 comx005 compare -2 2 -> -1 comx006 compare -1 -2 -> 1 comx007 compare -1 -1 -> 0 comx008 compare -1 0 -> -1 comx009 compare -1 1 -> -1 comx010 compare -1 2 -> -1 comx011 compare 0 -2 -> 1 comx012 compare 0 -1 -> 1 comx013 compare 0 0 -> 0 comx014 compare 0 1 -> -1 comx015 compare 0 2 -> -1 comx016 compare 1 -2 -> 1 comx017 compare 1 -1 -> 1 comx018 compare 1 0 -> 1 comx019 compare 1 1 -> 0 comx020 compare 1 2 -> -1 comx021 compare 2 -2 -> 1 comx022 compare 2 -1 -> 1 comx023 compare 2 0 -> 1 comx025 compare 2 1 -> 1 comx026 compare 2 2 -> 0 comx031 compare -20 -20 -> 0 comx032 compare -20 -10 -> -1 comx033 compare -20 00 -> -1 comx034 compare -20 10 -> -1 comx035 compare -20 20 -> -1 comx036 compare -10 -20 -> 1 comx037 compare -10 -10 -> 0 comx038 compare -10 00 -> -1 comx039 compare -10 10 -> -1 comx040 compare -10 20 -> -1 comx041 compare 00 -20 -> 1 comx042 compare 00 -10 -> 1 comx043 compare 00 00 -> 0 comx044 compare 00 10 -> -1 comx045 compare 00 20 -> -1 comx046 compare 10 -20 -> 1 comx047 compare 10 -10 -> 1 comx048 compare 10 00 -> 1 comx049 compare 10 10 -> 0 comx050 compare 10 20 -> -1 comx051 compare 20 -20 -> 1 comx052 compare 20 -10 -> 1 comx053 compare 20 00 -> 1 comx055 compare 20 10 -> 1 comx056 compare 20 20 -> 0 comx061 compare -2.0 -2.0 -> 0 comx062 compare -2.0 -1.0 -> -1 comx063 compare -2.0 0.0 -> -1 comx064 compare -2.0 1.0 -> -1 comx065 compare -2.0 2.0 -> -1 comx066 compare -1.0 -2.0 -> 1 comx067 compare -1.0 -1.0 -> 0 comx068 compare -1.0 0.0 -> -1 comx069 compare -1.0 1.0 -> -1 comx070 compare -1.0 2.0 -> -1 comx071 compare 0.0 -2.0 -> 1 comx072 compare 0.0 -1.0 -> 1 comx073 compare 0.0 0.0 -> 0 comx074 compare 0.0 1.0 -> -1 comx075 compare 0.0 2.0 -> -1 comx076 compare 1.0 -2.0 -> 1 comx077 compare 1.0 -1.0 -> 1 comx078 compare 1.0 0.0 -> 1 comx079 compare 1.0 1.0 -> 0 comx080 compare 1.0 2.0 -> -1 comx081 compare 2.0 -2.0 -> 1 comx082 compare 2.0 -1.0 -> 1 comx083 compare 2.0 0.0 -> 1 comx085 compare 2.0 1.0 -> 1 comx086 compare 2.0 2.0 -> 0 -- now some cases which might overflow if subtract were used maxexponent: 999999999 minexponent: -999999999 comx095 compare 9.99999999E+999999999 9.99999999E+999999999 -> 0 comx096 compare -9.99999999E+999999999 9.99999999E+999999999 -> -1 comx097 compare 9.99999999E+999999999 -9.99999999E+999999999 -> 1 comx098 compare -9.99999999E+999999999 -9.99999999E+999999999 -> 0 -- some differing length/exponent cases comx100 compare 7.0 7.0 -> 0 comx101 compare 7.0 7 -> 0 comx102 compare 7 7.0 -> 0 comx103 compare 7E+0 7.0 -> 0 comx104 compare 70E-1 7.0 -> 0 comx105 compare 0.7E+1 7 -> 0 comx106 compare 70E-1 7 -> 0 comx107 compare 7.0 7E+0 -> 0 comx108 compare 7.0 70E-1 -> 0 comx109 compare 7 0.7E+1 -> 0 comx110 compare 7 70E-1 -> 0 comx120 compare 8.0 7.0 -> 1 comx121 compare 8.0 7 -> 1 comx122 compare 8 7.0 -> 1 comx123 compare 8E+0 7.0 -> 1 comx124 compare 80E-1 7.0 -> 1 comx125 compare 0.8E+1 7 -> 1 comx126 compare 80E-1 7 -> 1 comx127 compare 8.0 7E+0 -> 1 comx128 compare 8.0 70E-1 -> 1 comx129 compare 8 0.7E+1 -> 1 comx130 compare 8 70E-1 -> 1 comx140 compare 8.0 9.0 -> -1 comx141 compare 8.0 9 -> -1 comx142 compare 8 9.0 -> -1 comx143 compare 8E+0 9.0 -> -1 comx144 compare 80E-1 9.0 -> -1 comx145 compare 0.8E+1 9 -> -1 comx146 compare 80E-1 9 -> -1 comx147 compare 8.0 9E+0 -> -1 comx148 compare 8.0 90E-1 -> -1 comx149 compare 8 0.9E+1 -> -1 comx150 compare 8 90E-1 -> -1 -- and again, with sign changes -+ .. comx200 compare -7.0 7.0 -> -1 comx201 compare -7.0 7 -> -1 comx202 compare -7 7.0 -> -1 comx203 compare -7E+0 7.0 -> -1 comx204 compare -70E-1 7.0 -> -1 comx205 compare -0.7E+1 7 -> -1 comx206 compare -70E-1 7 -> -1 comx207 compare -7.0 7E+0 -> -1 comx208 compare -7.0 70E-1 -> -1 comx209 compare -7 0.7E+1 -> -1 comx210 compare -7 70E-1 -> -1 comx220 compare -8.0 7.0 -> -1 comx221 compare -8.0 7 -> -1 comx222 compare -8 7.0 -> -1 comx223 compare -8E+0 7.0 -> -1 comx224 compare -80E-1 7.0 -> -1 comx225 compare -0.8E+1 7 -> -1 comx226 compare -80E-1 7 -> -1 comx227 compare -8.0 7E+0 -> -1 comx228 compare -8.0 70E-1 -> -1 comx229 compare -8 0.7E+1 -> -1 comx230 compare -8 70E-1 -> -1 comx240 compare -8.0 9.0 -> -1 comx241 compare -8.0 9 -> -1 comx242 compare -8 9.0 -> -1 comx243 compare -8E+0 9.0 -> -1 comx244 compare -80E-1 9.0 -> -1 comx245 compare -0.8E+1 9 -> -1 comx246 compare -80E-1 9 -> -1 comx247 compare -8.0 9E+0 -> -1 comx248 compare -8.0 90E-1 -> -1 comx249 compare -8 0.9E+1 -> -1 comx250 compare -8 90E-1 -> -1 -- and again, with sign changes +- .. comx300 compare 7.0 -7.0 -> 1 comx301 compare 7.0 -7 -> 1 comx302 compare 7 -7.0 -> 1 comx303 compare 7E+0 -7.0 -> 1 comx304 compare 70E-1 -7.0 -> 1 comx305 compare .7E+1 -7 -> 1 comx306 compare 70E-1 -7 -> 1 comx307 compare 7.0 -7E+0 -> 1 comx308 compare 7.0 -70E-1 -> 1 comx309 compare 7 -.7E+1 -> 1 comx310 compare 7 -70E-1 -> 1 comx320 compare 8.0 -7.0 -> 1 comx321 compare 8.0 -7 -> 1 comx322 compare 8 -7.0 -> 1 comx323 compare 8E+0 -7.0 -> 1 comx324 compare 80E-1 -7.0 -> 1 comx325 compare .8E+1 -7 -> 1 comx326 compare 80E-1 -7 -> 1 comx327 compare 8.0 -7E+0 -> 1 comx328 compare 8.0 -70E-1 -> 1 comx329 compare 8 -.7E+1 -> 1 comx330 compare 8 -70E-1 -> 1 comx340 compare 8.0 -9.0 -> 1 comx341 compare 8.0 -9 -> 1 comx342 compare 8 -9.0 -> 1 comx343 compare 8E+0 -9.0 -> 1 comx344 compare 80E-1 -9.0 -> 1 comx345 compare .8E+1 -9 -> 1 comx346 compare 80E-1 -9 -> 1 comx347 compare 8.0 -9E+0 -> 1 comx348 compare 8.0 -90E-1 -> 1 comx349 compare 8 -.9E+1 -> 1 comx350 compare 8 -90E-1 -> 1 -- and again, with sign changes -- .. comx400 compare -7.0 -7.0 -> 0 comx401 compare -7.0 -7 -> 0 comx402 compare -7 -7.0 -> 0 comx403 compare -7E+0 -7.0 -> 0 comx404 compare -70E-1 -7.0 -> 0 comx405 compare -.7E+1 -7 -> 0 comx406 compare -70E-1 -7 -> 0 comx407 compare -7.0 -7E+0 -> 0 comx408 compare -7.0 -70E-1 -> 0 comx409 compare -7 -.7E+1 -> 0 comx410 compare -7 -70E-1 -> 0 comx420 compare -8.0 -7.0 -> -1 comx421 compare -8.0 -7 -> -1 comx422 compare -8 -7.0 -> -1 comx423 compare -8E+0 -7.0 -> -1 comx424 compare -80E-1 -7.0 -> -1 comx425 compare -.8E+1 -7 -> -1 comx426 compare -80E-1 -7 -> -1 comx427 compare -8.0 -7E+0 -> -1 comx428 compare -8.0 -70E-1 -> -1 comx429 compare -8 -.7E+1 -> -1 comx430 compare -8 -70E-1 -> -1 comx440 compare -8.0 -9.0 -> 1 comx441 compare -8.0 -9 -> 1 comx442 compare -8 -9.0 -> 1 comx443 compare -8E+0 -9.0 -> 1 comx444 compare -80E-1 -9.0 -> 1 comx445 compare -.8E+1 -9 -> 1 comx446 compare -80E-1 -9 -> 1 comx447 compare -8.0 -9E+0 -> 1 comx448 compare -8.0 -90E-1 -> 1 comx449 compare -8 -.9E+1 -> 1 comx450 compare -8 -90E-1 -> 1 -- misalignment traps for little-endian comx451 compare 1.0 0.1 -> 1 comx452 compare 0.1 1.0 -> -1 comx453 compare 10.0 0.1 -> 1 comx454 compare 0.1 10.0 -> -1 comx455 compare 100 1.0 -> 1 comx456 compare 1.0 100 -> -1 comx457 compare 1000 10.0 -> 1 comx458 compare 10.0 1000 -> -1 comx459 compare 10000 100.0 -> 1 comx460 compare 100.0 10000 -> -1 comx461 compare 100000 1000.0 -> 1 comx462 compare 1000.0 100000 -> -1 comx463 compare 1000000 10000.0 -> 1 comx464 compare 10000.0 1000000 -> -1 -- testcases that subtract to lots of zeros at boundaries [pgr] precision: 40 comx470 compare 123.4560000000000000E789 123.456E789 -> 0 comx471 compare 123.456000000000000E-89 123.456E-89 -> 0 comx472 compare 123.45600000000000E789 123.456E789 -> 0 comx473 compare 123.4560000000000E-89 123.456E-89 -> 0 comx474 compare 123.456000000000E789 123.456E789 -> 0 comx475 compare 123.45600000000E-89 123.456E-89 -> 0 comx476 compare 123.4560000000E789 123.456E789 -> 0 comx477 compare 123.456000000E-89 123.456E-89 -> 0 comx478 compare 123.45600000E789 123.456E789 -> 0 comx479 compare 123.4560000E-89 123.456E-89 -> 0 comx480 compare 123.456000E789 123.456E789 -> 0 comx481 compare 123.45600E-89 123.456E-89 -> 0 comx482 compare 123.4560E789 123.456E789 -> 0 comx483 compare 123.456E-89 123.456E-89 -> 0 comx484 compare 123.456E-89 123.4560000000000000E-89 -> 0 comx485 compare 123.456E789 123.456000000000000E789 -> 0 comx486 compare 123.456E-89 123.45600000000000E-89 -> 0 comx487 compare 123.456E789 123.4560000000000E789 -> 0 comx488 compare 123.456E-89 123.456000000000E-89 -> 0 comx489 compare 123.456E789 123.45600000000E789 -> 0 comx490 compare 123.456E-89 123.4560000000E-89 -> 0 comx491 compare 123.456E789 123.456000000E789 -> 0 comx492 compare 123.456E-89 123.45600000E-89 -> 0 comx493 compare 123.456E789 123.4560000E789 -> 0 comx494 compare 123.456E-89 123.456000E-89 -> 0 comx495 compare 123.456E789 123.45600E789 -> 0 comx496 compare 123.456E-89 123.4560E-89 -> 0 comx497 compare 123.456E789 123.456E789 -> 0 -- wide-ranging, around precision; signs equal precision: 9 comx500 compare 1 1E-15 -> 1 comx501 compare 1 1E-14 -> 1 comx502 compare 1 1E-13 -> 1 comx503 compare 1 1E-12 -> 1 comx504 compare 1 1E-11 -> 1 comx505 compare 1 1E-10 -> 1 comx506 compare 1 1E-9 -> 1 comx507 compare 1 1E-8 -> 1 comx508 compare 1 1E-7 -> 1 comx509 compare 1 1E-6 -> 1 comx510 compare 1 1E-5 -> 1 comx511 compare 1 1E-4 -> 1 comx512 compare 1 1E-3 -> 1 comx513 compare 1 1E-2 -> 1 comx514 compare 1 1E-1 -> 1 comx515 compare 1 1E-0 -> 0 comx516 compare 1 1E+1 -> -1 comx517 compare 1 1E+2 -> -1 comx518 compare 1 1E+3 -> -1 comx519 compare 1 1E+4 -> -1 comx521 compare 1 1E+5 -> -1 comx522 compare 1 1E+6 -> -1 comx523 compare 1 1E+7 -> -1 comx524 compare 1 1E+8 -> -1 comx525 compare 1 1E+9 -> -1 comx526 compare 1 1E+10 -> -1 comx527 compare 1 1E+11 -> -1 comx528 compare 1 1E+12 -> -1 comx529 compare 1 1E+13 -> -1 comx530 compare 1 1E+14 -> -1 comx531 compare 1 1E+15 -> -1 -- LR swap comx540 compare 1E-15 1 -> -1 comx541 compare 1E-14 1 -> -1 comx542 compare 1E-13 1 -> -1 comx543 compare 1E-12 1 -> -1 comx544 compare 1E-11 1 -> -1 comx545 compare 1E-10 1 -> -1 comx546 compare 1E-9 1 -> -1 comx547 compare 1E-8 1 -> -1 comx548 compare 1E-7 1 -> -1 comx549 compare 1E-6 1 -> -1 comx550 compare 1E-5 1 -> -1 comx551 compare 1E-4 1 -> -1 comx552 compare 1E-3 1 -> -1 comx553 compare 1E-2 1 -> -1 comx554 compare 1E-1 1 -> -1 comx555 compare 1E-0 1 -> 0 comx556 compare 1E+1 1 -> 1 comx557 compare 1E+2 1 -> 1 comx558 compare 1E+3 1 -> 1 comx559 compare 1E+4 1 -> 1 comx561 compare 1E+5 1 -> 1 comx562 compare 1E+6 1 -> 1 comx563 compare 1E+7 1 -> 1 comx564 compare 1E+8 1 -> 1 comx565 compare 1E+9 1 -> 1 comx566 compare 1E+10 1 -> 1 comx567 compare 1E+11 1 -> 1 comx568 compare 1E+12 1 -> 1 comx569 compare 1E+13 1 -> 1 comx570 compare 1E+14 1 -> 1 comx571 compare 1E+15 1 -> 1 -- similar with a useful coefficient, one side only comx580 compare 0.000000987654321 1E-15 -> 1 comx581 compare 0.000000987654321 1E-14 -> 1 comx582 compare 0.000000987654321 1E-13 -> 1 comx583 compare 0.000000987654321 1E-12 -> 1 comx584 compare 0.000000987654321 1E-11 -> 1 comx585 compare 0.000000987654321 1E-10 -> 1 comx586 compare 0.000000987654321 1E-9 -> 1 comx587 compare 0.000000987654321 1E-8 -> 1 comx588 compare 0.000000987654321 1E-7 -> 1 comx589 compare 0.000000987654321 1E-6 -> -1 comx590 compare 0.000000987654321 1E-5 -> -1 comx591 compare 0.000000987654321 1E-4 -> -1 comx592 compare 0.000000987654321 1E-3 -> -1 comx593 compare 0.000000987654321 1E-2 -> -1 comx594 compare 0.000000987654321 1E-1 -> -1 comx595 compare 0.000000987654321 1E-0 -> -1 comx596 compare 0.000000987654321 1E+1 -> -1 comx597 compare 0.000000987654321 1E+2 -> -1 comx598 compare 0.000000987654321 1E+3 -> -1 comx599 compare 0.000000987654321 1E+4 -> -1 -- check some unit-y traps precision: 20 comx600 compare 12 12.2345 -> -1 comx601 compare 12.0 12.2345 -> -1 comx602 compare 12.00 12.2345 -> -1 comx603 compare 12.000 12.2345 -> -1 comx604 compare 12.0000 12.2345 -> -1 comx605 compare 12.00000 12.2345 -> -1 comx606 compare 12.000000 12.2345 -> -1 comx607 compare 12.0000000 12.2345 -> -1 comx608 compare 12.00000000 12.2345 -> -1 comx609 compare 12.000000000 12.2345 -> -1 comx610 compare 12.1234 12 -> 1 comx611 compare 12.1234 12.0 -> 1 comx612 compare 12.1234 12.00 -> 1 comx613 compare 12.1234 12.000 -> 1 comx614 compare 12.1234 12.0000 -> 1 comx615 compare 12.1234 12.00000 -> 1 comx616 compare 12.1234 12.000000 -> 1 comx617 compare 12.1234 12.0000000 -> 1 comx618 compare 12.1234 12.00000000 -> 1 comx619 compare 12.1234 12.000000000 -> 1 comx620 compare -12 -12.2345 -> 1 comx621 compare -12.0 -12.2345 -> 1 comx622 compare -12.00 -12.2345 -> 1 comx623 compare -12.000 -12.2345 -> 1 comx624 compare -12.0000 -12.2345 -> 1 comx625 compare -12.00000 -12.2345 -> 1 comx626 compare -12.000000 -12.2345 -> 1 comx627 compare -12.0000000 -12.2345 -> 1 comx628 compare -12.00000000 -12.2345 -> 1 comx629 compare -12.000000000 -12.2345 -> 1 comx630 compare -12.1234 -12 -> -1 comx631 compare -12.1234 -12.0 -> -1 comx632 compare -12.1234 -12.00 -> -1 comx633 compare -12.1234 -12.000 -> -1 comx634 compare -12.1234 -12.0000 -> -1 comx635 compare -12.1234 -12.00000 -> -1 comx636 compare -12.1234 -12.000000 -> -1 comx637 compare -12.1234 -12.0000000 -> -1 comx638 compare -12.1234 -12.00000000 -> -1 comx639 compare -12.1234 -12.000000000 -> -1 precision: 9 -- extended zeros comx640 compare 0 0 -> 0 comx641 compare 0 -0 -> 0 comx642 compare 0 -0.0 -> 0 comx643 compare 0 0.0 -> 0 comx644 compare -0 0 -> 0 comx645 compare -0 -0 -> 0 comx646 compare -0 -0.0 -> 0 comx647 compare -0 0.0 -> 0 comx648 compare 0.0 0 -> 0 comx649 compare 0.0 -0 -> 0 comx650 compare 0.0 -0.0 -> 0 comx651 compare 0.0 0.0 -> 0 comx652 compare -0.0 0 -> 0 comx653 compare -0.0 -0 -> 0 comx654 compare -0.0 -0.0 -> 0 comx655 compare -0.0 0.0 -> 0 comx656 compare -0E1 0.0 -> 0 comx657 compare -0E2 0.0 -> 0 comx658 compare 0E1 0.0 -> 0 comx659 compare 0E2 0.0 -> 0 comx660 compare -0E1 0 -> 0 comx661 compare -0E2 0 -> 0 comx662 compare 0E1 0 -> 0 comx663 compare 0E2 0 -> 0 comx664 compare -0E1 -0E1 -> 0 comx665 compare -0E2 -0E1 -> 0 comx666 compare 0E1 -0E1 -> 0 comx667 compare 0E2 -0E1 -> 0 comx668 compare -0E1 -0E2 -> 0 comx669 compare -0E2 -0E2 -> 0 comx670 compare 0E1 -0E2 -> 0 comx671 compare 0E2 -0E2 -> 0 comx672 compare -0E1 0E1 -> 0 comx673 compare -0E2 0E1 -> 0 comx674 compare 0E1 0E1 -> 0 comx675 compare 0E2 0E1 -> 0 comx676 compare -0E1 0E2 -> 0 comx677 compare -0E2 0E2 -> 0 comx678 compare 0E1 0E2 -> 0 comx679 compare 0E2 0E2 -> 0 -- trailing zeros; unit-y precision: 20 comx680 compare 12 12 -> 0 comx681 compare 12 12.0 -> 0 comx682 compare 12 12.00 -> 0 comx683 compare 12 12.000 -> 0 comx684 compare 12 12.0000 -> 0 comx685 compare 12 12.00000 -> 0 comx686 compare 12 12.000000 -> 0 comx687 compare 12 12.0000000 -> 0 comx688 compare 12 12.00000000 -> 0 comx689 compare 12 12.000000000 -> 0 comx690 compare 12 12 -> 0 comx691 compare 12.0 12 -> 0 comx692 compare 12.00 12 -> 0 comx693 compare 12.000 12 -> 0 comx694 compare 12.0000 12 -> 0 comx695 compare 12.00000 12 -> 0 comx696 compare 12.000000 12 -> 0 comx697 compare 12.0000000 12 -> 0 comx698 compare 12.00000000 12 -> 0 comx699 compare 12.000000000 12 -> 0 -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 comx701 compare 12345678000 1 -> 1 comx702 compare 1 12345678000 -> -1 comx703 compare 1234567800 1 -> 1 comx704 compare 1 1234567800 -> -1 comx705 compare 1234567890 1 -> 1 comx706 compare 1 1234567890 -> -1 comx707 compare 1234567891 1 -> 1 comx708 compare 1 1234567891 -> -1 comx709 compare 12345678901 1 -> 1 comx710 compare 1 12345678901 -> -1 comx711 compare 1234567896 1 -> 1 comx712 compare 1 1234567896 -> -1 comx713 compare -1234567891 1 -> -1 comx714 compare 1 -1234567891 -> 1 comx715 compare -12345678901 1 -> -1 comx716 compare 1 -12345678901 -> 1 comx717 compare -1234567896 1 -> -1 comx718 compare 1 -1234567896 -> 1 precision: 15 -- same with plenty of precision comx721 compare 12345678000 1 -> 1 comx722 compare 1 12345678000 -> -1 comx723 compare 1234567800 1 -> 1 comx724 compare 1 1234567800 -> -1 comx725 compare 1234567890 1 -> 1 comx726 compare 1 1234567890 -> -1 comx727 compare 1234567891 1 -> 1 comx728 compare 1 1234567891 -> -1 comx729 compare 12345678901 1 -> 1 comx730 compare 1 12345678901 -> -1 comx731 compare 1234567896 1 -> 1 comx732 compare 1 1234567896 -> -1 -- residue cases precision: 5 comx740 compare 1 0.9999999 -> 1 comx741 compare 1 0.999999 -> 1 comx742 compare 1 0.99999 -> 1 comx743 compare 1 1.0000 -> 0 comx744 compare 1 1.00001 -> -1 comx745 compare 1 1.000001 -> -1 comx746 compare 1 1.0000001 -> -1 comx750 compare 0.9999999 1 -> -1 comx751 compare 0.999999 1 -> -1 comx752 compare 0.99999 1 -> -1 comx753 compare 1.0000 1 -> 0 comx754 compare 1.00001 1 -> 1 comx755 compare 1.000001 1 -> 1 comx756 compare 1.0000001 1 -> 1 -- a selection of longies comx760 compare -36852134.84194296250843579428931 -5830629.8347085025808756560357940 -> -1 comx761 compare -36852134.84194296250843579428931 -36852134.84194296250843579428931 -> 0 comx762 compare -36852134.94194296250843579428931 -36852134.84194296250843579428931 -> -1 comx763 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 -- precisions above or below the difference should have no effect precision: 11 comx764 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 10 comx765 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 9 comx766 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 8 comx767 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 7 comx768 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 6 comx769 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 5 comx770 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 4 comx771 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 3 comx772 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 2 comx773 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 1 comx774 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 -- Specials precision: 9 comx780 compare Inf -Inf -> 1 comx781 compare Inf -1000 -> 1 comx782 compare Inf -1 -> 1 comx783 compare Inf -0 -> 1 comx784 compare Inf 0 -> 1 comx785 compare Inf 1 -> 1 comx786 compare Inf 1000 -> 1 comx787 compare Inf Inf -> 0 comx788 compare -1000 Inf -> -1 comx789 compare -Inf Inf -> -1 comx790 compare -1 Inf -> -1 comx791 compare -0 Inf -> -1 comx792 compare 0 Inf -> -1 comx793 compare 1 Inf -> -1 comx794 compare 1000 Inf -> -1 comx795 compare Inf Inf -> 0 comx800 compare -Inf -Inf -> 0 comx801 compare -Inf -1000 -> -1 comx802 compare -Inf -1 -> -1 comx803 compare -Inf -0 -> -1 comx804 compare -Inf 0 -> -1 comx805 compare -Inf 1 -> -1 comx806 compare -Inf 1000 -> -1 comx807 compare -Inf Inf -> -1 comx808 compare -Inf -Inf -> 0 comx809 compare -1000 -Inf -> 1 comx810 compare -1 -Inf -> 1 comx811 compare -0 -Inf -> 1 comx812 compare 0 -Inf -> 1 comx813 compare 1 -Inf -> 1 comx814 compare 1000 -Inf -> 1 comx815 compare Inf -Inf -> 1 comx821 compare NaN -Inf -> NaN comx822 compare NaN -1000 -> NaN comx823 compare NaN -1 -> NaN comx824 compare NaN -0 -> NaN comx825 compare NaN 0 -> NaN comx826 compare NaN 1 -> NaN comx827 compare NaN 1000 -> NaN comx828 compare NaN Inf -> NaN comx829 compare NaN NaN -> NaN comx830 compare -Inf NaN -> NaN comx831 compare -1000 NaN -> NaN comx832 compare -1 NaN -> NaN comx833 compare -0 NaN -> NaN comx834 compare 0 NaN -> NaN comx835 compare 1 NaN -> NaN comx836 compare 1000 NaN -> NaN comx837 compare Inf NaN -> NaN comx838 compare -NaN -NaN -> -NaN comx839 compare +NaN -NaN -> NaN comx840 compare -NaN +NaN -> -NaN comx841 compare sNaN -Inf -> NaN Invalid_operation comx842 compare sNaN -1000 -> NaN Invalid_operation comx843 compare sNaN -1 -> NaN Invalid_operation comx844 compare sNaN -0 -> NaN Invalid_operation comx845 compare sNaN 0 -> NaN Invalid_operation comx846 compare sNaN 1 -> NaN Invalid_operation comx847 compare sNaN 1000 -> NaN Invalid_operation comx848 compare sNaN NaN -> NaN Invalid_operation comx849 compare sNaN sNaN -> NaN Invalid_operation comx850 compare NaN sNaN -> NaN Invalid_operation comx851 compare -Inf sNaN -> NaN Invalid_operation comx852 compare -1000 sNaN -> NaN Invalid_operation comx853 compare -1 sNaN -> NaN Invalid_operation comx854 compare -0 sNaN -> NaN Invalid_operation comx855 compare 0 sNaN -> NaN Invalid_operation comx856 compare 1 sNaN -> NaN Invalid_operation comx857 compare 1000 sNaN -> NaN Invalid_operation comx858 compare Inf sNaN -> NaN Invalid_operation comx859 compare NaN sNaN -> NaN Invalid_operation -- propagating NaNs comx860 compare NaN9 -Inf -> NaN9 comx861 compare NaN8 999 -> NaN8 comx862 compare NaN77 Inf -> NaN77 comx863 compare -NaN67 NaN5 -> -NaN67 comx864 compare -Inf -NaN4 -> -NaN4 comx865 compare -999 -NaN33 -> -NaN33 comx866 compare Inf NaN2 -> NaN2 comx867 compare -NaN41 -NaN42 -> -NaN41 comx868 compare +NaN41 -NaN42 -> NaN41 comx869 compare -NaN41 +NaN42 -> -NaN41 comx870 compare +NaN41 +NaN42 -> NaN41 comx871 compare -sNaN99 -Inf -> -NaN99 Invalid_operation comx872 compare sNaN98 -11 -> NaN98 Invalid_operation comx873 compare sNaN97 NaN -> NaN97 Invalid_operation comx874 compare sNaN16 sNaN94 -> NaN16 Invalid_operation comx875 compare NaN85 sNaN83 -> NaN83 Invalid_operation comx876 compare -Inf sNaN92 -> NaN92 Invalid_operation comx877 compare 088 sNaN81 -> NaN81 Invalid_operation comx878 compare Inf sNaN90 -> NaN90 Invalid_operation comx879 compare NaN -sNaN89 -> -NaN89 Invalid_operation -- overflow and underflow tests .. subnormal results now allowed maxExponent: 999999999 minexponent: -999999999 comx880 compare +1.23456789012345E-0 9E+999999999 -> -1 comx881 compare 9E+999999999 +1.23456789012345E-0 -> 1 comx882 compare +0.100 9E-999999999 -> 1 comx883 compare 9E-999999999 +0.100 -> -1 comx885 compare -1.23456789012345E-0 9E+999999999 -> -1 comx886 compare 9E+999999999 -1.23456789012345E-0 -> 1 comx887 compare -0.100 9E-999999999 -> -1 comx888 compare 9E-999999999 -0.100 -> 1 comx889 compare 1e-599999999 1e-400000001 -> -1 comx890 compare 1e-599999999 1e-400000000 -> -1 comx891 compare 1e-600000000 1e-400000000 -> -1 comx892 compare 9e-999999998 0.01 -> -1 comx893 compare 9e-999999998 0.1 -> -1 comx894 compare 0.01 9e-999999998 -> 1 comx895 compare 1e599999999 1e400000001 -> 1 comx896 compare 1e599999999 1e400000000 -> 1 comx897 compare 1e600000000 1e400000000 -> 1 comx898 compare 9e999999998 100 -> 1 comx899 compare 9e999999998 10 -> 1 comx900 compare 100 9e999999998 -> -1 -- signs comx901 compare 1e+777777777 1e+411111111 -> 1 comx902 compare 1e+777777777 -1e+411111111 -> 1 comx903 compare -1e+777777777 1e+411111111 -> -1 comx904 compare -1e+777777777 -1e+411111111 -> -1 comx905 compare 1e-777777777 1e-411111111 -> -1 comx906 compare 1e-777777777 -1e-411111111 -> 1 comx907 compare -1e-777777777 1e-411111111 -> -1 comx908 compare -1e-777777777 -1e-411111111 -> 1 -- spread zeros comx910 compare 0E-383 0 -> 0 comx911 compare 0E-383 -0 -> 0 comx912 compare -0E-383 0 -> 0 comx913 compare -0E-383 -0 -> 0 comx914 compare 0E-383 0E+384 -> 0 comx915 compare 0E-383 -0E+384 -> 0 comx916 compare -0E-383 0E+384 -> 0 comx917 compare -0E-383 -0E+384 -> 0 comx918 compare 0 0E+384 -> 0 comx919 compare 0 -0E+384 -> 0 comx920 compare -0 0E+384 -> 0 comx921 compare -0 -0E+384 -> 0 comx930 compare 0E+384 0 -> 0 comx931 compare 0E+384 -0 -> 0 comx932 compare -0E+384 0 -> 0 comx933 compare -0E+384 -0 -> 0 comx934 compare 0E+384 0E-383 -> 0 comx935 compare 0E+384 -0E-383 -> 0 comx936 compare -0E+384 0E-383 -> 0 comx937 compare -0E+384 -0E-383 -> 0 comx938 compare 0 0E-383 -> 0 comx939 compare 0 -0E-383 -> 0 comx940 compare -0 0E-383 -> 0 comx941 compare -0 -0E-383 -> 0 -- Null tests comx990 compare 10 # -> NaN Invalid_operation comx991 compare # 10 -> NaN Invalid_operation apd-3.2.1/testdata/comparetotal.decTest000066400000000000000000001030551450022325000200760ustar00rootroot00000000000000------------------------------------------------------------------------ -- comparetotal.decTest -- decimal comparison using total ordering -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- Note that we cannot assume add/subtract tests cover paths adequately, -- here, because the code might be quite different (comparison cannot -- overflow or underflow, so actual subtractions are not necessary). -- Similarly, comparetotal will have some radically different paths -- than compare. extended: 1 precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 -- sanity checks cotx001 comparetotal -2 -2 -> 0 cotx002 comparetotal -2 -1 -> -1 cotx003 comparetotal -2 0 -> -1 cotx004 comparetotal -2 1 -> -1 cotx005 comparetotal -2 2 -> -1 cotx006 comparetotal -1 -2 -> 1 cotx007 comparetotal -1 -1 -> 0 cotx008 comparetotal -1 0 -> -1 cotx009 comparetotal -1 1 -> -1 cotx010 comparetotal -1 2 -> -1 cotx011 comparetotal 0 -2 -> 1 cotx012 comparetotal 0 -1 -> 1 cotx013 comparetotal 0 0 -> 0 cotx014 comparetotal 0 1 -> -1 cotx015 comparetotal 0 2 -> -1 cotx016 comparetotal 1 -2 -> 1 cotx017 comparetotal 1 -1 -> 1 cotx018 comparetotal 1 0 -> 1 cotx019 comparetotal 1 1 -> 0 cotx020 comparetotal 1 2 -> -1 cotx021 comparetotal 2 -2 -> 1 cotx022 comparetotal 2 -1 -> 1 cotx023 comparetotal 2 0 -> 1 cotx025 comparetotal 2 1 -> 1 cotx026 comparetotal 2 2 -> 0 cotx031 comparetotal -20 -20 -> 0 cotx032 comparetotal -20 -10 -> -1 cotx033 comparetotal -20 00 -> -1 cotx034 comparetotal -20 10 -> -1 cotx035 comparetotal -20 20 -> -1 cotx036 comparetotal -10 -20 -> 1 cotx037 comparetotal -10 -10 -> 0 cotx038 comparetotal -10 00 -> -1 cotx039 comparetotal -10 10 -> -1 cotx040 comparetotal -10 20 -> -1 cotx041 comparetotal 00 -20 -> 1 cotx042 comparetotal 00 -10 -> 1 cotx043 comparetotal 00 00 -> 0 cotx044 comparetotal 00 10 -> -1 cotx045 comparetotal 00 20 -> -1 cotx046 comparetotal 10 -20 -> 1 cotx047 comparetotal 10 -10 -> 1 cotx048 comparetotal 10 00 -> 1 cotx049 comparetotal 10 10 -> 0 cotx050 comparetotal 10 20 -> -1 cotx051 comparetotal 20 -20 -> 1 cotx052 comparetotal 20 -10 -> 1 cotx053 comparetotal 20 00 -> 1 cotx055 comparetotal 20 10 -> 1 cotx056 comparetotal 20 20 -> 0 cotx061 comparetotal -2.0 -2.0 -> 0 cotx062 comparetotal -2.0 -1.0 -> -1 cotx063 comparetotal -2.0 0.0 -> -1 cotx064 comparetotal -2.0 1.0 -> -1 cotx065 comparetotal -2.0 2.0 -> -1 cotx066 comparetotal -1.0 -2.0 -> 1 cotx067 comparetotal -1.0 -1.0 -> 0 cotx068 comparetotal -1.0 0.0 -> -1 cotx069 comparetotal -1.0 1.0 -> -1 cotx070 comparetotal -1.0 2.0 -> -1 cotx071 comparetotal 0.0 -2.0 -> 1 cotx072 comparetotal 0.0 -1.0 -> 1 cotx073 comparetotal 0.0 0.0 -> 0 cotx074 comparetotal 0.0 1.0 -> -1 cotx075 comparetotal 0.0 2.0 -> -1 cotx076 comparetotal 1.0 -2.0 -> 1 cotx077 comparetotal 1.0 -1.0 -> 1 cotx078 comparetotal 1.0 0.0 -> 1 cotx079 comparetotal 1.0 1.0 -> 0 cotx080 comparetotal 1.0 2.0 -> -1 cotx081 comparetotal 2.0 -2.0 -> 1 cotx082 comparetotal 2.0 -1.0 -> 1 cotx083 comparetotal 2.0 0.0 -> 1 cotx085 comparetotal 2.0 1.0 -> 1 cotx086 comparetotal 2.0 2.0 -> 0 -- now some cases which might overflow if subtract were used maxexponent: 999999999 minexponent: -999999999 cotx090 comparetotal 9.99999999E+999999999 9.99999999E+999999999 -> 0 cotx091 comparetotal -9.99999999E+999999999 9.99999999E+999999999 -> -1 cotx092 comparetotal 9.99999999E+999999999 -9.99999999E+999999999 -> 1 cotx093 comparetotal -9.99999999E+999999999 -9.99999999E+999999999 -> 0 -- Examples cotx094 comparetotal 12.73 127.9 -> -1 cotx095 comparetotal -127 12 -> -1 cotx096 comparetotal 12.30 12.3 -> -1 cotx097 comparetotal 12.30 12.30 -> 0 cotx098 comparetotal 12.3 12.300 -> 1 cotx099 comparetotal 12.3 NaN -> -1 -- some differing length/exponent cases -- in this first group, compare would compare all equal cotx100 comparetotal 7.0 7.0 -> 0 cotx101 comparetotal 7.0 7 -> -1 cotx102 comparetotal 7 7.0 -> 1 cotx103 comparetotal 7E+0 7.0 -> 1 cotx104 comparetotal 70E-1 7.0 -> 0 cotx105 comparetotal 0.7E+1 7 -> 0 cotx106 comparetotal 70E-1 7 -> -1 cotx107 comparetotal 7.0 7E+0 -> -1 cotx108 comparetotal 7.0 70E-1 -> 0 cotx109 comparetotal 7 0.7E+1 -> 0 cotx110 comparetotal 7 70E-1 -> 1 cotx120 comparetotal 8.0 7.0 -> 1 cotx121 comparetotal 8.0 7 -> 1 cotx122 comparetotal 8 7.0 -> 1 cotx123 comparetotal 8E+0 7.0 -> 1 cotx124 comparetotal 80E-1 7.0 -> 1 cotx125 comparetotal 0.8E+1 7 -> 1 cotx126 comparetotal 80E-1 7 -> 1 cotx127 comparetotal 8.0 7E+0 -> 1 cotx128 comparetotal 8.0 70E-1 -> 1 cotx129 comparetotal 8 0.7E+1 -> 1 cotx130 comparetotal 8 70E-1 -> 1 cotx140 comparetotal 8.0 9.0 -> -1 cotx141 comparetotal 8.0 9 -> -1 cotx142 comparetotal 8 9.0 -> -1 cotx143 comparetotal 8E+0 9.0 -> -1 cotx144 comparetotal 80E-1 9.0 -> -1 cotx145 comparetotal 0.8E+1 9 -> -1 cotx146 comparetotal 80E-1 9 -> -1 cotx147 comparetotal 8.0 9E+0 -> -1 cotx148 comparetotal 8.0 90E-1 -> -1 cotx149 comparetotal 8 0.9E+1 -> -1 cotx150 comparetotal 8 90E-1 -> -1 -- and again, with sign changes -+ .. cotx200 comparetotal -7.0 7.0 -> -1 cotx201 comparetotal -7.0 7 -> -1 cotx202 comparetotal -7 7.0 -> -1 cotx203 comparetotal -7E+0 7.0 -> -1 cotx204 comparetotal -70E-1 7.0 -> -1 cotx205 comparetotal -0.7E+1 7 -> -1 cotx206 comparetotal -70E-1 7 -> -1 cotx207 comparetotal -7.0 7E+0 -> -1 cotx208 comparetotal -7.0 70E-1 -> -1 cotx209 comparetotal -7 0.7E+1 -> -1 cotx210 comparetotal -7 70E-1 -> -1 cotx220 comparetotal -8.0 7.0 -> -1 cotx221 comparetotal -8.0 7 -> -1 cotx222 comparetotal -8 7.0 -> -1 cotx223 comparetotal -8E+0 7.0 -> -1 cotx224 comparetotal -80E-1 7.0 -> -1 cotx225 comparetotal -0.8E+1 7 -> -1 cotx226 comparetotal -80E-1 7 -> -1 cotx227 comparetotal -8.0 7E+0 -> -1 cotx228 comparetotal -8.0 70E-1 -> -1 cotx229 comparetotal -8 0.7E+1 -> -1 cotx230 comparetotal -8 70E-1 -> -1 cotx240 comparetotal -8.0 9.0 -> -1 cotx241 comparetotal -8.0 9 -> -1 cotx242 comparetotal -8 9.0 -> -1 cotx243 comparetotal -8E+0 9.0 -> -1 cotx244 comparetotal -80E-1 9.0 -> -1 cotx245 comparetotal -0.8E+1 9 -> -1 cotx246 comparetotal -80E-1 9 -> -1 cotx247 comparetotal -8.0 9E+0 -> -1 cotx248 comparetotal -8.0 90E-1 -> -1 cotx249 comparetotal -8 0.9E+1 -> -1 cotx250 comparetotal -8 90E-1 -> -1 -- and again, with sign changes +- .. cotx300 comparetotal 7.0 -7.0 -> 1 cotx301 comparetotal 7.0 -7 -> 1 cotx302 comparetotal 7 -7.0 -> 1 cotx303 comparetotal 7E+0 -7.0 -> 1 cotx304 comparetotal 70E-1 -7.0 -> 1 cotx305 comparetotal .7E+1 -7 -> 1 cotx306 comparetotal 70E-1 -7 -> 1 cotx307 comparetotal 7.0 -7E+0 -> 1 cotx308 comparetotal 7.0 -70E-1 -> 1 cotx309 comparetotal 7 -.7E+1 -> 1 cotx310 comparetotal 7 -70E-1 -> 1 cotx320 comparetotal 8.0 -7.0 -> 1 cotx321 comparetotal 8.0 -7 -> 1 cotx322 comparetotal 8 -7.0 -> 1 cotx323 comparetotal 8E+0 -7.0 -> 1 cotx324 comparetotal 80E-1 -7.0 -> 1 cotx325 comparetotal .8E+1 -7 -> 1 cotx326 comparetotal 80E-1 -7 -> 1 cotx327 comparetotal 8.0 -7E+0 -> 1 cotx328 comparetotal 8.0 -70E-1 -> 1 cotx329 comparetotal 8 -.7E+1 -> 1 cotx330 comparetotal 8 -70E-1 -> 1 cotx340 comparetotal 8.0 -9.0 -> 1 cotx341 comparetotal 8.0 -9 -> 1 cotx342 comparetotal 8 -9.0 -> 1 cotx343 comparetotal 8E+0 -9.0 -> 1 cotx344 comparetotal 80E-1 -9.0 -> 1 cotx345 comparetotal .8E+1 -9 -> 1 cotx346 comparetotal 80E-1 -9 -> 1 cotx347 comparetotal 8.0 -9E+0 -> 1 cotx348 comparetotal 8.0 -90E-1 -> 1 cotx349 comparetotal 8 -.9E+1 -> 1 cotx350 comparetotal 8 -90E-1 -> 1 -- and again, with sign changes -- .. cotx400 comparetotal -7.0 -7.0 -> 0 cotx401 comparetotal -7.0 -7 -> 1 cotx402 comparetotal -7 -7.0 -> -1 cotx403 comparetotal -7E+0 -7.0 -> -1 cotx404 comparetotal -70E-1 -7.0 -> 0 cotx405 comparetotal -.7E+1 -7 -> 0 cotx406 comparetotal -70E-1 -7 -> 1 cotx407 comparetotal -7.0 -7E+0 -> 1 cotx408 comparetotal -7.0 -70E-1 -> 0 cotx409 comparetotal -7 -.7E+1 -> 0 cotx410 comparetotal -7 -70E-1 -> -1 cotx420 comparetotal -8.0 -7.0 -> -1 cotx421 comparetotal -8.0 -7 -> -1 cotx422 comparetotal -8 -7.0 -> -1 cotx423 comparetotal -8E+0 -7.0 -> -1 cotx424 comparetotal -80E-1 -7.0 -> -1 cotx425 comparetotal -.8E+1 -7 -> -1 cotx426 comparetotal -80E-1 -7 -> -1 cotx427 comparetotal -8.0 -7E+0 -> -1 cotx428 comparetotal -8.0 -70E-1 -> -1 cotx429 comparetotal -8 -.7E+1 -> -1 cotx430 comparetotal -8 -70E-1 -> -1 cotx440 comparetotal -8.0 -9.0 -> 1 cotx441 comparetotal -8.0 -9 -> 1 cotx442 comparetotal -8 -9.0 -> 1 cotx443 comparetotal -8E+0 -9.0 -> 1 cotx444 comparetotal -80E-1 -9.0 -> 1 cotx445 comparetotal -.8E+1 -9 -> 1 cotx446 comparetotal -80E-1 -9 -> 1 cotx447 comparetotal -8.0 -9E+0 -> 1 cotx448 comparetotal -8.0 -90E-1 -> 1 cotx449 comparetotal -8 -.9E+1 -> 1 cotx450 comparetotal -8 -90E-1 -> 1 -- testcases that subtract to lots of zeros at boundaries [pgr] precision: 40 cotx470 comparetotal 123.4560000000000000E789 123.456E789 -> -1 cotx471 comparetotal 123.456000000000000E-89 123.456E-89 -> -1 cotx472 comparetotal 123.45600000000000E789 123.456E789 -> -1 cotx473 comparetotal 123.4560000000000E-89 123.456E-89 -> -1 cotx474 comparetotal 123.456000000000E789 123.456E789 -> -1 cotx475 comparetotal 123.45600000000E-89 123.456E-89 -> -1 cotx476 comparetotal 123.4560000000E789 123.456E789 -> -1 cotx477 comparetotal 123.456000000E-89 123.456E-89 -> -1 cotx478 comparetotal 123.45600000E789 123.456E789 -> -1 cotx479 comparetotal 123.4560000E-89 123.456E-89 -> -1 cotx480 comparetotal 123.456000E789 123.456E789 -> -1 cotx481 comparetotal 123.45600E-89 123.456E-89 -> -1 cotx482 comparetotal 123.4560E789 123.456E789 -> -1 cotx483 comparetotal 123.456E-89 123.456E-89 -> 0 cotx484 comparetotal 123.456E-89 123.4560000000000000E-89 -> 1 cotx485 comparetotal 123.456E789 123.456000000000000E789 -> 1 cotx486 comparetotal 123.456E-89 123.45600000000000E-89 -> 1 cotx487 comparetotal 123.456E789 123.4560000000000E789 -> 1 cotx488 comparetotal 123.456E-89 123.456000000000E-89 -> 1 cotx489 comparetotal 123.456E789 123.45600000000E789 -> 1 cotx490 comparetotal 123.456E-89 123.4560000000E-89 -> 1 cotx491 comparetotal 123.456E789 123.456000000E789 -> 1 cotx492 comparetotal 123.456E-89 123.45600000E-89 -> 1 cotx493 comparetotal 123.456E789 123.4560000E789 -> 1 cotx494 comparetotal 123.456E-89 123.456000E-89 -> 1 cotx495 comparetotal 123.456E789 123.45600E789 -> 1 cotx496 comparetotal 123.456E-89 123.4560E-89 -> 1 cotx497 comparetotal 123.456E789 123.456E789 -> 0 -- wide-ranging, around precision; signs equal precision: 9 cotx500 comparetotal 1 1E-15 -> 1 cotx501 comparetotal 1 1E-14 -> 1 cotx502 comparetotal 1 1E-13 -> 1 cotx503 comparetotal 1 1E-12 -> 1 cotx504 comparetotal 1 1E-11 -> 1 cotx505 comparetotal 1 1E-10 -> 1 cotx506 comparetotal 1 1E-9 -> 1 cotx507 comparetotal 1 1E-8 -> 1 cotx508 comparetotal 1 1E-7 -> 1 cotx509 comparetotal 1 1E-6 -> 1 cotx510 comparetotal 1 1E-5 -> 1 cotx511 comparetotal 1 1E-4 -> 1 cotx512 comparetotal 1 1E-3 -> 1 cotx513 comparetotal 1 1E-2 -> 1 cotx514 comparetotal 1 1E-1 -> 1 cotx515 comparetotal 1 1E-0 -> 0 cotx516 comparetotal 1 1E+1 -> -1 cotx517 comparetotal 1 1E+2 -> -1 cotx518 comparetotal 1 1E+3 -> -1 cotx519 comparetotal 1 1E+4 -> -1 cotx521 comparetotal 1 1E+5 -> -1 cotx522 comparetotal 1 1E+6 -> -1 cotx523 comparetotal 1 1E+7 -> -1 cotx524 comparetotal 1 1E+8 -> -1 cotx525 comparetotal 1 1E+9 -> -1 cotx526 comparetotal 1 1E+10 -> -1 cotx527 comparetotal 1 1E+11 -> -1 cotx528 comparetotal 1 1E+12 -> -1 cotx529 comparetotal 1 1E+13 -> -1 cotx530 comparetotal 1 1E+14 -> -1 cotx531 comparetotal 1 1E+15 -> -1 -- LR swap cotx540 comparetotal 1E-15 1 -> -1 cotx541 comparetotal 1E-14 1 -> -1 cotx542 comparetotal 1E-13 1 -> -1 cotx543 comparetotal 1E-12 1 -> -1 cotx544 comparetotal 1E-11 1 -> -1 cotx545 comparetotal 1E-10 1 -> -1 cotx546 comparetotal 1E-9 1 -> -1 cotx547 comparetotal 1E-8 1 -> -1 cotx548 comparetotal 1E-7 1 -> -1 cotx549 comparetotal 1E-6 1 -> -1 cotx550 comparetotal 1E-5 1 -> -1 cotx551 comparetotal 1E-4 1 -> -1 cotx552 comparetotal 1E-3 1 -> -1 cotx553 comparetotal 1E-2 1 -> -1 cotx554 comparetotal 1E-1 1 -> -1 cotx555 comparetotal 1E-0 1 -> 0 cotx556 comparetotal 1E+1 1 -> 1 cotx557 comparetotal 1E+2 1 -> 1 cotx558 comparetotal 1E+3 1 -> 1 cotx559 comparetotal 1E+4 1 -> 1 cotx561 comparetotal 1E+5 1 -> 1 cotx562 comparetotal 1E+6 1 -> 1 cotx563 comparetotal 1E+7 1 -> 1 cotx564 comparetotal 1E+8 1 -> 1 cotx565 comparetotal 1E+9 1 -> 1 cotx566 comparetotal 1E+10 1 -> 1 cotx567 comparetotal 1E+11 1 -> 1 cotx568 comparetotal 1E+12 1 -> 1 cotx569 comparetotal 1E+13 1 -> 1 cotx570 comparetotal 1E+14 1 -> 1 cotx571 comparetotal 1E+15 1 -> 1 -- similar with an useful coefficient, one side only cotx580 comparetotal 0.000000987654321 1E-15 -> 1 cotx581 comparetotal 0.000000987654321 1E-14 -> 1 cotx582 comparetotal 0.000000987654321 1E-13 -> 1 cotx583 comparetotal 0.000000987654321 1E-12 -> 1 cotx584 comparetotal 0.000000987654321 1E-11 -> 1 cotx585 comparetotal 0.000000987654321 1E-10 -> 1 cotx586 comparetotal 0.000000987654321 1E-9 -> 1 cotx587 comparetotal 0.000000987654321 1E-8 -> 1 cotx588 comparetotal 0.000000987654321 1E-7 -> 1 cotx589 comparetotal 0.000000987654321 1E-6 -> -1 cotx590 comparetotal 0.000000987654321 1E-5 -> -1 cotx591 comparetotal 0.000000987654321 1E-4 -> -1 cotx592 comparetotal 0.000000987654321 1E-3 -> -1 cotx593 comparetotal 0.000000987654321 1E-2 -> -1 cotx594 comparetotal 0.000000987654321 1E-1 -> -1 cotx595 comparetotal 0.000000987654321 1E-0 -> -1 cotx596 comparetotal 0.000000987654321 1E+1 -> -1 cotx597 comparetotal 0.000000987654321 1E+2 -> -1 cotx598 comparetotal 0.000000987654321 1E+3 -> -1 cotx599 comparetotal 0.000000987654321 1E+4 -> -1 -- check some unit-y traps precision: 20 cotx600 comparetotal 12 12.2345 -> -1 cotx601 comparetotal 12.0 12.2345 -> -1 cotx602 comparetotal 12.00 12.2345 -> -1 cotx603 comparetotal 12.000 12.2345 -> -1 cotx604 comparetotal 12.0000 12.2345 -> -1 cotx605 comparetotal 12.00000 12.2345 -> -1 cotx606 comparetotal 12.000000 12.2345 -> -1 cotx607 comparetotal 12.0000000 12.2345 -> -1 cotx608 comparetotal 12.00000000 12.2345 -> -1 cotx609 comparetotal 12.000000000 12.2345 -> -1 cotx610 comparetotal 12.1234 12 -> 1 cotx611 comparetotal 12.1234 12.0 -> 1 cotx612 comparetotal 12.1234 12.00 -> 1 cotx613 comparetotal 12.1234 12.000 -> 1 cotx614 comparetotal 12.1234 12.0000 -> 1 cotx615 comparetotal 12.1234 12.00000 -> 1 cotx616 comparetotal 12.1234 12.000000 -> 1 cotx617 comparetotal 12.1234 12.0000000 -> 1 cotx618 comparetotal 12.1234 12.00000000 -> 1 cotx619 comparetotal 12.1234 12.000000000 -> 1 cotx620 comparetotal -12 -12.2345 -> 1 cotx621 comparetotal -12.0 -12.2345 -> 1 cotx622 comparetotal -12.00 -12.2345 -> 1 cotx623 comparetotal -12.000 -12.2345 -> 1 cotx624 comparetotal -12.0000 -12.2345 -> 1 cotx625 comparetotal -12.00000 -12.2345 -> 1 cotx626 comparetotal -12.000000 -12.2345 -> 1 cotx627 comparetotal -12.0000000 -12.2345 -> 1 cotx628 comparetotal -12.00000000 -12.2345 -> 1 cotx629 comparetotal -12.000000000 -12.2345 -> 1 cotx630 comparetotal -12.1234 -12 -> -1 cotx631 comparetotal -12.1234 -12.0 -> -1 cotx632 comparetotal -12.1234 -12.00 -> -1 cotx633 comparetotal -12.1234 -12.000 -> -1 cotx634 comparetotal -12.1234 -12.0000 -> -1 cotx635 comparetotal -12.1234 -12.00000 -> -1 cotx636 comparetotal -12.1234 -12.000000 -> -1 cotx637 comparetotal -12.1234 -12.0000000 -> -1 cotx638 comparetotal -12.1234 -12.00000000 -> -1 cotx639 comparetotal -12.1234 -12.000000000 -> -1 precision: 9 -- extended zeros cotx640 comparetotal 0 0 -> 0 cotx641 comparetotal 0 -0 -> 1 cotx642 comparetotal 0 -0.0 -> 1 cotx643 comparetotal 0 0.0 -> 1 cotx644 comparetotal -0 0 -> -1 cotx645 comparetotal -0 -0 -> 0 cotx646 comparetotal -0 -0.0 -> -1 cotx647 comparetotal -0 0.0 -> -1 cotx648 comparetotal 0.0 0 -> -1 cotx649 comparetotal 0.0 -0 -> 1 cotx650 comparetotal 0.0 -0.0 -> 1 cotx651 comparetotal 0.0 0.0 -> 0 cotx652 comparetotal -0.0 0 -> -1 cotx653 comparetotal -0.0 -0 -> 1 cotx654 comparetotal -0.0 -0.0 -> 0 cotx655 comparetotal -0.0 0.0 -> -1 cotx656 comparetotal -0E1 0.0 -> -1 cotx657 comparetotal -0E2 0.0 -> -1 cotx658 comparetotal 0E1 0.0 -> 1 cotx659 comparetotal 0E2 0.0 -> 1 cotx660 comparetotal -0E1 0 -> -1 cotx661 comparetotal -0E2 0 -> -1 cotx662 comparetotal 0E1 0 -> 1 cotx663 comparetotal 0E2 0 -> 1 cotx664 comparetotal -0E1 -0E1 -> 0 cotx665 comparetotal -0E2 -0E1 -> -1 cotx666 comparetotal 0E1 -0E1 -> 1 cotx667 comparetotal 0E2 -0E1 -> 1 cotx668 comparetotal -0E1 -0E2 -> 1 cotx669 comparetotal -0E2 -0E2 -> 0 cotx670 comparetotal 0E1 -0E2 -> 1 cotx671 comparetotal 0E2 -0E2 -> 1 cotx672 comparetotal -0E1 0E1 -> -1 cotx673 comparetotal -0E2 0E1 -> -1 cotx674 comparetotal 0E1 0E1 -> 0 cotx675 comparetotal 0E2 0E1 -> 1 cotx676 comparetotal -0E1 0E2 -> -1 cotx677 comparetotal -0E2 0E2 -> -1 cotx678 comparetotal 0E1 0E2 -> -1 cotx679 comparetotal 0E2 0E2 -> 0 -- trailing zeros; unit-y precision: 20 cotx680 comparetotal 12 12 -> 0 cotx681 comparetotal 12 12.0 -> 1 cotx682 comparetotal 12 12.00 -> 1 cotx683 comparetotal 12 12.000 -> 1 cotx684 comparetotal 12 12.0000 -> 1 cotx685 comparetotal 12 12.00000 -> 1 cotx686 comparetotal 12 12.000000 -> 1 cotx687 comparetotal 12 12.0000000 -> 1 cotx688 comparetotal 12 12.00000000 -> 1 cotx689 comparetotal 12 12.000000000 -> 1 cotx690 comparetotal 12 12 -> 0 cotx691 comparetotal 12.0 12 -> -1 cotx692 comparetotal 12.00 12 -> -1 cotx693 comparetotal 12.000 12 -> -1 cotx694 comparetotal 12.0000 12 -> -1 cotx695 comparetotal 12.00000 12 -> -1 cotx696 comparetotal 12.000000 12 -> -1 cotx697 comparetotal 12.0000000 12 -> -1 cotx698 comparetotal 12.00000000 12 -> -1 cotx699 comparetotal 12.000000000 12 -> -1 -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 cotx701 comparetotal 12345678000 1 -> 1 cotx702 comparetotal 1 12345678000 -> -1 cotx703 comparetotal 1234567800 1 -> 1 cotx704 comparetotal 1 1234567800 -> -1 cotx705 comparetotal 1234567890 1 -> 1 cotx706 comparetotal 1 1234567890 -> -1 cotx707 comparetotal 1234567891 1 -> 1 cotx708 comparetotal 1 1234567891 -> -1 cotx709 comparetotal 12345678901 1 -> 1 cotx710 comparetotal 1 12345678901 -> -1 cotx711 comparetotal 1234567896 1 -> 1 cotx712 comparetotal 1 1234567896 -> -1 cotx713 comparetotal -1234567891 1 -> -1 cotx714 comparetotal 1 -1234567891 -> 1 cotx715 comparetotal -12345678901 1 -> -1 cotx716 comparetotal 1 -12345678901 -> 1 cotx717 comparetotal -1234567896 1 -> -1 cotx718 comparetotal 1 -1234567896 -> 1 precision: 15 -- same with plenty of precision cotx721 comparetotal 12345678000 1 -> 1 cotx722 comparetotal 1 12345678000 -> -1 cotx723 comparetotal 1234567800 1 -> 1 cotx724 comparetotal 1 1234567800 -> -1 cotx725 comparetotal 1234567890 1 -> 1 cotx726 comparetotal 1 1234567890 -> -1 cotx727 comparetotal 1234567891 1 -> 1 cotx728 comparetotal 1 1234567891 -> -1 cotx729 comparetotal 12345678901 1 -> 1 cotx730 comparetotal 1 12345678901 -> -1 cotx731 comparetotal 1234567896 1 -> 1 cotx732 comparetotal 1 1234567896 -> -1 -- residue cases precision: 5 cotx740 comparetotal 1 0.9999999 -> 1 cotx741 comparetotal 1 0.999999 -> 1 cotx742 comparetotal 1 0.99999 -> 1 cotx743 comparetotal 1 1.0000 -> 1 cotx744 comparetotal 1 1.00001 -> -1 cotx745 comparetotal 1 1.000001 -> -1 cotx746 comparetotal 1 1.0000001 -> -1 cotx750 comparetotal 0.9999999 1 -> -1 cotx751 comparetotal 0.999999 1 -> -1 cotx752 comparetotal 0.99999 1 -> -1 cotx753 comparetotal 1.0000 1 -> -1 cotx754 comparetotal 1.00001 1 -> 1 cotx755 comparetotal 1.000001 1 -> 1 cotx756 comparetotal 1.0000001 1 -> 1 -- a selection of longies cotx760 comparetotal -36852134.84194296250843579428931 -5830629.8347085025808756560357940 -> -1 cotx761 comparetotal -36852134.84194296250843579428931 -36852134.84194296250843579428931 -> 0 cotx762 comparetotal -36852134.94194296250843579428931 -36852134.84194296250843579428931 -> -1 cotx763 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 -- precisions above or below the difference should have no effect precision: 11 cotx764 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 10 cotx765 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 9 cotx766 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 8 cotx767 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 7 cotx768 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 6 cotx769 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 5 cotx770 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 4 cotx771 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 3 cotx772 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 2 cotx773 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 precision: 1 cotx774 comparetotal -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1 -- Specials precision: 9 cotx780 comparetotal Inf -Inf -> 1 cotx781 comparetotal Inf -1000 -> 1 cotx782 comparetotal Inf -1 -> 1 cotx783 comparetotal Inf -0 -> 1 cotx784 comparetotal Inf 0 -> 1 cotx785 comparetotal Inf 1 -> 1 cotx786 comparetotal Inf 1000 -> 1 cotx787 comparetotal Inf Inf -> 0 cotx788 comparetotal -1000 Inf -> -1 cotx789 comparetotal -Inf Inf -> -1 cotx790 comparetotal -1 Inf -> -1 cotx791 comparetotal -0 Inf -> -1 cotx792 comparetotal 0 Inf -> -1 cotx793 comparetotal 1 Inf -> -1 cotx794 comparetotal 1000 Inf -> -1 cotx795 comparetotal Inf Inf -> 0 cotx800 comparetotal -Inf -Inf -> 0 cotx801 comparetotal -Inf -1000 -> -1 cotx802 comparetotal -Inf -1 -> -1 cotx803 comparetotal -Inf -0 -> -1 cotx804 comparetotal -Inf 0 -> -1 cotx805 comparetotal -Inf 1 -> -1 cotx806 comparetotal -Inf 1000 -> -1 cotx807 comparetotal -Inf Inf -> -1 cotx808 comparetotal -Inf -Inf -> 0 cotx809 comparetotal -1000 -Inf -> 1 cotx810 comparetotal -1 -Inf -> 1 cotx811 comparetotal -0 -Inf -> 1 cotx812 comparetotal 0 -Inf -> 1 cotx813 comparetotal 1 -Inf -> 1 cotx814 comparetotal 1000 -Inf -> 1 cotx815 comparetotal Inf -Inf -> 1 cotx821 comparetotal NaN -Inf -> 1 cotx822 comparetotal NaN -1000 -> 1 cotx823 comparetotal NaN -1 -> 1 cotx824 comparetotal NaN -0 -> 1 cotx825 comparetotal NaN 0 -> 1 cotx826 comparetotal NaN 1 -> 1 cotx827 comparetotal NaN 1000 -> 1 cotx828 comparetotal NaN Inf -> 1 cotx829 comparetotal NaN NaN -> 0 cotx830 comparetotal -Inf NaN -> -1 cotx831 comparetotal -1000 NaN -> -1 cotx832 comparetotal -1 NaN -> -1 cotx833 comparetotal -0 NaN -> -1 cotx834 comparetotal 0 NaN -> -1 cotx835 comparetotal 1 NaN -> -1 cotx836 comparetotal 1000 NaN -> -1 cotx837 comparetotal Inf NaN -> -1 cotx838 comparetotal -NaN -NaN -> 0 cotx839 comparetotal +NaN -NaN -> 1 cotx840 comparetotal -NaN +NaN -> -1 cotx841 comparetotal sNaN -sNaN -> 1 cotx842 comparetotal sNaN -NaN -> 1 cotx843 comparetotal sNaN -Inf -> 1 cotx844 comparetotal sNaN -1000 -> 1 cotx845 comparetotal sNaN -1 -> 1 cotx846 comparetotal sNaN -0 -> 1 cotx847 comparetotal sNaN 0 -> 1 cotx848 comparetotal sNaN 1 -> 1 cotx849 comparetotal sNaN 1000 -> 1 cotx850 comparetotal sNaN NaN -> -1 cotx851 comparetotal sNaN sNaN -> 0 cotx852 comparetotal -sNaN sNaN -> -1 cotx853 comparetotal -NaN sNaN -> -1 cotx854 comparetotal -Inf sNaN -> -1 cotx855 comparetotal -1000 sNaN -> -1 cotx856 comparetotal -1 sNaN -> -1 cotx857 comparetotal -0 sNaN -> -1 cotx858 comparetotal 0 sNaN -> -1 cotx859 comparetotal 1 sNaN -> -1 cotx860 comparetotal 1000 sNaN -> -1 cotx861 comparetotal Inf sNaN -> -1 cotx862 comparetotal NaN sNaN -> 1 cotx863 comparetotal sNaN sNaN -> 0 cotx871 comparetotal -sNaN -sNaN -> 0 cotx872 comparetotal -sNaN -NaN -> 1 cotx873 comparetotal -sNaN -Inf -> -1 cotx874 comparetotal -sNaN -1000 -> -1 cotx875 comparetotal -sNaN -1 -> -1 cotx876 comparetotal -sNaN -0 -> -1 cotx877 comparetotal -sNaN 0 -> -1 cotx878 comparetotal -sNaN 1 -> -1 cotx879 comparetotal -sNaN 1000 -> -1 cotx880 comparetotal -sNaN NaN -> -1 cotx881 comparetotal -sNaN sNaN -> -1 cotx882 comparetotal -sNaN -sNaN -> 0 cotx883 comparetotal -NaN -sNaN -> -1 cotx884 comparetotal -Inf -sNaN -> 1 cotx885 comparetotal -1000 -sNaN -> 1 cotx886 comparetotal -1 -sNaN -> 1 cotx887 comparetotal -0 -sNaN -> 1 cotx888 comparetotal 0 -sNaN -> 1 cotx889 comparetotal 1 -sNaN -> 1 cotx890 comparetotal 1000 -sNaN -> 1 cotx891 comparetotal Inf -sNaN -> 1 cotx892 comparetotal NaN -sNaN -> 1 cotx893 comparetotal sNaN -sNaN -> 1 -- NaNs with payload cotx960 comparetotal NaN9 -Inf -> 1 cotx961 comparetotal NaN8 999 -> 1 cotx962 comparetotal NaN77 Inf -> 1 cotx963 comparetotal -NaN67 NaN5 -> -1 cotx964 comparetotal -Inf -NaN4 -> 1 cotx965 comparetotal -999 -NaN33 -> 1 cotx966 comparetotal Inf NaN2 -> -1 cotx970 comparetotal -NaN41 -NaN42 -> 1 cotx971 comparetotal +NaN41 -NaN42 -> 1 cotx972 comparetotal -NaN41 +NaN42 -> -1 cotx973 comparetotal +NaN41 +NaN42 -> -1 cotx974 comparetotal -NaN42 -NaN01 -> -1 cotx975 comparetotal +NaN42 -NaN01 -> 1 cotx976 comparetotal -NaN42 +NaN01 -> -1 cotx977 comparetotal +NaN42 +NaN01 -> 1 cotx980 comparetotal -sNaN771 -sNaN772 -> 1 cotx981 comparetotal +sNaN771 -sNaN772 -> 1 cotx982 comparetotal -sNaN771 +sNaN772 -> -1 cotx983 comparetotal +sNaN771 +sNaN772 -> -1 cotx984 comparetotal -sNaN772 -sNaN771 -> -1 cotx985 comparetotal +sNaN772 -sNaN771 -> 1 cotx986 comparetotal -sNaN772 +sNaN771 -> -1 cotx987 comparetotal +sNaN772 +sNaN771 -> 1 cotx991 comparetotal -sNaN99 -Inf -> -1 cotx992 comparetotal sNaN98 -11 -> 1 cotx993 comparetotal sNaN97 NaN -> -1 cotx994 comparetotal sNaN16 sNaN94 -> -1 cotx995 comparetotal NaN85 sNaN83 -> 1 cotx996 comparetotal -Inf sNaN92 -> -1 cotx997 comparetotal 088 sNaN81 -> -1 cotx998 comparetotal Inf sNaN90 -> -1 cotx999 comparetotal NaN -sNaN89 -> 1 -- overflow and underflow tests .. subnormal results now allowed maxExponent: 999999999 minexponent: -999999999 cotx1080 comparetotal +1.23456789012345E-0 9E+999999999 -> -1 cotx1081 comparetotal 9E+999999999 +1.23456789012345E-0 -> 1 cotx1082 comparetotal +0.100 9E-999999999 -> 1 cotx1083 comparetotal 9E-999999999 +0.100 -> -1 cotx1085 comparetotal -1.23456789012345E-0 9E+999999999 -> -1 cotx1086 comparetotal 9E+999999999 -1.23456789012345E-0 -> 1 cotx1087 comparetotal -0.100 9E-999999999 -> -1 cotx1088 comparetotal 9E-999999999 -0.100 -> 1 cotx1089 comparetotal 1e-599999999 1e-400000001 -> -1 cotx1090 comparetotal 1e-599999999 1e-400000000 -> -1 cotx1091 comparetotal 1e-600000000 1e-400000000 -> -1 cotx1092 comparetotal 9e-999999998 0.01 -> -1 cotx1093 comparetotal 9e-999999998 0.1 -> -1 cotx1094 comparetotal 0.01 9e-999999998 -> 1 cotx1095 comparetotal 1e599999999 1e400000001 -> 1 cotx1096 comparetotal 1e599999999 1e400000000 -> 1 cotx1097 comparetotal 1e600000000 1e400000000 -> 1 cotx1098 comparetotal 9e999999998 100 -> 1 cotx1099 comparetotal 9e999999998 10 -> 1 cotx1100 comparetotal 100 9e999999998 -> -1 -- signs cotx1101 comparetotal 1e+777777777 1e+411111111 -> 1 cotx1102 comparetotal 1e+777777777 -1e+411111111 -> 1 cotx1103 comparetotal -1e+777777777 1e+411111111 -> -1 cotx1104 comparetotal -1e+777777777 -1e+411111111 -> -1 cotx1105 comparetotal 1e-777777777 1e-411111111 -> -1 cotx1106 comparetotal 1e-777777777 -1e-411111111 -> 1 cotx1107 comparetotal -1e-777777777 1e-411111111 -> -1 cotx1108 comparetotal -1e-777777777 -1e-411111111 -> 1 -- spread zeros cotx1110 comparetotal 0E-383 0 -> -1 cotx1111 comparetotal 0E-383 -0 -> 1 cotx1112 comparetotal -0E-383 0 -> -1 cotx1113 comparetotal -0E-383 -0 -> 1 cotx1114 comparetotal 0E-383 0E+384 -> -1 cotx1115 comparetotal 0E-383 -0E+384 -> 1 cotx1116 comparetotal -0E-383 0E+384 -> -1 cotx1117 comparetotal -0E-383 -0E+384 -> 1 cotx1118 comparetotal 0 0E+384 -> -1 cotx1119 comparetotal 0 -0E+384 -> 1 cotx1120 comparetotal -0 0E+384 -> -1 cotx1121 comparetotal -0 -0E+384 -> 1 cotx1130 comparetotal 0E+384 0 -> 1 cotx1131 comparetotal 0E+384 -0 -> 1 cotx1132 comparetotal -0E+384 0 -> -1 cotx1133 comparetotal -0E+384 -0 -> -1 cotx1134 comparetotal 0E+384 0E-383 -> 1 cotx1135 comparetotal 0E+384 -0E-383 -> 1 cotx1136 comparetotal -0E+384 0E-383 -> -1 cotx1137 comparetotal -0E+384 -0E-383 -> -1 cotx1138 comparetotal 0 0E-383 -> 1 cotx1139 comparetotal 0 -0E-383 -> 1 cotx1140 comparetotal -0 0E-383 -> -1 cotx1141 comparetotal -0 -0E-383 -> -1 -- Null tests cotx9990 comparetotal 10 # -> NaN Invalid_operation cotx9991 comparetotal # 10 -> NaN Invalid_operation apd-3.2.1/testdata/cuberoot-apd.decTest000066400000000000000000000063471450022325000177760ustar00rootroot00000000000000-- cuberoot-apd.decTest -- decimal cube root -- These tests are not part of the GDA test suite, but were written for -- apd. They are not as exhaustive as those tests, but do cover a number of -- useful results. extended: 0 precision: 9 rounding: half_up maxExponent: 999 minExponent: -999 -- basics cbtx001 cuberoot 1 -> 1 cbtx002 cuberoot -1 -> -1 cbtx003 cuberoot 1.00 -> 1.0 cbtx004 cuberoot -1.00 -> -1.0 cbtx005 cuberoot 0 -> 0 cbtx006 cuberoot 00.0 -> 0 cbtx007 cuberoot 0.00 -> 0 cbtx008 cuberoot 00.00 -> 0 cbtx009 cuberoot 00 -> 0 cbtx010 cuberoot -2 -> -1.25992105 Inexact Rounded cbtx011 cuberoot 2 -> 1.25992105 Inexact Rounded cbtx012 cuberoot -2.00 -> -1.25992105 Inexact Rounded cbtx013 cuberoot 2.00 -> 1.25992105 Inexact Rounded cbtx014 cuberoot -0 -> -0 cbtx015 cuberoot -0.00 -> -0.0 cbtx016 cuberoot -00.0 -> -0.0 cbtx017 cuberoot -0E+9 -> -0E+3 cbtx018 cuberoot -0E+10 -> -0E+3 cbtx019 cuberoot -0E+11 -> -0E+3 cbtx020 cuberoot -0E+12 -> -0E+4 cbtx021 cuberoot -00 -> -0 cbtx022 cuberoot 0E+5 -> 0 cbtx023 cuberoot 8.0 -> 2.0 cbtx024 cuberoot 8.00 -> 2.0 cbtx030 cuberoot +0.1 -> 0.464158883 Inexact Rounded cbtx031 cuberoot -0.1 -> -0.464158883 Inexact Rounded cbtx032 cuberoot +0.01 -> 0.215443469 Inexact Rounded cbtx033 cuberoot -0.01 -> -0.215443469 Inexact Rounded cbtx034 cuberoot +0.001 -> 0.1 cbtx035 cuberoot -0.001 -> -0.1 cbtx036 cuberoot +0.000001 -> 0.01 cbtx037 cuberoot -0.000001 -> -0.01 cbtx038 cuberoot +0.000000000001 -> 0.0001 cbtx039 cuberoot -0.000000000001 -> -0.0001 cbtx041 cuberoot 1.1 -> 1.03228012 Inexact Rounded cbtx042 cuberoot 1.10 -> 1.03228012 Inexact Rounded cbtx043 cuberoot 1.100 -> 1.03228012 Inexact Rounded cbtx044 cuberoot 1.110 -> 1.03539881 Inexact Rounded cbtx045 cuberoot -1.1 -> -1.03228012 Inexact Rounded cbtx046 cuberoot -1.10 -> -1.03228012 Inexact Rounded cbtx047 cuberoot -1.100 -> -1.03228012 Inexact Rounded cbtx048 cuberoot -1.110 -> -1.03539881 Inexact Rounded cbtx049 cuberoot 9.9 -> 2.14722917 Inexact Rounded cbtx050 cuberoot 9.90 -> 2.14722917 Inexact Rounded cbtx051 cuberoot 9.900 -> 2.14722917 Inexact Rounded cbtx052 cuberoot 9.990 -> 2.15371631 Inexact Rounded cbtx053 cuberoot -9.9 -> -2.14722917 Inexact Rounded cbtx054 cuberoot -9.90 -> -2.14722917 Inexact Rounded cbtx055 cuberoot -9.900 -> -2.14722917 Inexact Rounded cbtx056 cuberoot -9.990 -> -2.15371631 Inexact Rounded cbtx060 cuberoot 10.0 -> 2.15443469 Inexact Rounded cbtx061 cuberoot 10.00 -> 2.15443469 Inexact Rounded cbtx062 cuberoot 1000.0 -> 10.0 cbtx063 cuberoot 1000.00 -> 10.0 cbtx064 cuberoot 1.1000E+3 -> 10.3228012 Inexact Rounded cbtx065 cuberoot 1.10000E+3 -> 10.3228012 Inexact Rounded cbtx066 cuberoot -10.0 -> -2.15443469 Inexact Rounded cbtx067 cuberoot -10.00 -> -2.15443469 Inexact Rounded cbtx068 cuberoot -1000.0 -> -10.0 cbtx069 cuberoot -1000.00 -> -10.0 cbtx070 cuberoot -1.1000E+3 -> -10.3228012 Inexact Rounded cbtx071 cuberoot -1.10000E+3 -> -10.3228012 Inexact Rounded -- famous cubes cbtx080 cuberoot 1 -> 1 cbtx081 cuberoot 8 -> 2 cbtx082 cuberoot 27 -> 3 cbtx083 cuberoot 64 -> 4 cbtx084 cuberoot 125 -> 5 cbtx085 cuberoot 216 -> 6 cbtx086 cuberoot 343 -> 7 cbtx087 cuberoot 512 -> 8 cbtx088 cuberoot 729 -> 9 cbtx089 cuberoot 1000 -> 10 -- others precision: 5 cbtx100 cuberoot 1.0001 -> 1.0000 Inexact Rounded apd-3.2.1/testdata/divide.decTest000066400000000000000000001132701450022325000166500ustar00rootroot00000000000000------------------------------------------------------------------------ -- divide.decTest -- decimal division -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 -- sanity checks divx001 divide 1 1 -> 1 divx002 divide 2 1 -> 2 divx003 divide 1 2 -> 0.5 divx004 divide 2 2 -> 1 divx005 divide 0 1 -> 0 divx006 divide 0 2 -> 0 divx007 divide 1 3 -> 0.333333333 Inexact Rounded divx008 divide 2 3 -> 0.666666667 Inexact Rounded divx009 divide 3 3 -> 1 divx010 divide 2.4 1 -> 2.4 divx011 divide 2.4 -1 -> -2.4 divx012 divide -2.4 1 -> -2.4 divx013 divide -2.4 -1 -> 2.4 divx014 divide 2.40 1 -> 2.40 divx015 divide 2.400 1 -> 2.400 divx016 divide 2.4 2 -> 1.2 divx017 divide 2.400 2 -> 1.200 divx018 divide 2. 2 -> 1 divx019 divide 20 20 -> 1 divx020 divide 187 187 -> 1 divx021 divide 5 2 -> 2.5 divx022 divide 50 20 -> 2.5 divx023 divide 500 200 -> 2.5 divx024 divide 50.0 20.0 -> 2.5 divx025 divide 5.00 2.00 -> 2.5 divx026 divide 5 2.0 -> 2.5 divx027 divide 5 2.000 -> 2.5 divx028 divide 5 0.20 -> 25 divx029 divide 5 0.200 -> 25 divx030 divide 10 1 -> 10 divx031 divide 100 1 -> 100 divx032 divide 1000 1 -> 1000 divx033 divide 1000 100 -> 10 divx035 divide 1 2 -> 0.5 divx036 divide 1 4 -> 0.25 divx037 divide 1 8 -> 0.125 divx038 divide 1 16 -> 0.0625 divx039 divide 1 32 -> 0.03125 divx040 divide 1 64 -> 0.015625 divx041 divide 1 -2 -> -0.5 divx042 divide 1 -4 -> -0.25 divx043 divide 1 -8 -> -0.125 divx044 divide 1 -16 -> -0.0625 divx045 divide 1 -32 -> -0.03125 divx046 divide 1 -64 -> -0.015625 divx047 divide -1 2 -> -0.5 divx048 divide -1 4 -> -0.25 divx049 divide -1 8 -> -0.125 divx050 divide -1 16 -> -0.0625 divx051 divide -1 32 -> -0.03125 divx052 divide -1 64 -> -0.015625 divx053 divide -1 -2 -> 0.5 divx054 divide -1 -4 -> 0.25 divx055 divide -1 -8 -> 0.125 divx056 divide -1 -16 -> 0.0625 divx057 divide -1 -32 -> 0.03125 divx058 divide -1 -64 -> 0.015625 divx070 divide 999999999 1 -> 999999999 divx071 divide 999999999.4 1 -> 999999999 Inexact Rounded divx072 divide 999999999.5 1 -> 1.00000000E+9 Inexact Rounded divx073 divide 999999999.9 1 -> 1.00000000E+9 Inexact Rounded divx074 divide 999999999.999 1 -> 1.00000000E+9 Inexact Rounded precision: 6 divx080 divide 999999999 1 -> 1.00000E+9 Inexact Rounded divx081 divide 99999999 1 -> 1.00000E+8 Inexact Rounded divx082 divide 9999999 1 -> 1.00000E+7 Inexact Rounded divx083 divide 999999 1 -> 999999 divx084 divide 99999 1 -> 99999 divx085 divide 9999 1 -> 9999 divx086 divide 999 1 -> 999 divx087 divide 99 1 -> 99 divx088 divide 9 1 -> 9 precision: 9 divx090 divide 0. 1 -> 0 divx091 divide .0 1 -> 0.0 divx092 divide 0.00 1 -> 0.00 divx093 divide 0.00E+9 1 -> 0E+7 divx094 divide 0.0000E-50 1 -> 0E-54 divx095 divide 1 1E-8 -> 1E+8 divx096 divide 1 1E-9 -> 1E+9 divx097 divide 1 1E-10 -> 1E+10 divx098 divide 1 1E-11 -> 1E+11 divx099 divide 1 1E-12 -> 1E+12 divx100 divide 1 1 -> 1 divx101 divide 1 2 -> 0.5 divx102 divide 1 3 -> 0.333333333 Inexact Rounded divx103 divide 1 4 -> 0.25 divx104 divide 1 5 -> 0.2 divx105 divide 1 6 -> 0.166666667 Inexact Rounded divx106 divide 1 7 -> 0.142857143 Inexact Rounded divx107 divide 1 8 -> 0.125 divx108 divide 1 9 -> 0.111111111 Inexact Rounded divx109 divide 1 10 -> 0.1 divx110 divide 1 1 -> 1 divx111 divide 2 1 -> 2 divx112 divide 3 1 -> 3 divx113 divide 4 1 -> 4 divx114 divide 5 1 -> 5 divx115 divide 6 1 -> 6 divx116 divide 7 1 -> 7 divx117 divide 8 1 -> 8 divx118 divide 9 1 -> 9 divx119 divide 10 1 -> 10 divx120 divide 3E+1 0.001 -> 3E+4 divx121 divide 2.200 2 -> 1.100 divx130 divide 12345 4.999 -> 2469.49390 Inexact Rounded divx131 divide 12345 4.99 -> 2473.94790 Inexact Rounded divx132 divide 12345 4.9 -> 2519.38776 Inexact Rounded divx133 divide 12345 5 -> 2469 divx134 divide 12345 5.1 -> 2420.58824 Inexact Rounded divx135 divide 12345 5.01 -> 2464.07186 Inexact Rounded divx136 divide 12345 5.001 -> 2468.50630 Inexact Rounded precision: 9 maxexponent: 999999999 minexponent: -999999999 -- test possibly imprecise results divx220 divide 391 597 -> 0.654941374 Inexact Rounded divx221 divide 391 -597 -> -0.654941374 Inexact Rounded divx222 divide -391 597 -> -0.654941374 Inexact Rounded divx223 divide -391 -597 -> 0.654941374 Inexact Rounded -- test some cases that are close to exponent overflow maxexponent: 999999999 minexponent: -999999999 divx270 divide 1 1e999999999 -> 1E-999999999 divx271 divide 1 0.9e999999999 -> 1.11111111E-999999999 Inexact Rounded divx272 divide 1 0.99e999999999 -> 1.01010101E-999999999 Inexact Rounded divx273 divide 1 0.999999999e999999999 -> 1.00000000E-999999999 Inexact Rounded divx274 divide 9e999999999 1 -> 9E+999999999 divx275 divide 9.9e999999999 1 -> 9.9E+999999999 divx276 divide 9.99e999999999 1 -> 9.99E+999999999 divx277 divide 9.99999999e999999999 1 -> 9.99999999E+999999999 divx280 divide 0.1 9e-999999999 -> 1.11111111E+999999997 Inexact Rounded divx281 divide 0.1 99e-999999999 -> 1.01010101E+999999996 Inexact Rounded divx282 divide 0.1 999e-999999999 -> 1.00100100E+999999995 Inexact Rounded divx283 divide 0.1 9e-999999998 -> 1.11111111E+999999996 Inexact Rounded divx284 divide 0.1 99e-999999998 -> 1.01010101E+999999995 Inexact Rounded divx285 divide 0.1 999e-999999998 -> 1.00100100E+999999994 Inexact Rounded divx286 divide 0.1 999e-999999997 -> 1.00100100E+999999993 Inexact Rounded divx287 divide 0.1 9999e-999999997 -> 1.00010001E+999999992 Inexact Rounded divx288 divide 0.1 99999e-999999997 -> 1.00001000E+999999991 Inexact Rounded -- Divide into 0 tests divx301 divide 0 7 -> 0 divx302 divide 0 7E-5 -> 0E+5 divx303 divide 0 7E-1 -> 0E+1 divx304 divide 0 7E+1 -> 0.0 divx305 divide 0 7E+5 -> 0.00000 divx306 divide 0 7E+6 -> 0.000000 divx307 divide 0 7E+7 -> 0E-7 divx308 divide 0 70E-5 -> 0E+5 divx309 divide 0 70E-1 -> 0E+1 divx310 divide 0 70E+0 -> 0 divx311 divide 0 70E+1 -> 0.0 divx312 divide 0 70E+5 -> 0.00000 divx313 divide 0 70E+6 -> 0.000000 divx314 divide 0 70E+7 -> 0E-7 divx315 divide 0 700E-5 -> 0E+5 divx316 divide 0 700E-1 -> 0E+1 divx317 divide 0 700E+0 -> 0 divx318 divide 0 700E+1 -> 0.0 divx319 divide 0 700E+5 -> 0.00000 divx320 divide 0 700E+6 -> 0.000000 divx321 divide 0 700E+7 -> 0E-7 divx322 divide 0 700E+77 -> 0E-77 divx331 divide 0E-3 7E-5 -> 0E+2 divx332 divide 0E-3 7E-1 -> 0.00 divx333 divide 0E-3 7E+1 -> 0.0000 divx334 divide 0E-3 7E+5 -> 0E-8 divx335 divide 0E-1 7E-5 -> 0E+4 divx336 divide 0E-1 7E-1 -> 0 divx337 divide 0E-1 7E+1 -> 0.00 divx338 divide 0E-1 7E+5 -> 0.000000 divx339 divide 0E+1 7E-5 -> 0E+6 divx340 divide 0E+1 7E-1 -> 0E+2 divx341 divide 0E+1 7E+1 -> 0 divx342 divide 0E+1 7E+5 -> 0.0000 divx343 divide 0E+3 7E-5 -> 0E+8 divx344 divide 0E+3 7E-1 -> 0E+4 divx345 divide 0E+3 7E+1 -> 0E+2 divx346 divide 0E+3 7E+5 -> 0.00 maxexponent: 92 minexponent: -92 precision: 7 divx351 divide 0E-92 7E-1 -> 0E-91 divx352 divide 0E-92 7E+1 -> 0E-93 divx353 divide 0E-92 7E+5 -> 0E-97 divx354 divide 0E-92 7E+6 -> 0E-98 divx355 divide 0E-92 7E+7 -> 0E-98 Clamped divx356 divide 0E-92 777E-1 -> 0E-91 divx357 divide 0E-92 777E+1 -> 0E-93 divx358 divide 0E-92 777E+3 -> 0E-95 divx359 divide 0E-92 777E+4 -> 0E-96 divx360 divide 0E-92 777E+5 -> 0E-97 divx361 divide 0E-92 777E+6 -> 0E-98 divx362 divide 0E-92 777E+7 -> 0E-98 Clamped divx363 divide 0E-92 7E+92 -> 0E-98 Clamped divx371 divide 0E-92 700E-1 -> 0E-91 divx372 divide 0E-92 700E+1 -> 0E-93 divx373 divide 0E-92 700E+3 -> 0E-95 divx374 divide 0E-92 700E+4 -> 0E-96 divx375 divide 0E-92 700E+5 -> 0E-97 divx376 divide 0E-92 700E+6 -> 0E-98 divx377 divide 0E-92 700E+7 -> 0E-98 Clamped divx381 divide 0E+92 7E+1 -> 0E+91 divx382 divide 0E+92 7E+0 -> 0E+92 divx383 divide 0E+92 7E-1 -> 0E+92 Clamped divx384 divide 0E+90 777E+1 -> 0E+89 divx385 divide 0E+90 777E-1 -> 0E+91 divx386 divide 0E+90 777E-2 -> 0E+92 divx387 divide 0E+90 777E-3 -> 0E+92 Clamped divx388 divide 0E+90 777E-4 -> 0E+92 Clamped divx391 divide 0E+90 700E+1 -> 0E+89 divx392 divide 0E+90 700E-1 -> 0E+91 divx393 divide 0E+90 700E-2 -> 0E+92 divx394 divide 0E+90 700E-3 -> 0E+92 Clamped divx395 divide 0E+90 700E-4 -> 0E+92 Clamped -- input rounding checks maxexponent: 999 minexponent: -999 precision: 9 divx401 divide 12345678000 1 -> 1.23456780E+10 Rounded divx402 divide 1 12345678000 -> 8.10000066E-11 Inexact Rounded divx403 divide 1234567800 1 -> 1.23456780E+9 Rounded divx404 divide 1 1234567800 -> 8.10000066E-10 Inexact Rounded divx405 divide 1234567890 1 -> 1.23456789E+9 Rounded divx406 divide 1 1234567890 -> 8.10000007E-10 Inexact Rounded divx407 divide 1234567891 1 -> 1.23456789E+9 Inexact Rounded divx408 divide 1 1234567891 -> 8.10000007E-10 Inexact Rounded divx409 divide 12345678901 1 -> 1.23456789E+10 Inexact Rounded divx410 divide 1 12345678901 -> 8.10000007E-11 Inexact Rounded divx411 divide 1234567896 1 -> 1.23456790E+9 Inexact Rounded divx412 divide 1 1234567896 -> 8.10000003E-10 Inexact Rounded divx413 divide 1 1234567897 -> 8.10000003E-10 Inexact Rounded divx414 divide 1 1234567898 -> 8.10000002E-10 Inexact Rounded divx415 divide 1 1234567899 -> 8.10000001E-10 Inexact Rounded divx416 divide 1 1234567900 -> 8.10000001E-10 Inexact Rounded divx417 divide 1 1234567901 -> 8.10000000E-10 Inexact Rounded divx418 divide 1 1234567902 -> 8.09999999E-10 Inexact Rounded -- some longies divx421 divide 1234567896.000000000000 1 -> 1.23456790E+9 Inexact Rounded divx422 divide 1 1234567896.000000000000 -> 8.10000003E-10 Inexact Rounded divx423 divide 1234567896.000000000001 1 -> 1.23456790E+9 Inexact Rounded divx424 divide 1 1234567896.000000000001 -> 8.10000003E-10 Inexact Rounded divx425 divide 1234567896.000000000000000000000000000000000000000009 1 -> 1.23456790E+9 Inexact Rounded divx426 divide 1 1234567896.000000000000000000000000000000000000000009 -> 8.10000003E-10 Inexact Rounded divx427 divide 1234567897.900010000000000000000000000000000000000009 1 -> 1.23456790E+9 Inexact Rounded divx428 divide 1 1234567897.900010000000000000000000000000000000000009 -> 8.10000002E-10 Inexact Rounded precision: 15 -- still checking... divx441 divide 12345678000 1 -> 12345678000 divx442 divide 1 12345678000 -> 8.10000066420005E-11 Inexact Rounded divx443 divide 1234567800 1 -> 1234567800 divx444 divide 1 1234567800 -> 8.10000066420005E-10 Inexact Rounded divx445 divide 1234567890 1 -> 1234567890 divx446 divide 1 1234567890 -> 8.10000007371000E-10 Inexact Rounded divx447 divide 1234567891 1 -> 1234567891 divx448 divide 1 1234567891 -> 8.10000006714900E-10 Inexact Rounded divx449 divide 12345678901 1 -> 12345678901 divx450 divide 1 12345678901 -> 8.10000007305390E-11 Inexact Rounded divx451 divide 1234567896 1 -> 1234567896 divx452 divide 1 1234567896 -> 8.10000003434400E-10 Inexact Rounded -- high-lows divx453 divide 1e+1 1 -> 1E+1 divx454 divide 1e+1 1.0 -> 1E+1 divx455 divide 1e+1 1.00 -> 1E+1 divx456 divide 1e+2 2 -> 5E+1 divx457 divide 1e+2 2.0 -> 5E+1 divx458 divide 1e+2 2.00 -> 5E+1 -- some from IEEE discussions divx460 divide 3e0 2e0 -> 1.5 divx461 divide 30e-1 2e0 -> 1.5 divx462 divide 300e-2 2e0 -> 1.50 divx464 divide 3000e-3 2e0 -> 1.500 divx465 divide 3e0 20e-1 -> 1.5 divx466 divide 30e-1 20e-1 -> 1.5 divx467 divide 300e-2 20e-1 -> 1.5 divx468 divide 3000e-3 20e-1 -> 1.50 divx469 divide 3e0 200e-2 -> 1.5 divx470 divide 30e-1 200e-2 -> 1.5 divx471 divide 300e-2 200e-2 -> 1.5 divx472 divide 3000e-3 200e-2 -> 1.5 divx473 divide 3e0 2000e-3 -> 1.5 divx474 divide 30e-1 2000e-3 -> 1.5 divx475 divide 300e-2 2000e-3 -> 1.5 divx476 divide 3000e-3 2000e-3 -> 1.5 -- some reciprocals divx480 divide 1 1.0E+33 -> 1E-33 divx481 divide 1 10E+33 -> 1E-34 divx482 divide 1 1.0E-33 -> 1E+33 divx483 divide 1 10E-33 -> 1E+32 -- RMS discussion table maxexponent: 96 minexponent: -95 precision: 7 divx484 divide 0e5 1e3 -> 0E+2 divx485 divide 0e5 2e3 -> 0E+2 divx486 divide 0e5 10e2 -> 0E+3 divx487 divide 0e5 20e2 -> 0E+3 divx488 divide 0e5 100e1 -> 0E+4 divx489 divide 0e5 200e1 -> 0E+4 divx491 divide 1e5 1e3 -> 1E+2 divx492 divide 1e5 2e3 -> 5E+1 divx493 divide 1e5 10e2 -> 1E+2 divx494 divide 1e5 20e2 -> 5E+1 divx495 divide 1e5 100e1 -> 1E+2 divx496 divide 1e5 200e1 -> 5E+1 -- tryzeros cases precision: 7 rounding: half_up maxExponent: 92 minexponent: -92 divx497 divide 0E+86 1000E-13 -> 0E+92 Clamped divx498 divide 0E-98 1000E+13 -> 0E-98 Clamped precision: 9 rounding: half_up maxExponent: 999 minexponent: -999 -- focus on trailing zeros issues precision: 9 divx500 divide 1 9.9 -> 0.101010101 Inexact Rounded precision: 8 divx501 divide 1 9.9 -> 0.10101010 Inexact Rounded precision: 7 divx502 divide 1 9.9 -> 0.1010101 Inexact Rounded precision: 6 divx503 divide 1 9.9 -> 0.101010 Inexact Rounded precision: 9 divx511 divide 1 2 -> 0.5 divx512 divide 1.0 2 -> 0.5 divx513 divide 1.00 2 -> 0.50 divx514 divide 1.000 2 -> 0.500 divx515 divide 1.0000 2 -> 0.5000 divx516 divide 1.00000 2 -> 0.50000 divx517 divide 1.000000 2 -> 0.500000 divx518 divide 1.0000000 2 -> 0.5000000 divx519 divide 1.00 2.00 -> 0.5 divx521 divide 2 1 -> 2 divx522 divide 2 1.0 -> 2 divx523 divide 2 1.00 -> 2 divx524 divide 2 1.000 -> 2 divx525 divide 2 1.0000 -> 2 divx526 divide 2 1.00000 -> 2 divx527 divide 2 1.000000 -> 2 divx528 divide 2 1.0000000 -> 2 divx529 divide 2.00 1.00 -> 2 divx530 divide 2.40 2 -> 1.20 divx531 divide 2.40 4 -> 0.60 divx532 divide 2.40 10 -> 0.24 divx533 divide 2.40 2.0 -> 1.2 divx534 divide 2.40 4.0 -> 0.6 divx535 divide 2.40 10.0 -> 0.24 divx536 divide 2.40 2.00 -> 1.2 divx537 divide 2.40 4.00 -> 0.6 divx538 divide 2.40 10.00 -> 0.24 divx539 divide 0.9 0.1 -> 9 divx540 divide 0.9 0.01 -> 9E+1 divx541 divide 0.9 0.001 -> 9E+2 divx542 divide 5 2 -> 2.5 divx543 divide 5 2.0 -> 2.5 divx544 divide 5 2.00 -> 2.5 divx545 divide 5 20 -> 0.25 divx546 divide 5 20.0 -> 0.25 divx547 divide 2.400 2 -> 1.200 divx548 divide 2.400 2.0 -> 1.20 divx549 divide 2.400 2.400 -> 1 divx550 divide 240 1 -> 240 divx551 divide 240 10 -> 24 divx552 divide 240 100 -> 2.4 divx553 divide 240 1000 -> 0.24 divx554 divide 2400 1 -> 2400 divx555 divide 2400 10 -> 240 divx556 divide 2400 100 -> 24 divx557 divide 2400 1000 -> 2.4 -- +ve exponent precision: 5 divx570 divide 2.4E+6 2 -> 1.2E+6 divx571 divide 2.40E+6 2 -> 1.20E+6 divx572 divide 2.400E+6 2 -> 1.200E+6 divx573 divide 2.4000E+6 2 -> 1.2000E+6 divx574 divide 24E+5 2 -> 1.2E+6 divx575 divide 240E+4 2 -> 1.20E+6 divx576 divide 2400E+3 2 -> 1.200E+6 divx577 divide 24000E+2 2 -> 1.2000E+6 precision: 6 divx580 divide 2.4E+6 2 -> 1.2E+6 divx581 divide 2.40E+6 2 -> 1.20E+6 divx582 divide 2.400E+6 2 -> 1.200E+6 divx583 divide 2.4000E+6 2 -> 1.2000E+6 divx584 divide 24E+5 2 -> 1.2E+6 divx585 divide 240E+4 2 -> 1.20E+6 divx586 divide 2400E+3 2 -> 1.200E+6 divx587 divide 24000E+2 2 -> 1.2000E+6 precision: 7 divx590 divide 2.4E+6 2 -> 1.2E+6 divx591 divide 2.40E+6 2 -> 1.20E+6 divx592 divide 2.400E+6 2 -> 1.200E+6 divx593 divide 2.4000E+6 2 -> 1.2000E+6 divx594 divide 24E+5 2 -> 1.2E+6 divx595 divide 240E+4 2 -> 1.20E+6 divx596 divide 2400E+3 2 -> 1.200E+6 divx597 divide 24000E+2 2 -> 1.2000E+6 precision: 9 divx600 divide 2.4E+9 2 -> 1.2E+9 divx601 divide 2.40E+9 2 -> 1.20E+9 divx602 divide 2.400E+9 2 -> 1.200E+9 divx603 divide 2.4000E+9 2 -> 1.2000E+9 divx604 divide 24E+8 2 -> 1.2E+9 divx605 divide 240E+7 2 -> 1.20E+9 divx606 divide 2400E+6 2 -> 1.200E+9 divx607 divide 24000E+5 2 -> 1.2000E+9 -- long operand triangle precision: 33 divx610 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131097703792 Inexact Rounded precision: 32 divx611 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813109770379 Inexact Rounded precision: 31 divx612 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81310977038 Inexact Rounded precision: 30 divx613 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131097704 Inexact Rounded precision: 29 divx614 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813109770 Inexact Rounded precision: 28 divx615 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81310977 Inexact Rounded precision: 27 divx616 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131098 Inexact Rounded precision: 26 divx617 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813110 Inexact Rounded precision: 25 divx618 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81311 Inexact Rounded precision: 24 divx619 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131 Inexact Rounded precision: 23 divx620 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813 Inexact Rounded precision: 22 divx621 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81 Inexact Rounded precision: 21 divx622 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8 Inexact Rounded precision: 20 divx623 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817798 Inexact Rounded precision: 19 divx624 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888379681780E+19 Inexact Rounded precision: 18 divx625 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088837968178E+19 Inexact Rounded precision: 17 divx626 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408883796818E+19 Inexact Rounded precision: 16 divx627 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888379682E+19 Inexact Rounded precision: 15 divx628 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088837968E+19 Inexact Rounded precision: 14 divx629 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408883797E+19 Inexact Rounded precision: 13 divx630 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888380E+19 Inexact Rounded precision: 12 divx631 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088838E+19 Inexact Rounded precision: 11 divx632 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408884E+19 Inexact Rounded precision: 10 divx633 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888E+19 Inexact Rounded precision: 9 divx634 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114089E+19 Inexact Rounded precision: 8 divx635 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011409E+19 Inexact Rounded precision: 7 divx636 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101141E+19 Inexact Rounded precision: 6 divx637 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114E+19 Inexact Rounded precision: 5 divx638 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011E+19 Inexact Rounded precision: 4 divx639 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101E+19 Inexact Rounded precision: 3 divx640 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10E+19 Inexact Rounded precision: 2 divx641 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1E+19 Inexact Rounded precision: 1 divx642 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4E+19 Inexact Rounded -- more zeros, etc. precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 divx731 divide 5.00 1E-3 -> 5.00E+3 divx732 divide 00.00 0.000 -> NaN Division_undefined divx733 divide 00.00 0E-3 -> NaN Division_undefined divx734 divide 0 -0 -> NaN Division_undefined divx735 divide -0 0 -> NaN Division_undefined divx736 divide -0 -0 -> NaN Division_undefined divx741 divide 0 -1 -> -0 divx742 divide -0 -1 -> 0 divx743 divide 0 1 -> 0 divx744 divide -0 1 -> -0 divx745 divide -1 0 -> -Infinity Division_by_zero divx746 divide -1 -0 -> Infinity Division_by_zero divx747 divide 1 0 -> Infinity Division_by_zero divx748 divide 1 -0 -> -Infinity Division_by_zero divx751 divide 0.0 -1 -> -0.0 divx752 divide -0.0 -1 -> 0.0 divx753 divide 0.0 1 -> 0.0 divx754 divide -0.0 1 -> -0.0 divx755 divide -1.0 0 -> -Infinity Division_by_zero divx756 divide -1.0 -0 -> Infinity Division_by_zero divx757 divide 1.0 0 -> Infinity Division_by_zero divx758 divide 1.0 -0 -> -Infinity Division_by_zero divx761 divide 0 -1.0 -> -0E+1 divx762 divide -0 -1.0 -> 0E+1 divx763 divide 0 1.0 -> 0E+1 divx764 divide -0 1.0 -> -0E+1 divx765 divide -1 0.0 -> -Infinity Division_by_zero divx766 divide -1 -0.0 -> Infinity Division_by_zero divx767 divide 1 0.0 -> Infinity Division_by_zero divx768 divide 1 -0.0 -> -Infinity Division_by_zero divx771 divide 0.0 -1.0 -> -0 divx772 divide -0.0 -1.0 -> 0 divx773 divide 0.0 1.0 -> 0 divx774 divide -0.0 1.0 -> -0 divx775 divide -1.0 0.0 -> -Infinity Division_by_zero divx776 divide -1.0 -0.0 -> Infinity Division_by_zero divx777 divide 1.0 0.0 -> Infinity Division_by_zero divx778 divide 1.0 -0.0 -> -Infinity Division_by_zero -- Specials divx780 divide Inf -Inf -> NaN Invalid_operation divx781 divide Inf -1000 -> -Infinity divx782 divide Inf -1 -> -Infinity divx783 divide Inf -0 -> -Infinity divx784 divide Inf 0 -> Infinity divx785 divide Inf 1 -> Infinity divx786 divide Inf 1000 -> Infinity divx787 divide Inf Inf -> NaN Invalid_operation divx788 divide -1000 Inf -> -0E-398 Clamped divx789 divide -Inf Inf -> NaN Invalid_operation divx790 divide -1 Inf -> -0E-398 Clamped divx791 divide -0 Inf -> -0E-398 Clamped divx792 divide 0 Inf -> 0E-398 Clamped divx793 divide 1 Inf -> 0E-398 Clamped divx794 divide 1000 Inf -> 0E-398 Clamped divx795 divide Inf Inf -> NaN Invalid_operation divx800 divide -Inf -Inf -> NaN Invalid_operation divx801 divide -Inf -1000 -> Infinity divx802 divide -Inf -1 -> Infinity divx803 divide -Inf -0 -> Infinity divx804 divide -Inf 0 -> -Infinity divx805 divide -Inf 1 -> -Infinity divx806 divide -Inf 1000 -> -Infinity divx807 divide -Inf Inf -> NaN Invalid_operation divx808 divide -1000 Inf -> -0E-398 Clamped divx809 divide -Inf -Inf -> NaN Invalid_operation divx810 divide -1 -Inf -> 0E-398 Clamped divx811 divide -0 -Inf -> 0E-398 Clamped divx812 divide 0 -Inf -> -0E-398 Clamped divx813 divide 1 -Inf -> -0E-398 Clamped divx814 divide 1000 -Inf -> -0E-398 Clamped divx815 divide Inf -Inf -> NaN Invalid_operation divx821 divide NaN -Inf -> NaN divx822 divide NaN -1000 -> NaN divx823 divide NaN -1 -> NaN divx824 divide NaN -0 -> NaN divx825 divide NaN 0 -> NaN divx826 divide NaN 1 -> NaN divx827 divide NaN 1000 -> NaN divx828 divide NaN Inf -> NaN divx829 divide NaN NaN -> NaN divx830 divide -Inf NaN -> NaN divx831 divide -1000 NaN -> NaN divx832 divide -1 NaN -> NaN divx833 divide -0 NaN -> NaN divx834 divide 0 NaN -> NaN divx835 divide 1 NaN -> NaN divx836 divide 1000 NaN -> NaN divx837 divide Inf NaN -> NaN divx841 divide sNaN -Inf -> NaN Invalid_operation divx842 divide sNaN -1000 -> NaN Invalid_operation divx843 divide sNaN -1 -> NaN Invalid_operation divx844 divide sNaN -0 -> NaN Invalid_operation divx845 divide sNaN 0 -> NaN Invalid_operation divx846 divide sNaN 1 -> NaN Invalid_operation divx847 divide sNaN 1000 -> NaN Invalid_operation divx848 divide sNaN NaN -> NaN Invalid_operation divx849 divide sNaN sNaN -> NaN Invalid_operation divx850 divide NaN sNaN -> NaN Invalid_operation divx851 divide -Inf sNaN -> NaN Invalid_operation divx852 divide -1000 sNaN -> NaN Invalid_operation divx853 divide -1 sNaN -> NaN Invalid_operation divx854 divide -0 sNaN -> NaN Invalid_operation divx855 divide 0 sNaN -> NaN Invalid_operation divx856 divide 1 sNaN -> NaN Invalid_operation divx857 divide 1000 sNaN -> NaN Invalid_operation divx858 divide Inf sNaN -> NaN Invalid_operation divx859 divide NaN sNaN -> NaN Invalid_operation -- propagating NaNs divx861 divide NaN9 -Inf -> NaN9 divx862 divide NaN8 1000 -> NaN8 divx863 divide NaN7 Inf -> NaN7 divx864 divide NaN6 NaN5 -> NaN6 divx865 divide -Inf NaN4 -> NaN4 divx866 divide -1000 NaN3 -> NaN3 divx867 divide Inf NaN2 -> NaN2 divx871 divide sNaN99 -Inf -> NaN99 Invalid_operation divx872 divide sNaN98 -1 -> NaN98 Invalid_operation divx873 divide sNaN97 NaN -> NaN97 Invalid_operation divx874 divide sNaN96 sNaN94 -> NaN96 Invalid_operation divx875 divide NaN95 sNaN93 -> NaN93 Invalid_operation divx876 divide -Inf sNaN92 -> NaN92 Invalid_operation divx877 divide 0 sNaN91 -> NaN91 Invalid_operation divx878 divide Inf sNaN90 -> NaN90 Invalid_operation divx879 divide NaN sNaN89 -> NaN89 Invalid_operation divx881 divide -NaN9 -Inf -> -NaN9 divx882 divide -NaN8 1000 -> -NaN8 divx883 divide -NaN7 Inf -> -NaN7 divx884 divide -NaN6 -NaN5 -> -NaN6 divx885 divide -Inf -NaN4 -> -NaN4 divx886 divide -1000 -NaN3 -> -NaN3 divx887 divide Inf -NaN2 -> -NaN2 divx891 divide -sNaN99 -Inf -> -NaN99 Invalid_operation divx892 divide -sNaN98 -1 -> -NaN98 Invalid_operation divx893 divide -sNaN97 NaN -> -NaN97 Invalid_operation divx894 divide -sNaN96 -sNaN94 -> -NaN96 Invalid_operation divx895 divide -NaN95 -sNaN93 -> -NaN93 Invalid_operation divx896 divide -Inf -sNaN92 -> -NaN92 Invalid_operation divx897 divide 0 -sNaN91 -> -NaN91 Invalid_operation divx898 divide Inf -sNaN90 -> -NaN90 Invalid_operation divx899 divide -NaN -sNaN89 -> -NaN89 Invalid_operation maxexponent: 999999999 minexponent: -999999999 -- Various flavours of divide by 0 divx901 divide 0 0 -> NaN Division_undefined divx902 divide 0.0E5 0 -> NaN Division_undefined divx903 divide 0.000 0 -> NaN Division_undefined divx904 divide 0.0001 0 -> Infinity Division_by_zero divx905 divide 0.01 0 -> Infinity Division_by_zero divx906 divide 0.1 0 -> Infinity Division_by_zero divx907 divide 1 0 -> Infinity Division_by_zero divx908 divide 1 0.0 -> Infinity Division_by_zero divx909 divide 10 0.0 -> Infinity Division_by_zero divx910 divide 1E+100 0.0 -> Infinity Division_by_zero divx911 divide 1E+1000 0 -> Infinity Division_by_zero divx921 divide -0.0001 0 -> -Infinity Division_by_zero divx922 divide -0.01 0 -> -Infinity Division_by_zero divx923 divide -0.1 0 -> -Infinity Division_by_zero divx924 divide -1 0 -> -Infinity Division_by_zero divx925 divide -1 0.0 -> -Infinity Division_by_zero divx926 divide -10 0.0 -> -Infinity Division_by_zero divx927 divide -1E+100 0.0 -> -Infinity Division_by_zero divx928 divide -1E+1000 0 -> -Infinity Division_by_zero divx931 divide 0.0001 -0 -> -Infinity Division_by_zero divx932 divide 0.01 -0 -> -Infinity Division_by_zero divx933 divide 0.1 -0 -> -Infinity Division_by_zero divx934 divide 1 -0 -> -Infinity Division_by_zero divx935 divide 1 -0.0 -> -Infinity Division_by_zero divx936 divide 10 -0.0 -> -Infinity Division_by_zero divx937 divide 1E+100 -0.0 -> -Infinity Division_by_zero divx938 divide 1E+1000 -0 -> -Infinity Division_by_zero divx941 divide -0.0001 -0 -> Infinity Division_by_zero divx942 divide -0.01 -0 -> Infinity Division_by_zero divx943 divide -0.1 -0 -> Infinity Division_by_zero divx944 divide -1 -0 -> Infinity Division_by_zero divx945 divide -1 -0.0 -> Infinity Division_by_zero divx946 divide -10 -0.0 -> Infinity Division_by_zero divx947 divide -1E+100 -0.0 -> Infinity Division_by_zero divx948 divide -1E+1000 -0 -> Infinity Division_by_zero -- overflow and underflow tests precision: 9 maxexponent: 999999999 minexponent: -999999999 divx951 divide 9E+999999999 +0.23456789012345E-0 -> Infinity Inexact Overflow Rounded divx952 divide +0.100 9E+999999999 -> 1.111111E-1000000001 Inexact Rounded Underflow Subnormal divx953 divide 9E-999999999 +9.100 -> 9.8901099E-1000000000 Inexact Rounded Underflow Subnormal divx954 divide -1.23456789 9E+999999999 -> -1.3717421E-1000000000 Subnormal divx955 divide -1.23456789012345E-0 9E+999999999 -> -1.3717421E-1000000000 Underflow Subnormal Rounded Inexact divx956 divide -1.23456789012345E-0 7E+999999999 -> -1.7636684E-1000000000 Inexact Rounded Underflow Subnormal divx957 divide 9E+999999999 -0.83456789012345E-0 -> -Infinity Inexact Overflow Rounded divx958 divide -0.100 9E+999999999 -> -1.111111E-1000000001 Subnormal Inexact Rounded Underflow divx959 divide 9E-999999999 -9.100 -> -9.8901099E-1000000000 Inexact Rounded Underflow Subnormal -- overflow and underflow (additional edge tests in multiply.decTest) -- 'subnormal' results now possible (all hard underflow or overflow in -- base arithemtic) divx960 divide 1e-600000000 1e+400000001 -> 1E-1000000001 Subnormal divx961 divide 1e-600000000 1e+400000002 -> 1E-1000000002 Subnormal divx962 divide 1e-600000000 1e+400000003 -> 1E-1000000003 Subnormal divx963 divide 1e-600000000 1e+400000004 -> 1E-1000000004 Subnormal divx964 divide 1e-600000000 1e+400000005 -> 1E-1000000005 Subnormal divx965 divide 1e-600000000 1e+400000006 -> 1E-1000000006 Subnormal divx966 divide 1e-600000000 1e+400000007 -> 1E-1000000007 Subnormal divx967 divide 1e-600000000 1e+400000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx968 divide 1e-600000000 1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx969 divide 1e-600000000 1e+400000010 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- [no equivalent of 'subnormal' for overflow] divx970 divide 1e+600000000 1e-400000001 -> Infinity Overflow Inexact Rounded divx971 divide 1e+600000000 1e-400000002 -> Infinity Overflow Inexact Rounded divx972 divide 1e+600000000 1e-400000003 -> Infinity Overflow Inexact Rounded divx973 divide 1e+600000000 1e-400000004 -> Infinity Overflow Inexact Rounded divx974 divide 1e+600000000 1e-400000005 -> Infinity Overflow Inexact Rounded divx975 divide 1e+600000000 1e-400000006 -> Infinity Overflow Inexact Rounded divx976 divide 1e+600000000 1e-400000007 -> Infinity Overflow Inexact Rounded divx977 divide 1e+600000000 1e-400000008 -> Infinity Overflow Inexact Rounded divx978 divide 1e+600000000 1e-400000009 -> Infinity Overflow Inexact Rounded divx979 divide 1e+600000000 1e-400000010 -> Infinity Overflow Inexact Rounded -- Sign after overflow and underflow divx980 divide 1e-600000000 1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx981 divide 1e-600000000 -1e+400000009 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx982 divide -1e-600000000 1e+400000009 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx983 divide -1e-600000000 -1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped divx984 divide 1e+600000000 1e-400000009 -> Infinity Overflow Inexact Rounded divx985 divide 1e+600000000 -1e-400000009 -> -Infinity Overflow Inexact Rounded divx986 divide -1e+600000000 1e-400000009 -> -Infinity Overflow Inexact Rounded divx987 divide -1e+600000000 -1e-400000009 -> Infinity Overflow Inexact Rounded -- Long operand overflow may be a different path precision: 3 divx990 divide 1000 9.999E-999999999 -> Infinity Inexact Overflow Rounded divx991 divide 1000 -9.999E-999999999 -> -Infinity Inexact Overflow Rounded divx992 divide 9.999E+999999999 0.01 -> Infinity Inexact Overflow Rounded divx993 divide -9.999E+999999999 0.01 -> -Infinity Inexact Overflow Rounded -- check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 divx1001 divide 1.52444E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow divx1002 divide 1.52445E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow divx1003 divide 1.52446E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow -- a rounding problem in one implementation precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 -- Unbounded answer to 40 digits: -- 1.465811965811965811965811965811965811966E+7000 divx1010 divide 343E6000 234E-1000 -> Infinity Overflow Inexact Rounded precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 -- Examples from SQL proposal (Krishna Kulkarni) precision: 7 divx1021 divide 1E0 1E0 -> 1 divx1022 divide 1E0 2E0 -> 0.5 divx1023 divide 1E0 3E0 -> 0.3333333 Inexact Rounded divx1024 divide 100E-2 1000E-3 -> 1 divx1025 divide 24E-1 2E0 -> 1.2 divx1026 divide 2400E-3 2E0 -> 1.200 divx1027 divide 5E0 2E0 -> 2.5 divx1028 divide 5E0 20E-1 -> 2.5 divx1029 divide 5E0 2000E-3 -> 2.5 divx1030 divide 5E0 2E-1 -> 25 divx1031 divide 5E0 20E-2 -> 25 divx1032 divide 480E-2 3E0 -> 1.60 divx1033 divide 47E-1 2E0 -> 2.35 -- ECMAScript bad examples rounding: half_down precision: 7 divx1050 divide 5 9 -> 0.5555556 Inexact Rounded rounding: half_even divx1051 divide 5 11 -> 0.4545455 Inexact Rounded -- payload decapitate precision: 5 divx1055 divide sNaN987654321 1 -> NaN54321 Invalid_operation -- Null tests divx9998 divide 10 # -> NaN Invalid_operation divx9999 divide # 10 -> NaN Invalid_operation apd-3.2.1/testdata/divideint.decTest000066400000000000000000000505601450022325000173650ustar00rootroot00000000000000------------------------------------------------------------------------ -- divideint.decTest -- decimal integer division -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 dvix001 divideint 1 1 -> 1 dvix002 divideint 2 1 -> 2 dvix003 divideint 1 2 -> 0 dvix004 divideint 2 2 -> 1 dvix005 divideint 0 1 -> 0 dvix006 divideint 0 2 -> 0 dvix007 divideint 1 3 -> 0 dvix008 divideint 2 3 -> 0 dvix009 divideint 3 3 -> 1 dvix010 divideint 2.4 1 -> 2 dvix011 divideint 2.4 -1 -> -2 dvix012 divideint -2.4 1 -> -2 dvix013 divideint -2.4 -1 -> 2 dvix014 divideint 2.40 1 -> 2 dvix015 divideint 2.400 1 -> 2 dvix016 divideint 2.4 2 -> 1 dvix017 divideint 2.400 2 -> 1 dvix018 divideint 2. 2 -> 1 dvix019 divideint 20 20 -> 1 dvix020 divideint 187 187 -> 1 dvix021 divideint 5 2 -> 2 dvix022 divideint 5 2.0 -> 2 dvix023 divideint 5 2.000 -> 2 dvix024 divideint 5 0.200 -> 25 dvix025 divideint 5 0.200 -> 25 dvix030 divideint 1 2 -> 0 dvix031 divideint 1 4 -> 0 dvix032 divideint 1 8 -> 0 dvix033 divideint 1 16 -> 0 dvix034 divideint 1 32 -> 0 dvix035 divideint 1 64 -> 0 dvix040 divideint 1 -2 -> -0 dvix041 divideint 1 -4 -> -0 dvix042 divideint 1 -8 -> -0 dvix043 divideint 1 -16 -> -0 dvix044 divideint 1 -32 -> -0 dvix045 divideint 1 -64 -> -0 dvix050 divideint -1 2 -> -0 dvix051 divideint -1 4 -> -0 dvix052 divideint -1 8 -> -0 dvix053 divideint -1 16 -> -0 dvix054 divideint -1 32 -> -0 dvix055 divideint -1 64 -> -0 dvix060 divideint -1 -2 -> 0 dvix061 divideint -1 -4 -> 0 dvix062 divideint -1 -8 -> 0 dvix063 divideint -1 -16 -> 0 dvix064 divideint -1 -32 -> 0 dvix065 divideint -1 -64 -> 0 -- similar with powers of ten dvix160 divideint 1 1 -> 1 dvix161 divideint 1 10 -> 0 dvix162 divideint 1 100 -> 0 dvix163 divideint 1 1000 -> 0 dvix164 divideint 1 10000 -> 0 dvix165 divideint 1 100000 -> 0 dvix166 divideint 1 1000000 -> 0 dvix167 divideint 1 10000000 -> 0 dvix168 divideint 1 100000000 -> 0 dvix170 divideint 1 -1 -> -1 dvix171 divideint 1 -10 -> -0 dvix172 divideint 1 -100 -> -0 dvix173 divideint 1 -1000 -> -0 dvix174 divideint 1 -10000 -> -0 dvix175 divideint 1 -100000 -> -0 dvix176 divideint 1 -1000000 -> -0 dvix177 divideint 1 -10000000 -> -0 dvix178 divideint 1 -100000000 -> -0 dvix180 divideint -1 1 -> -1 dvix181 divideint -1 10 -> -0 dvix182 divideint -1 100 -> -0 dvix183 divideint -1 1000 -> -0 dvix184 divideint -1 10000 -> -0 dvix185 divideint -1 100000 -> -0 dvix186 divideint -1 1000000 -> -0 dvix187 divideint -1 10000000 -> -0 dvix188 divideint -1 100000000 -> -0 dvix190 divideint -1 -1 -> 1 dvix191 divideint -1 -10 -> 0 dvix192 divideint -1 -100 -> 0 dvix193 divideint -1 -1000 -> 0 dvix194 divideint -1 -10000 -> 0 dvix195 divideint -1 -100000 -> 0 dvix196 divideint -1 -1000000 -> 0 dvix197 divideint -1 -10000000 -> 0 dvix198 divideint -1 -100000000 -> 0 -- some long operand cases here dvix070 divideint 999999999 1 -> 999999999 dvix071 divideint 999999999.4 1 -> 999999999 dvix072 divideint 999999999.5 1 -> 999999999 dvix073 divideint 999999999.9 1 -> 999999999 dvix074 divideint 999999999.999 1 -> 999999999 precision: 6 dvix080 divideint 999999999 1 -> NaN Division_impossible dvix081 divideint 99999999 1 -> NaN Division_impossible dvix082 divideint 9999999 1 -> NaN Division_impossible dvix083 divideint 999999 1 -> 999999 dvix084 divideint 99999 1 -> 99999 dvix085 divideint 9999 1 -> 9999 dvix086 divideint 999 1 -> 999 dvix087 divideint 99 1 -> 99 dvix088 divideint 9 1 -> 9 precision: 9 dvix090 divideint 0. 1 -> 0 dvix091 divideint .0 1 -> 0 dvix092 divideint 0.00 1 -> 0 dvix093 divideint 0.00E+9 1 -> 0 dvix094 divideint 0.0000E-50 1 -> 0 dvix100 divideint 1 1 -> 1 dvix101 divideint 1 2 -> 0 dvix102 divideint 1 3 -> 0 dvix103 divideint 1 4 -> 0 dvix104 divideint 1 5 -> 0 dvix105 divideint 1 6 -> 0 dvix106 divideint 1 7 -> 0 dvix107 divideint 1 8 -> 0 dvix108 divideint 1 9 -> 0 dvix109 divideint 1 10 -> 0 dvix110 divideint 1 1 -> 1 dvix111 divideint 2 1 -> 2 dvix112 divideint 3 1 -> 3 dvix113 divideint 4 1 -> 4 dvix114 divideint 5 1 -> 5 dvix115 divideint 6 1 -> 6 dvix116 divideint 7 1 -> 7 dvix117 divideint 8 1 -> 8 dvix118 divideint 9 1 -> 9 dvix119 divideint 10 1 -> 10 -- from DiagBigDecimal dvix131 divideint 101.3 1 -> 101 dvix132 divideint 101.0 1 -> 101 dvix133 divideint 101.3 3 -> 33 dvix134 divideint 101.0 3 -> 33 dvix135 divideint 2.4 1 -> 2 dvix136 divideint 2.400 1 -> 2 dvix137 divideint 18 18 -> 1 dvix138 divideint 1120 1000 -> 1 dvix139 divideint 2.4 2 -> 1 dvix140 divideint 2.400 2 -> 1 dvix141 divideint 0.5 2.000 -> 0 dvix142 divideint 8.005 7 -> 1 dvix143 divideint 5 2 -> 2 dvix144 divideint 0 2 -> 0 dvix145 divideint 0.00 2 -> 0 -- Others dvix150 divideint 12345 4.999 -> 2469 dvix151 divideint 12345 4.99 -> 2473 dvix152 divideint 12345 4.9 -> 2519 dvix153 divideint 12345 5 -> 2469 dvix154 divideint 12345 5.1 -> 2420 dvix155 divideint 12345 5.01 -> 2464 dvix156 divideint 12345 5.001 -> 2468 dvix157 divideint 101 7.6 -> 13 -- Various flavours of divideint by 0 maxexponent: 999999999 minexponent: -999999999 dvix201 divideint 0 0 -> NaN Division_undefined dvix202 divideint 0.0E5 0 -> NaN Division_undefined dvix203 divideint 0.000 0 -> NaN Division_undefined dvix204 divideint 0.0001 0 -> Infinity Division_by_zero dvix205 divideint 0.01 0 -> Infinity Division_by_zero dvix206 divideint 0.1 0 -> Infinity Division_by_zero dvix207 divideint 1 0 -> Infinity Division_by_zero dvix208 divideint 1 0.0 -> Infinity Division_by_zero dvix209 divideint 10 0.0 -> Infinity Division_by_zero dvix210 divideint 1E+100 0.0 -> Infinity Division_by_zero dvix211 divideint 1E+1000 0 -> Infinity Division_by_zero dvix214 divideint -0.0001 0 -> -Infinity Division_by_zero dvix215 divideint -0.01 0 -> -Infinity Division_by_zero dvix216 divideint -0.1 0 -> -Infinity Division_by_zero dvix217 divideint -1 0 -> -Infinity Division_by_zero dvix218 divideint -1 0.0 -> -Infinity Division_by_zero dvix219 divideint -10 0.0 -> -Infinity Division_by_zero dvix220 divideint -1E+100 0.0 -> -Infinity Division_by_zero dvix221 divideint -1E+1000 0 -> -Infinity Division_by_zero -- test some cases that are close to exponent overflow maxexponent: 999999999 minexponent: -999999999 dvix270 divideint 1 1e999999999 -> 0 dvix271 divideint 1 0.9e999999999 -> 0 dvix272 divideint 1 0.99e999999999 -> 0 dvix273 divideint 1 0.999999999e999999999 -> 0 dvix274 divideint 9e999999999 1 -> NaN Division_impossible dvix275 divideint 9.9e999999999 1 -> NaN Division_impossible dvix276 divideint 9.99e999999999 1 -> NaN Division_impossible dvix277 divideint 9.99999999e999999999 1 -> NaN Division_impossible dvix280 divideint 0.1 9e-999999999 -> NaN Division_impossible dvix281 divideint 0.1 99e-999999999 -> NaN Division_impossible dvix282 divideint 0.1 999e-999999999 -> NaN Division_impossible dvix283 divideint 0.1 9e-999999998 -> NaN Division_impossible dvix284 divideint 0.1 99e-999999998 -> NaN Division_impossible dvix285 divideint 0.1 999e-999999998 -> NaN Division_impossible dvix286 divideint 0.1 999e-999999997 -> NaN Division_impossible dvix287 divideint 0.1 9999e-999999997 -> NaN Division_impossible dvix288 divideint 0.1 99999e-999999997 -> NaN Division_impossible -- GD edge cases: lhs smaller than rhs but more digits dvix301 divideint 0.9 2 -> 0 dvix302 divideint 0.9 2.0 -> 0 dvix303 divideint 0.9 2.1 -> 0 dvix304 divideint 0.9 2.00 -> 0 dvix305 divideint 0.9 2.01 -> 0 dvix306 divideint 0.12 1 -> 0 dvix307 divideint 0.12 1.0 -> 0 dvix308 divideint 0.12 1.00 -> 0 dvix309 divideint 0.12 1.0 -> 0 dvix310 divideint 0.12 1.00 -> 0 dvix311 divideint 0.12 2 -> 0 dvix312 divideint 0.12 2.0 -> 0 dvix313 divideint 0.12 2.1 -> 0 dvix314 divideint 0.12 2.00 -> 0 dvix315 divideint 0.12 2.01 -> 0 -- overflow and underflow tests [from divide] maxexponent: 999999999 minexponent: -999999999 dvix330 divideint +1.23456789012345E-0 9E+999999999 -> 0 dvix331 divideint 9E+999999999 +0.23456789012345E-0 -> NaN Division_impossible dvix332 divideint +0.100 9E+999999999 -> 0 dvix333 divideint 9E-999999999 +9.100 -> 0 dvix335 divideint -1.23456789012345E-0 9E+999999999 -> -0 dvix336 divideint 9E+999999999 -0.83456789012345E-0 -> NaN Division_impossible dvix337 divideint -0.100 9E+999999999 -> -0 dvix338 divideint 9E-999999999 -9.100 -> -0 -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 dvix401 divideint 12345678000 100 -> 123456780 dvix402 divideint 1 12345678000 -> 0 dvix403 divideint 1234567800 10 -> 123456780 dvix404 divideint 1 1234567800 -> 0 dvix405 divideint 1234567890 10 -> 123456789 dvix406 divideint 1 1234567890 -> 0 dvix407 divideint 1234567891 10 -> 123456789 dvix408 divideint 1 1234567891 -> 0 dvix409 divideint 12345678901 100 -> 123456789 dvix410 divideint 1 12345678901 -> 0 dvix411 divideint 1234567896 10 -> 123456789 dvix412 divideint 1 1234567896 -> 0 dvix413 divideint 12345678948 100 -> 123456789 dvix414 divideint 12345678949 100 -> 123456789 dvix415 divideint 12345678950 100 -> 123456789 dvix416 divideint 12345678951 100 -> 123456789 dvix417 divideint 12345678999 100 -> 123456789 precision: 15 dvix441 divideint 12345678000 1 -> 12345678000 dvix442 divideint 1 12345678000 -> 0 dvix443 divideint 1234567800 1 -> 1234567800 dvix444 divideint 1 1234567800 -> 0 dvix445 divideint 1234567890 1 -> 1234567890 dvix446 divideint 1 1234567890 -> 0 dvix447 divideint 1234567891 1 -> 1234567891 dvix448 divideint 1 1234567891 -> 0 dvix449 divideint 12345678901 1 -> 12345678901 dvix450 divideint 1 12345678901 -> 0 dvix451 divideint 1234567896 1 -> 1234567896 dvix452 divideint 1 1234567896 -> 0 precision: 9 rounding: half_up maxExponent: 999 minexponent: -999 -- more zeros, etc. dvix531 divideint 5.00 1E-3 -> 5000 dvix532 divideint 00.00 0.000 -> NaN Division_undefined dvix533 divideint 00.00 0E-3 -> NaN Division_undefined dvix534 divideint 0 -0 -> NaN Division_undefined dvix535 divideint -0 0 -> NaN Division_undefined dvix536 divideint -0 -0 -> NaN Division_undefined dvix541 divideint 0 -1 -> -0 dvix542 divideint -0 -1 -> 0 dvix543 divideint 0 1 -> 0 dvix544 divideint -0 1 -> -0 dvix545 divideint -1 0 -> -Infinity Division_by_zero dvix546 divideint -1 -0 -> Infinity Division_by_zero dvix547 divideint 1 0 -> Infinity Division_by_zero dvix548 divideint 1 -0 -> -Infinity Division_by_zero dvix551 divideint 0.0 -1 -> -0 dvix552 divideint -0.0 -1 -> 0 dvix553 divideint 0.0 1 -> 0 dvix554 divideint -0.0 1 -> -0 dvix555 divideint -1.0 0 -> -Infinity Division_by_zero dvix556 divideint -1.0 -0 -> Infinity Division_by_zero dvix557 divideint 1.0 0 -> Infinity Division_by_zero dvix558 divideint 1.0 -0 -> -Infinity Division_by_zero dvix561 divideint 0 -1.0 -> -0 dvix562 divideint -0 -1.0 -> 0 dvix563 divideint 0 1.0 -> 0 dvix564 divideint -0 1.0 -> -0 dvix565 divideint -1 0.0 -> -Infinity Division_by_zero dvix566 divideint -1 -0.0 -> Infinity Division_by_zero dvix567 divideint 1 0.0 -> Infinity Division_by_zero dvix568 divideint 1 -0.0 -> -Infinity Division_by_zero dvix571 divideint 0.0 -1.0 -> -0 dvix572 divideint -0.0 -1.0 -> 0 dvix573 divideint 0.0 1.0 -> 0 dvix574 divideint -0.0 1.0 -> -0 dvix575 divideint -1.0 0.0 -> -Infinity Division_by_zero dvix576 divideint -1.0 -0.0 -> Infinity Division_by_zero dvix577 divideint 1.0 0.0 -> Infinity Division_by_zero dvix578 divideint 1.0 -0.0 -> -Infinity Division_by_zero -- Specials dvix580 divideint Inf -Inf -> NaN Invalid_operation dvix581 divideint Inf -1000 -> -Infinity dvix582 divideint Inf -1 -> -Infinity dvix583 divideint Inf -0 -> -Infinity dvix584 divideint Inf 0 -> Infinity dvix585 divideint Inf 1 -> Infinity dvix586 divideint Inf 1000 -> Infinity dvix587 divideint Inf Inf -> NaN Invalid_operation dvix588 divideint -1000 Inf -> -0 dvix589 divideint -Inf Inf -> NaN Invalid_operation dvix590 divideint -1 Inf -> -0 dvix591 divideint -0 Inf -> -0 dvix592 divideint 0 Inf -> 0 dvix593 divideint 1 Inf -> 0 dvix594 divideint 1000 Inf -> 0 dvix595 divideint Inf Inf -> NaN Invalid_operation dvix600 divideint -Inf -Inf -> NaN Invalid_operation dvix601 divideint -Inf -1000 -> Infinity dvix602 divideint -Inf -1 -> Infinity dvix603 divideint -Inf -0 -> Infinity dvix604 divideint -Inf 0 -> -Infinity dvix605 divideint -Inf 1 -> -Infinity dvix606 divideint -Inf 1000 -> -Infinity dvix607 divideint -Inf Inf -> NaN Invalid_operation dvix608 divideint -1000 Inf -> -0 dvix609 divideint -Inf -Inf -> NaN Invalid_operation dvix610 divideint -1 -Inf -> 0 dvix611 divideint -0 -Inf -> 0 dvix612 divideint 0 -Inf -> -0 dvix613 divideint 1 -Inf -> -0 dvix614 divideint 1000 -Inf -> -0 dvix615 divideint Inf -Inf -> NaN Invalid_operation dvix621 divideint NaN -Inf -> NaN dvix622 divideint NaN -1000 -> NaN dvix623 divideint NaN -1 -> NaN dvix624 divideint NaN -0 -> NaN dvix625 divideint NaN 0 -> NaN dvix626 divideint NaN 1 -> NaN dvix627 divideint NaN 1000 -> NaN dvix628 divideint NaN Inf -> NaN dvix629 divideint NaN NaN -> NaN dvix630 divideint -Inf NaN -> NaN dvix631 divideint -1000 NaN -> NaN dvix632 divideint -1 NaN -> NaN dvix633 divideint -0 NaN -> NaN dvix634 divideint 0 NaN -> NaN dvix635 divideint 1 NaN -> NaN dvix636 divideint 1000 NaN -> NaN dvix637 divideint Inf NaN -> NaN dvix641 divideint sNaN -Inf -> NaN Invalid_operation dvix642 divideint sNaN -1000 -> NaN Invalid_operation dvix643 divideint sNaN -1 -> NaN Invalid_operation dvix644 divideint sNaN -0 -> NaN Invalid_operation dvix645 divideint sNaN 0 -> NaN Invalid_operation dvix646 divideint sNaN 1 -> NaN Invalid_operation dvix647 divideint sNaN 1000 -> NaN Invalid_operation dvix648 divideint sNaN NaN -> NaN Invalid_operation dvix649 divideint sNaN sNaN -> NaN Invalid_operation dvix650 divideint NaN sNaN -> NaN Invalid_operation dvix651 divideint -Inf sNaN -> NaN Invalid_operation dvix652 divideint -1000 sNaN -> NaN Invalid_operation dvix653 divideint -1 sNaN -> NaN Invalid_operation dvix654 divideint -0 sNaN -> NaN Invalid_operation dvix655 divideint 0 sNaN -> NaN Invalid_operation dvix656 divideint 1 sNaN -> NaN Invalid_operation dvix657 divideint 1000 sNaN -> NaN Invalid_operation dvix658 divideint Inf sNaN -> NaN Invalid_operation dvix659 divideint NaN sNaN -> NaN Invalid_operation -- propagating NaNs dvix661 divideint NaN9 -Inf -> NaN9 dvix662 divideint NaN8 1000 -> NaN8 dvix663 divideint NaN7 Inf -> NaN7 dvix664 divideint -NaN6 NaN5 -> -NaN6 dvix665 divideint -Inf NaN4 -> NaN4 dvix666 divideint -1000 NaN3 -> NaN3 dvix667 divideint Inf -NaN2 -> -NaN2 dvix671 divideint -sNaN99 -Inf -> -NaN99 Invalid_operation dvix672 divideint sNaN98 -1 -> NaN98 Invalid_operation dvix673 divideint sNaN97 NaN -> NaN97 Invalid_operation dvix674 divideint sNaN96 sNaN94 -> NaN96 Invalid_operation dvix675 divideint NaN95 sNaN93 -> NaN93 Invalid_operation dvix676 divideint -Inf sNaN92 -> NaN92 Invalid_operation dvix677 divideint 0 sNaN91 -> NaN91 Invalid_operation dvix678 divideint Inf -sNaN90 -> -NaN90 Invalid_operation dvix679 divideint NaN sNaN89 -> NaN89 Invalid_operation -- some long operand cases again precision: 8 dvix710 divideint 100000001 1 -> NaN Division_impossible dvix711 divideint 100000000.4 1 -> NaN Division_impossible dvix712 divideint 100000000.5 1 -> NaN Division_impossible dvix713 divideint 100000000.9 1 -> NaN Division_impossible dvix714 divideint 100000000.999 1 -> NaN Division_impossible precision: 6 dvix720 divideint 100000000 1 -> NaN Division_impossible dvix721 divideint 10000000 1 -> NaN Division_impossible dvix722 divideint 1000000 1 -> NaN Division_impossible dvix723 divideint 100000 1 -> 100000 dvix724 divideint 10000 1 -> 10000 dvix725 divideint 1000 1 -> 1000 dvix726 divideint 100 1 -> 100 dvix727 divideint 10 1 -> 10 dvix728 divideint 1 1 -> 1 dvix729 divideint 1 10 -> 0 precision: 9 maxexponent: 999999999 minexponent: -999999999 dvix732 divideint 1 0.99e999999999 -> 0 dvix733 divideint 1 0.999999999e999999999 -> 0 dvix734 divideint 9e999999999 1 -> NaN Division_impossible dvix735 divideint 9.9e999999999 1 -> NaN Division_impossible dvix736 divideint 9.99e999999999 1 -> NaN Division_impossible dvix737 divideint 9.99999999e999999999 1 -> NaN Division_impossible dvix740 divideint 0.1 9e-999999999 -> NaN Division_impossible dvix741 divideint 0.1 99e-999999999 -> NaN Division_impossible dvix742 divideint 0.1 999e-999999999 -> NaN Division_impossible dvix743 divideint 0.1 9e-999999998 -> NaN Division_impossible dvix744 divideint 0.1 99e-999999998 -> NaN Division_impossible dvix745 divideint 0.1 999e-999999998 -> NaN Division_impossible dvix746 divideint 0.1 999e-999999997 -> NaN Division_impossible dvix747 divideint 0.1 9999e-999999997 -> NaN Division_impossible dvix748 divideint 0.1 99999e-999999997 -> NaN Division_impossible -- Null tests dvix900 divideint 10 # -> NaN Invalid_operation dvix901 divideint # 10 -> NaN Invalid_operation apd-3.2.1/testdata/exp.decTest000066400000000000000000001147061450022325000162050ustar00rootroot00000000000000------------------------------------------------------------------------ -- exp.decTest -- decimal natural exponentiation -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- Tests of the exponential funtion. Currently all testcases here -- show results which are correctly rounded (within <= 0.5 ulp). extended: 1 precision: 9 rounding: half_even maxExponent: 384 minexponent: -383 -- basics (examples in specificiation, etc.) expx001 exp -Infinity -> 0 expx002 exp -10 -> 0.0000453999298 Inexact Rounded expx003 exp -1 -> 0.367879441 Inexact Rounded expx004 exp 0 -> 1 expx005 exp -0 -> 1 expx006 exp 1 -> 2.71828183 Inexact Rounded expx007 exp 0.693147181 -> 2.00000000 Inexact Rounded expx008 exp 10 -> 22026.4658 Inexact Rounded expx009 exp +Infinity -> Infinity -- tiny edge cases precision: 7 expx011 exp 0.1 -> 1.105171 Inexact Rounded expx012 exp 0.01 -> 1.010050 Inexact Rounded expx013 exp 0.001 -> 1.001001 Inexact Rounded expx014 exp 0.0001 -> 1.000100 Inexact Rounded expx015 exp 0.00001 -> 1.000010 Inexact Rounded expx016 exp 0.000001 -> 1.000001 Inexact Rounded expx017 exp 0.0000001 -> 1.000000 Inexact Rounded expx018 exp 0.0000003 -> 1.000000 Inexact Rounded expx019 exp 0.0000004 -> 1.000000 Inexact Rounded expx020 exp 0.0000005 -> 1.000001 Inexact Rounded expx021 exp 0.0000008 -> 1.000001 Inexact Rounded expx022 exp 0.0000009 -> 1.000001 Inexact Rounded expx023 exp 0.0000010 -> 1.000001 Inexact Rounded expx024 exp 0.0000011 -> 1.000001 Inexact Rounded expx025 exp 0.00000009 -> 1.000000 Inexact Rounded expx026 exp 0.00000005 -> 1.000000 Inexact Rounded expx027 exp 0.00000004 -> 1.000000 Inexact Rounded expx028 exp 0.00000001 -> 1.000000 Inexact Rounded -- and some more zeros expx030 exp 0.00000000 -> 1 expx031 exp 0E+100 -> 1 expx032 exp 0E-100 -> 1 expx033 exp -0.00000000 -> 1 expx034 exp -0E+100 -> 1 expx035 exp -0E-100 -> 1 -- basic e=0, e=1, e=2, e=4, e>=8 cases precision: 7 expx041 exp 1 -> 2.718282 Inexact Rounded expx042 exp -1 -> 0.3678794 Inexact Rounded expx043 exp 10 -> 22026.47 Inexact Rounded expx044 exp -10 -> 0.00004539993 Inexact Rounded expx045 exp 100 -> 2.688117E+43 Inexact Rounded expx046 exp -100 -> 3.720076E-44 Inexact Rounded expx047 exp 1000 -> Infinity Overflow Inexact Rounded expx048 exp -1000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx049 exp 100000000 -> Infinity Overflow Inexact Rounded expx050 exp -100000000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal -- miscellanea -- similar to 'VF bug' test, at 17, but with last digit corrected for decimal precision: 16 expx055 exp -5.42410311287441459172E+2 -> 2.717658486884572E-236 Inexact Rounded -- result from NetRexx/Java prototype -> 2.7176584868845721117677929628617246054459644711108E-236 -- result from Rexx (series) version -> 2.717658486884572111767792962861724605446E-236 precision: 17 expx056 exp -5.42410311287441459172E+2 -> 2.7176584868845721E-236 Inexact Rounded precision: 18 expx057 exp -5.42410311287441459172E+2 -> 2.71765848688457211E-236 Inexact Rounded precision: 19 expx058 exp -5.42410311287441459172E+2 -> 2.717658486884572112E-236 Inexact Rounded precision: 20 expx059 exp -5.42410311287441459172E+2 -> 2.7176584868845721118E-236 Inexact Rounded -- rounding in areas of ..500.., ..499.., ..100.., ..999.. sequences precision: 50 expx101 exp -9E-8 -> 0.99999991000000404999987850000273374995079250073811 Inexact Rounded precision: 31 expx102 exp -9E-8 -> 0.9999999100000040499998785000027 Inexact Rounded precision: 30 expx103 exp -9E-8 -> 0.999999910000004049999878500003 Inexact Rounded precision: 29 expx104 exp -9E-8 -> 0.99999991000000404999987850000 Inexact Rounded precision: 28 expx105 exp -9E-8 -> 0.9999999100000040499998785000 Inexact Rounded precision: 27 expx106 exp -9E-8 -> 0.999999910000004049999878500 Inexact Rounded precision: 26 expx107 exp -9E-8 -> 0.99999991000000404999987850 Inexact Rounded precision: 25 expx108 exp -9E-8 -> 0.9999999100000040499998785 Inexact Rounded precision: 24 expx109 exp -9E-8 -> 0.999999910000004049999879 Inexact Rounded precision: 23 expx110 exp -9E-8 -> 0.99999991000000404999988 Inexact Rounded precision: 22 expx111 exp -9E-8 -> 0.9999999100000040499999 Inexact Rounded precision: 21 expx112 exp -9E-8 -> 0.999999910000004050000 Inexact Rounded precision: 20 expx113 exp -9E-8 -> 0.99999991000000405000 Inexact Rounded precision: 19 expx114 exp -9E-8 -> 0.9999999100000040500 Inexact Rounded precision: 18 expx115 exp -9E-8 -> 0.999999910000004050 Inexact Rounded precision: 17 expx116 exp -9E-8 -> 0.99999991000000405 Inexact Rounded precision: 16 expx117 exp -9E-8 -> 0.9999999100000040 Inexact Rounded precision: 15 expx118 exp -9E-8 -> 0.999999910000004 Inexact Rounded precision: 14 expx119 exp -9E-8 -> 0.99999991000000 Inexact Rounded precision: 13 expx120 exp -9E-8 -> 0.9999999100000 Inexact Rounded precision: 12 expx121 exp -9E-8 -> 0.999999910000 Inexact Rounded precision: 11 expx122 exp -9E-8 -> 0.99999991000 Inexact Rounded precision: 10 expx123 exp -9E-8 -> 0.9999999100 Inexact Rounded precision: 9 expx124 exp -9E-8 -> 0.999999910 Inexact Rounded precision: 8 expx125 exp -9E-8 -> 0.99999991 Inexact Rounded precision: 7 expx126 exp -9E-8 -> 0.9999999 Inexact Rounded precision: 6 expx127 exp -9E-8 -> 1.00000 Inexact Rounded precision: 5 expx128 exp -9E-8 -> 1.0000 Inexact Rounded precision: 4 expx129 exp -9E-8 -> 1.000 Inexact Rounded precision: 3 expx130 exp -9E-8 -> 1.00 Inexact Rounded precision: 2 expx131 exp -9E-8 -> 1.0 Inexact Rounded precision: 1 expx132 exp -9E-8 -> 1 Inexact Rounded -- sanity checks, with iteration counts [normalized so 0<=|x|<1] precision: 50 expx210 exp 0 -> 1 -- iterations: 2 expx211 exp -1E-40 -> 0.99999999999999999999999999999999999999990000000000 Inexact Rounded -- iterations: 8 expx212 exp -9E-7 -> 0.99999910000040499987850002733749507925073811240510 Inexact Rounded -- iterations: 6 expx213 exp -9E-8 -> 0.99999991000000404999987850000273374995079250073811 Inexact Rounded -- iterations: 15 expx214 exp -0.003 -> 0.99700449550337297601206623409756091074177480489845 Inexact Rounded -- iterations: 14 expx215 exp -0.001 -> 0.99900049983337499166805535716765597470235590236008 Inexact Rounded -- iterations: 26 expx216 exp -0.1 -> 0.90483741803595957316424905944643662119470536098040 Inexact Rounded -- iterations: 39 expx217 exp -0.7 -> 0.49658530379140951470480009339752896170766716571182 Inexact Rounded -- iterations: 41 expx218 exp -0.9 -> 0.40656965974059911188345423964562598783370337617038 Inexact Rounded -- iterations: 43 expx219 exp -0.99 -> 0.37157669102204569053152411990820138691802885490501 Inexact Rounded -- iterations: 26 expx220 exp -1 -> 0.36787944117144232159552377016146086744581113103177 Inexact Rounded -- iterations: 26 expx221 exp -1.01 -> 0.36421897957152331975704629563734548959589139192482 Inexact Rounded -- iterations: 27 expx222 exp -1.1 -> 0.33287108369807955328884690643131552161247952156921 Inexact Rounded -- iterations: 28 expx223 exp -1.5 -> 0.22313016014842982893328047076401252134217162936108 Inexact Rounded -- iterations: 30 expx224 exp -2 -> 0.13533528323661269189399949497248440340763154590958 Inexact Rounded -- iterations: 36 expx225 exp -5 -> 0.0067379469990854670966360484231484242488495850273551 Inexact Rounded -- iterations: 26 expx226 exp -10 -> 0.000045399929762484851535591515560550610237918088866565 Inexact Rounded -- iterations: 28 expx227 exp -14 -> 8.3152871910356788406398514256526229460765836498457E-7 Inexact Rounded -- iterations: 29 expx228 exp -15 -> 3.0590232050182578837147949770228963937082078081856E-7 Inexact Rounded -- iterations: 30 expx233 exp 0 -> 1 -- iterations: 2 expx234 exp 1E-40 -> 1.0000000000000000000000000000000000000001000000000 Inexact Rounded -- iterations: 7 expx235 exp 9E-7 -> 1.0000009000004050001215000273375049207507381125949 Inexact Rounded -- iterations: 6 expx236 exp 9E-8 -> 1.0000000900000040500001215000027337500492075007381 Inexact Rounded -- iterations: 15 expx237 exp 0.003 -> 1.0030045045033770260129340913489002053318727195619 Inexact Rounded -- iterations: 13 expx238 exp 0.001 -> 1.0010005001667083416680557539930583115630762005807 Inexact Rounded -- iterations: 25 expx239 exp 0.1 -> 1.1051709180756476248117078264902466682245471947375 Inexact Rounded -- iterations: 38 expx240 exp 0.7 -> 2.0137527074704765216245493885830652700175423941459 Inexact Rounded -- iterations: 41 expx241 exp 0.9 -> 2.4596031111569496638001265636024706954217723064401 Inexact Rounded -- iterations: 42 expx242 exp 0.99 -> 2.6912344723492622890998794040710139721802931841030 Inexact Rounded -- iterations: 26 expx243 exp 1 -> 2.7182818284590452353602874713526624977572470937000 Inexact Rounded -- iterations: 26 expx244 exp 1.01 -> 2.7456010150169164939897763166603876240737508195960 Inexact Rounded -- iterations: 26 expx245 exp 1.1 -> 3.0041660239464331120584079535886723932826810260163 Inexact Rounded -- iterations: 28 expx246 exp 1.5 -> 4.4816890703380648226020554601192758190057498683697 Inexact Rounded -- iterations: 29 expx247 exp 2 -> 7.3890560989306502272304274605750078131803155705518 Inexact Rounded -- iterations: 36 expx248 exp 5 -> 148.41315910257660342111558004055227962348766759388 Inexact Rounded -- iterations: 26 expx249 exp 10 -> 22026.465794806716516957900645284244366353512618557 Inexact Rounded -- iterations: 28 expx250 exp 14 -> 1202604.2841647767777492367707678594494124865433761 Inexact Rounded -- iterations: 28 expx251 exp 15 -> 3269017.3724721106393018550460917213155057385438200 Inexact Rounded -- iterations: 29 -- a biggie [result verified 3 ways] precision: 250 expx260 exp 1 -> 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921817413596629043572900334295260595630738132328627943490763233829880753195251019011573834187930702154089149934884167509244761460668 Inexact Rounded -- extreme range boundaries precision: 16 maxExponent: 999999 minExponent: -999999 -- Ntiny boundary expx290 exp -2302618.022332529 -> 0E-1000014 Underflow Subnormal Inexact Rounded Clamped expx291 exp -2302618.022332528 -> 1E-1000014 Underflow Subnormal Inexact Rounded -- Nmax/10 and Nmax boundary expx292 exp 2302582.790408952 -> 9.999999993100277E+999998 Inexact Rounded expx293 exp 2302582.790408953 -> 1.000000000310028E+999999 Inexact Rounded expx294 exp 2302585.092993946 -> 9.999999003159870E+999999 Inexact Rounded expx295 exp 2302585.092994036 -> 9.999999903159821E+999999 Inexact Rounded expx296 exp 2302585.092994045 -> 9.999999993159820E+999999 Inexact Rounded expx297 exp 2302585.092994046 -> Infinity Overflow Inexact Rounded -- 0<-x<<1 effects precision: 30 expx320 exp -4.9999999999999E-8 -> 0.999999950000001250000979166617 Inexact Rounded expx321 exp -5.0000000000000E-8 -> 0.999999950000001249999979166667 Inexact Rounded expx322 exp -5.0000000000001E-8 -> 0.999999950000001249998979166717 Inexact Rounded precision: 20 expx323 exp -4.9999999999999E-8 -> 0.99999995000000125000 Inexact Rounded expx324 exp -5.0000000000000E-8 -> 0.99999995000000125000 Inexact Rounded expx325 exp -5.0000000000001E-8 -> 0.99999995000000125000 Inexact Rounded precision: 14 expx326 exp -4.9999999999999E-8 -> 0.99999995000000 Inexact Rounded expx327 exp -5.0000000000000E-8 -> 0.99999995000000 Inexact Rounded expx328 exp -5.0000000000001E-8 -> 0.99999995000000 Inexact Rounded -- overprecise and 0<-x<<1 precision: 8 expx330 exp -4.9999999999999E-8 -> 0.99999995 Inexact Rounded expx331 exp -5.0000000000000E-8 -> 0.99999995 Inexact Rounded expx332 exp -5.0000000000001E-8 -> 0.99999995 Inexact Rounded precision: 7 expx333 exp -4.9999999999999E-8 -> 1.000000 Inexact Rounded expx334 exp -5.0000000000000E-8 -> 1.000000 Inexact Rounded expx335 exp -5.0000000000001E-8 -> 1.000000 Inexact Rounded precision: 3 expx336 exp -4.9999999999999E-8 -> 1.00 Inexact Rounded expx337 exp -5.0000000000000E-8 -> 1.00 Inexact Rounded expx338 exp -5.0000000000001E-8 -> 1.00 Inexact Rounded -- 0 1.00000005000000124999902083328 Inexact Rounded expx341 exp 5.0000000000000E-8 -> 1.00000005000000125000002083333 Inexact Rounded expx342 exp 5.0000000000001E-8 -> 1.00000005000000125000102083338 Inexact Rounded precision: 20 expx343 exp 4.9999999999999E-8 -> 1.0000000500000012500 Inexact Rounded expx344 exp 5.0000000000000E-8 -> 1.0000000500000012500 Inexact Rounded expx345 exp 5.0000000000001E-8 -> 1.0000000500000012500 Inexact Rounded precision: 14 expx346 exp 4.9999999999999E-8 -> 1.0000000500000 Inexact Rounded expx347 exp 5.0000000000000E-8 -> 1.0000000500000 Inexact Rounded expx348 exp 5.0000000000001E-8 -> 1.0000000500000 Inexact Rounded -- overprecise and 0 1.0000001 Inexact Rounded expx351 exp 5.0000000000000E-8 -> 1.0000001 Inexact Rounded expx352 exp 5.0000000000001E-8 -> 1.0000001 Inexact Rounded precision: 7 expx353 exp 4.9999999999999E-8 -> 1.000000 Inexact Rounded expx354 exp 5.0000000000000E-8 -> 1.000000 Inexact Rounded expx355 exp 5.0000000000001E-8 -> 1.000000 Inexact Rounded precision: 3 expx356 exp 4.9999999999999E-8 -> 1.00 Inexact Rounded expx357 exp 5.0000000000000E-8 -> 1.00 Inexact Rounded expx358 exp 5.0000000000001E-8 -> 1.00 Inexact Rounded -- cases near 1 -- 1 2345678901234567890 precision: 20 expx401 exp 0.99999999999996 -> 2.7182818284589365041 Inexact Rounded expx402 exp 0.99999999999997 -> 2.7182818284589636869 Inexact Rounded expx403 exp 0.99999999999998 -> 2.7182818284589908697 Inexact Rounded expx404 exp 0.99999999999999 -> 2.7182818284590180525 Inexact Rounded expx405 exp 1.0000000000000 -> 2.7182818284590452354 Inexact Rounded expx406 exp 1.0000000000001 -> 2.7182818284593170635 Inexact Rounded expx407 exp 1.0000000000002 -> 2.7182818284595888917 Inexact Rounded precision: 14 expx411 exp 0.99999999999996 -> 2.7182818284589 Inexact Rounded expx412 exp 0.99999999999997 -> 2.7182818284590 Inexact Rounded expx413 exp 0.99999999999998 -> 2.7182818284590 Inexact Rounded expx414 exp 0.99999999999999 -> 2.7182818284590 Inexact Rounded expx415 exp 1.0000000000000 -> 2.7182818284590 Inexact Rounded expx416 exp 1.0000000000001 -> 2.7182818284593 Inexact Rounded expx417 exp 1.0000000000002 -> 2.7182818284596 Inexact Rounded -- overprecise... precision: 7 expx421 exp 0.99999999999996 -> 2.718282 Inexact Rounded expx422 exp 0.99999999999997 -> 2.718282 Inexact Rounded expx423 exp 0.99999999999998 -> 2.718282 Inexact Rounded expx424 exp 0.99999999999999 -> 2.718282 Inexact Rounded expx425 exp 1.0000000000001 -> 2.718282 Inexact Rounded expx426 exp 1.0000000000002 -> 2.718282 Inexact Rounded expx427 exp 1.0000000000003 -> 2.718282 Inexact Rounded precision: 2 expx431 exp 0.99999999999996 -> 2.7 Inexact Rounded expx432 exp 0.99999999999997 -> 2.7 Inexact Rounded expx433 exp 0.99999999999998 -> 2.7 Inexact Rounded expx434 exp 0.99999999999999 -> 2.7 Inexact Rounded expx435 exp 1.0000000000001 -> 2.7 Inexact Rounded expx436 exp 1.0000000000002 -> 2.7 Inexact Rounded expx437 exp 1.0000000000003 -> 2.7 Inexact Rounded -- basics at low precisions precision: 3 expx501 exp -Infinity -> 0 expx502 exp -10 -> 0.0000454 Inexact Rounded expx503 exp -1 -> 0.368 Inexact Rounded expx504 exp 0 -> 1 expx505 exp -0 -> 1 expx506 exp 1 -> 2.72 Inexact Rounded expx507 exp 0.693147181 -> 2.00 Inexact Rounded expx508 exp 10 -> 2.20E+4 Inexact Rounded expx509 exp +Infinity -> Infinity precision: 2 expx511 exp -Infinity -> 0 expx512 exp -10 -> 0.000045 Inexact Rounded expx513 exp -1 -> 0.37 Inexact Rounded expx514 exp 0 -> 1 expx515 exp -0 -> 1 expx516 exp 1 -> 2.7 Inexact Rounded expx517 exp 0.693147181 -> 2.0 Inexact Rounded expx518 exp 10 -> 2.2E+4 Inexact Rounded expx519 exp +Infinity -> Infinity precision: 1 expx521 exp -Infinity -> 0 expx522 exp -10 -> 0.00005 Inexact Rounded expx523 exp -1 -> 0.4 Inexact Rounded expx524 exp 0 -> 1 expx525 exp -0 -> 1 expx526 exp 1 -> 3 Inexact Rounded expx527 exp 0.693147181 -> 2 Inexact Rounded expx528 exp 10 -> 2E+4 Inexact Rounded expx529 exp +Infinity -> Infinity -- overflows, including some overprecise borderlines precision: 7 maxExponent: 384 minExponent: -383 expx701 exp 1000000000 -> Infinity Overflow Inexact Rounded expx702 exp 100000000 -> Infinity Overflow Inexact Rounded expx703 exp 10000000 -> Infinity Overflow Inexact Rounded expx704 exp 1000000 -> Infinity Overflow Inexact Rounded expx705 exp 100000 -> Infinity Overflow Inexact Rounded expx706 exp 10000 -> Infinity Overflow Inexact Rounded expx707 exp 1000 -> Infinity Overflow Inexact Rounded expx708 exp 886.4952608 -> Infinity Overflow Inexact Rounded expx709 exp 886.4952607 -> 9.999999E+384 Inexact Rounded expx710 exp 886.49527 -> Infinity Overflow Inexact Rounded expx711 exp 886.49526 -> 9.999992E+384 Inexact Rounded precision: 16 expx721 exp 886.4952608027075883 -> Infinity Overflow Inexact Rounded expx722 exp 886.4952608027075882 -> 9.999999999999999E+384 Inexact Rounded expx723 exp 886.49526080270759 -> Infinity Overflow Inexact Rounded expx724 exp 886.49526080270758 -> 9.999999999999917E+384 Inexact Rounded expx725 exp 886.4952608027076 -> Infinity Overflow Inexact Rounded expx726 exp 886.4952608027075 -> 9.999999999999117E+384 Inexact Rounded -- and by special request ... precision: 15 expx731 exp 886.495260802708 -> Infinity Overflow Inexact Rounded expx732 exp 886.495260802707 -> 9.99999999999412E+384 Inexact Rounded expx733 exp 886.495260802706 -> 9.99999999998412E+384 Inexact Rounded maxExponent: 999 minExponent: -999 expx735 exp 2302.58509299405 -> Infinity Overflow Inexact Rounded expx736 exp 2302.58509299404 -> 9.99999999994316E+999 Inexact Rounded expx737 exp 2302.58509299403 -> 9.99999999984316E+999 Inexact Rounded -- subnormals and underflows, including underflow-to-zero edge point precision: 7 maxExponent: 384 minExponent: -383 expx751 exp -1000000000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx752 exp -100000000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx753 exp -10000000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx754 exp -1000000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx755 exp -100000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx756 exp -10000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx757 exp -1000 -> 0E-389 Underflow Inexact Rounded Clamped Subnormal expx758 exp -881.89009 -> 1.000001E-383 Inexact Rounded expx759 exp -881.8901 -> 9.99991E-384 Inexact Rounded Underflow Subnormal expx760 exp -885 -> 4.4605E-385 Inexact Rounded Underflow Subnormal expx761 exp -888 -> 2.221E-386 Inexact Rounded Underflow Subnormal expx762 exp -890 -> 3.01E-387 Inexact Rounded Underflow Subnormal expx763 exp -892.9 -> 1.7E-388 Inexact Rounded Underflow Subnormal expx764 exp -893 -> 1.5E-388 Inexact Rounded Underflow Subnormal expx765 exp -893.5 -> 9E-389 Inexact Rounded Underflow Subnormal expx766 exp -895.7056 -> 1E-389 Inexact Rounded Underflow Subnormal expx769 exp -895.8 -> 1E-389 Inexact Rounded Underflow Subnormal expx770 exp -895.73 -> 1E-389 Inexact Rounded Underflow Subnormal expx771 exp -896.3987 -> 1E-389 Inexact Rounded Underflow Subnormal expx772 exp -896.3988 -> 0E-389 Inexact Rounded Underflow Subnormal Clamped expx773 exp -898.0081 -> 0E-389 Inexact Rounded Underflow Subnormal Clamped expx774 exp -898.0082 -> 0E-389 Inexact Rounded Underflow Subnormal Clamped -- special values maxexponent: 999 minexponent: -999 expx820 exp Inf -> Infinity expx821 exp -Inf -> 0 expx822 exp NaN -> NaN expx823 exp sNaN -> NaN Invalid_operation -- propagating NaNs expx824 exp sNaN123 -> NaN123 Invalid_operation expx825 exp -sNaN321 -> -NaN321 Invalid_operation expx826 exp NaN456 -> NaN456 expx827 exp -NaN654 -> -NaN654 expx828 exp NaN1 -> NaN1 -- Invalid operations due to restrictions -- [next two probably skipped by most test harnesses] precision: 100000000 expx901 exp -Infinity -> NaN Invalid_context precision: 99999999 expx902 exp -Infinity -> NaN Invalid_context precision: 9 maxExponent: 1000000 minExponent: -999999 expx903 exp -Infinity -> NaN Invalid_context maxExponent: 999999 minExponent: -999999 expx904 exp -Infinity -> 0 maxExponent: 999999 minExponent: -1000000 expx905 exp -Infinity -> NaN Invalid_context maxExponent: 999999 minExponent: -999998 expx906 exp -Infinity -> 0 -- maxExponent: 384 minExponent: -383 precision: 16 rounding: half_even -- Null test expx900 exp # -> NaN Invalid_operation -- Randoms P=50, within 0-999 Precision: 50 maxExponent: 384 minExponent: -383 expx1501 exp 656.35397950590285612266095596539934213943872885728 -> 1.1243757610640319783611178528839652672062820040314E+285 Inexact Rounded expx1502 exp 0.93620571093652800225038550600780322831236082781471 -> 2.5502865130986176689199711857825771311178046842009 Inexact Rounded expx1503 exp 0.00000000000000008340785856601514714183373874105791 -> 1.0000000000000000834078585660151506202691740252512 Inexact Rounded expx1504 exp 0.00009174057262887789625745574686545163168788456203 -> 1.0000917447809239005146722341251524081006051473273 Inexact Rounded expx1505 exp 33.909116897973797735657751591014926629051117541243 -> 532773181025002.03543618901306726495870476617232229 Inexact Rounded expx1506 exp 0.00000740470413004406592124575295278456936809587311 -> 1.0000074047315449333590066395670306135567889210814 Inexact Rounded expx1507 exp 0.00000000000124854922222108802453746922483071445492 -> 1.0000000000012485492222218674621176239911424968263 Inexact Rounded expx1508 exp 4.1793280674155659794286951159430651258356014391382 -> 65.321946520147199404199787811336860087975118278185 Inexact Rounded expx1509 exp 485.43595745460655893746179890255529919221550201686 -> 6.6398403920459617255950476953129377459845366585463E+210 Inexact Rounded expx1510 exp 0.00000000003547259806590856032527875157830328156597 -> 1.0000000000354725980665377129320589406715000685515 Inexact Rounded expx1511 exp 0.00000000000000759621497339104047930616478635042678 -> 1.0000000000000075962149733910693305471257715463887 Inexact Rounded expx1512 exp 9.7959168821760339304571595474480640286072720233796 -> 17960.261146042955179164303653412650751681436352437 Inexact Rounded expx1513 exp 0.00000000566642006258290526783901451194943164535581 -> 1.0000000056664200786370634609832438815665249347650 Inexact Rounded expx1514 exp 741.29888791134298194088827572374718940925820027354 -> 8.7501694006317332808128946666402622432064923198731E+321 Inexact Rounded expx1515 exp 032.75573003552517668808529099897153710887014947935 -> 168125196578678.17725841108617955904425345631092339 Inexact Rounded expx1516 exp 42.333700726429333308594265553422902463737399437644 -> 2428245675864172475.4681119493045657797309369672012 Inexact Rounded expx1517 exp 0.00000000000000559682616876491888197609158802835798 -> 1.0000000000000055968261687649345442076732739577049 Inexact Rounded expx1518 exp 0.00000000000080703688668280193584758300973549486312 -> 1.0000000000008070368866831275901158164321867914342 Inexact Rounded expx1519 exp 640.72396012796509482382712891709072570653606838251 -> 1.8318094990683394229304133068983914236995326891045E+278 Inexact Rounded expx1520 exp 0.00000000000000509458922167631071416948112219512224 -> 1.0000000000000050945892216763236915891499324358556 Inexact Rounded expx1521 exp 6.7670394314315206378625221583973414660727960241395 -> 868.73613012822031367806248697092884415119568271315 Inexact Rounded expx1522 exp 04.823217407412963506638267226891024138054783122548 -> 124.36457929588837129731821077586705505565904205366 Inexact Rounded expx1523 exp 193.51307878701196403991208482520115359690106143615 -> 1.1006830872854715677390914655452261550768957576034E+84 Inexact Rounded expx1524 exp 5.7307749038303650539200345901210497015617393970463 -> 308.20800743106843083522721523715645950574866495196 Inexact Rounded expx1525 exp 0.00000000000095217825199797965200541169123743500267 -> 1.0000000000009521782519984329737172007991390381273 Inexact Rounded expx1526 exp 0.00027131440949183370966393682617930153495028919140 -> 1.0002713512185751022906058160480606598754913607364 Inexact Rounded expx1527 exp 0.00000000064503059114680682343002315662069272707123 -> 1.0000000006450305913548390552323517403613135496633 Inexact Rounded expx1528 exp 0.00000000000000095616643506527288866235238548440593 -> 1.0000000000000009561664350652733457894781582009094 Inexact Rounded expx1529 exp 0.00000000000000086449942811678650244459550252743433 -> 1.0000000000000008644994281167868761242261096529986 Inexact Rounded expx1530 exp 0.06223488355635359965683053157729204988381887621850 -> 1.0642122813392406657789688931838919323826250630831 Inexact Rounded expx1531 exp 0.00000400710807804429435502657131912308680674057053 -> 1.0000040071161065125925620890019319832127863559260 Inexact Rounded expx1532 exp 85.522796894744576211573232055494551429297878413017 -> 13870073686404228452757799770251085177.853337368935 Inexact Rounded expx1533 exp 9.1496720811363678696938036379756663548353399954363 -> 9411.3537122832743386783597629161763057370034495157 Inexact Rounded expx1534 exp 8.2215705240788294472944382056330516738577785177942 -> 3720.3406813383076953899654701615084425598377758189 Inexact Rounded expx1535 exp 0.00000000015772064569640613142823203726821076239561 -> 1.0000000001577206457088440324683315788358926129830 Inexact Rounded expx1536 exp 0.58179346473959531432624153576883440625538017532480 -> 1.7892445018275360163797022372655837188423194863605 Inexact Rounded expx1537 exp 33.555726197149525061455517784870570470833498096559 -> 374168069896324.62578073148993526626307095854407952 Inexact Rounded expx1538 exp 9.7898079803906215094140010009583375537259810398659 -> 17850.878119912208888217100998019986634620368538426 Inexact Rounded expx1539 exp 89.157697327174521542502447953032536541038636966347 -> 525649152320166503771224149330448089550.67293829227 Inexact Rounded expx1540 exp 25.022947600123328912029051897171319573322888514885 -> 73676343442.952517824345431437683153304645851960524 Inexact Rounded -- exp(1) at 34 Precision: 34 expx1200 exp 1 -> 2.718281828459045235360287471352662 Inexact Rounded -- Randoms P=34, within 0-999 Precision: 34 maxExponent: 6144 minExponent: -6143 expx1201 exp 309.5948855821510212996700645087188 -> 2.853319692901387521201738015050724E+134 Inexact Rounded expx1202 exp 9.936543068706211420422803962680164 -> 20672.15839203171877476511093276022 Inexact Rounded expx1203 exp 6.307870323881505684429839491707908 -> 548.8747777054637296137277391754665 Inexact Rounded expx1204 exp 0.0003543281389438420535201308282503 -> 1.000354390920573746164733350843155 Inexact Rounded expx1205 exp 0.0000037087453363918375598394920229 -> 1.000003708752213796324841920189323 Inexact Rounded expx1206 exp 0.0020432312687512438040222444116585 -> 1.002045320088164826013561630975308 Inexact Rounded expx1207 exp 6.856313340032177672550343216129586 -> 949.8587981604144147983589660524396 Inexact Rounded expx1208 exp 0.0000000000402094928333815643326418 -> 1.000000000040209492834189965989612 Inexact Rounded expx1209 exp 0.0049610784722412117632647003545839 -> 1.004973404997901987039589029277833 Inexact Rounded expx1210 exp 0.0000891471883724066909746786702686 -> 1.000089151162101085412780088266699 Inexact Rounded expx1211 exp 08.59979170376061890684723211112566 -> 5430.528314920905714615339273738097 Inexact Rounded expx1212 exp 9.473117039341003854872778112752590 -> 13005.36234331224953460055897913917 Inexact Rounded expx1213 exp 0.0999060724692207648429969999310118 -> 1.105067116975190602296052700726802 Inexact Rounded expx1214 exp 0.0000000927804533555877884082269247 -> 1.000000092780457659694183954740772 Inexact Rounded expx1215 exp 0.0376578583872889916298772818265677 -> 1.038375900489771946477857818447556 Inexact Rounded expx1216 exp 261.6896411697539524911536116712307 -> 4.470613562127465095241600174941460E+113 Inexact Rounded expx1217 exp 0.0709997423269162980875824213889626 -> 1.073580949235407949417814485533172 Inexact Rounded expx1218 exp 0.0000000444605583295169895235658731 -> 1.000000044460559317887627657593900 Inexact Rounded expx1219 exp 0.0000021224072854777512281369815185 -> 1.000002122409537785687390631070906 Inexact Rounded expx1220 exp 547.5174462574156885473558485475052 -> 6.078629247383807942612114579728672E+237 Inexact Rounded expx1221 exp 0.0000009067598041615192002339844670 -> 1.000000906760215268314680115374387 Inexact Rounded expx1222 exp 0.0316476500308065365803455533244603 -> 1.032153761880187977658387961769034 Inexact Rounded expx1223 exp 84.46160530377645101833996706384473 -> 4.799644995897968383503269871697856E+36 Inexact Rounded expx1224 exp 0.0000000000520599740290848018904145 -> 1.000000000052059974030439922338393 Inexact Rounded expx1225 exp 0.0000006748530640093620665651726708 -> 1.000000674853291722742292331812997 Inexact Rounded expx1226 exp 0.0000000116853119761042020507916169 -> 1.000000011685312044377460306165203 Inexact Rounded expx1227 exp 0.0022593818094258636727616886693280 -> 1.002261936135876893707094845543461 Inexact Rounded expx1228 exp 0.0029398857673478912249856509667517 -> 1.002944211469495086813087651287012 Inexact Rounded expx1229 exp 0.7511480029928802775376270557636963 -> 2.119431734510320169806976569366789 Inexact Rounded expx1230 exp 174.9431952176750671150886423048447 -> 9.481222305374955011464619468044051E+75 Inexact Rounded expx1231 exp 0.0000810612451694136129199895164424 -> 1.000081064530720924186615149646920 Inexact Rounded expx1232 exp 51.06888989702669288180946272499035 -> 15098613888619165073959.89896018749 Inexact Rounded expx1233 exp 0.0000000005992887599437093651494510 -> 1.000000000599288760123282874082758 Inexact Rounded expx1234 exp 714.8549046761054856311108828903972 -> 2.867744544891081117381595080480784E+310 Inexact Rounded expx1235 exp 0.0000000004468247802990643645607110 -> 1.000000000446824780398890556720233 Inexact Rounded expx1236 exp 831.5818151589890366323551672043709 -> 1.417077409182624969435938062261655E+361 Inexact Rounded expx1237 exp 0.0000000006868323825179605747108044 -> 1.000000000686832382753829935602454 Inexact Rounded expx1238 exp 0.0000001306740266408976840228440255 -> 1.000000130674035178748675187648098 Inexact Rounded expx1239 exp 0.3182210609022267704811502412335163 -> 1.374680115667798185758927247894859 Inexact Rounded expx1240 exp 0.0147741234179104437440264644295501 -> 1.014883800239950682628277534839222 Inexact Rounded -- Randoms P=16, within 0-99 Precision: 16 maxExponent: 384 minExponent: -383 expx1101 exp 8.473011527013724 -> 4783.900643969246 Inexact Rounded expx1102 exp 0.0000055753022764 -> 1.000005575317818 Inexact Rounded expx1103 exp 0.0000323474114482 -> 1.000032347934631 Inexact Rounded expx1104 exp 64.54374138544166 -> 1.073966476173531E+28 Inexact Rounded expx1105 exp 90.47203246416569 -> 1.956610887250643E+39 Inexact Rounded expx1106 exp 9.299931532342757 -> 10937.27033325227 Inexact Rounded expx1107 exp 8.759678437852203 -> 6372.062234495381 Inexact Rounded expx1108 exp 0.0000931755127172 -> 1.000093179853690 Inexact Rounded expx1109 exp 0.0000028101158373 -> 1.000002810119786 Inexact Rounded expx1110 exp 0.0000008008130919 -> 1.000000800813413 Inexact Rounded expx1111 exp 8.339771722299049 -> 4187.133803081878 Inexact Rounded expx1112 exp 0.0026140497995474 -> 1.002617469406750 Inexact Rounded expx1113 exp 0.7478033356261771 -> 2.112354781975418 Inexact Rounded expx1114 exp 51.77663761827966 -> 3.064135801120365E+22 Inexact Rounded expx1115 exp 0.1524989783061012 -> 1.164741272084955 Inexact Rounded expx1116 exp 0.0066298798669219 -> 1.006651906170791 Inexact Rounded expx1117 exp 9.955141865534960 -> 21060.23334287038 Inexact Rounded expx1118 exp 92.34503059198483 -> 1.273318993481226E+40 Inexact Rounded expx1119 exp 0.0000709388677346 -> 1.000070941383956 Inexact Rounded expx1120 exp 79.12883036433204 -> 2.318538899389243E+34 Inexact Rounded expx1121 exp 0.0000090881548873 -> 1.000009088196185 Inexact Rounded expx1122 exp 0.0424828809603411 -> 1.043398194245720 Inexact Rounded expx1123 exp 0.8009035891427416 -> 2.227552811933310 Inexact Rounded expx1124 exp 8.825786167283102 -> 6807.540455289995 Inexact Rounded expx1125 exp 1.535457249746275 -> 4.643448260146849 Inexact Rounded expx1126 exp 69.02254254355800 -> 9.464754500670653E+29 Inexact Rounded expx1127 exp 0.0007050554368713 -> 1.000705304046880 Inexact Rounded expx1128 exp 0.0000081206549504 -> 1.000008120687923 Inexact Rounded expx1129 exp 0.621774854641137 -> 1.862230298554903 Inexact Rounded expx1130 exp 3.847629031404354 -> 46.88177613568203 Inexact Rounded expx1131 exp 24.81250184697732 -> 59694268456.19966 Inexact Rounded expx1132 exp 5.107546500516044 -> 165.2643809755670 Inexact Rounded expx1133 exp 79.17810943951986 -> 2.435656372541360E+34 Inexact Rounded expx1134 exp 0.0051394695667015 -> 1.005152699295301 Inexact Rounded expx1135 exp 57.44504488501725 -> 8.872908566929688E+24 Inexact Rounded expx1136 exp 0.0000508388968036 -> 1.000050840189122 Inexact Rounded expx1137 exp 69.71309932148997 -> 1.888053740693541E+30 Inexact Rounded expx1138 exp 0.0064183412981502 -> 1.006438982988835 Inexact Rounded expx1139 exp 9.346991220814677 -> 11464.27802035082 Inexact Rounded expx1140 exp 33.09087139999152 -> 235062229168763.5 Inexact Rounded -- Randoms P=7, within 0-9 Precision: 7 maxExponent: 96 minExponent: -95 expx1001 exp 2.395441 -> 10.97304 Inexact Rounded expx1002 exp 0.6406779 -> 1.897767 Inexact Rounded expx1003 exp 0.5618218 -> 1.753865 Inexact Rounded expx1004 exp 3.055120 -> 21.22373 Inexact Rounded expx1005 exp 1.536792 -> 4.649650 Inexact Rounded expx1006 exp 0.0801591 -> 1.083459 Inexact Rounded expx1007 exp 0.0966875 -> 1.101516 Inexact Rounded expx1008 exp 0.0646761 -> 1.066813 Inexact Rounded expx1009 exp 0.0095670 -> 1.009613 Inexact Rounded expx1010 exp 2.956859 -> 19.23745 Inexact Rounded expx1011 exp 7.504679 -> 1816.522 Inexact Rounded expx1012 exp 0.0045259 -> 1.004536 Inexact Rounded expx1013 exp 3.810071 -> 45.15364 Inexact Rounded expx1014 exp 1.502390 -> 4.492413 Inexact Rounded expx1015 exp 0.0321523 -> 1.032675 Inexact Rounded expx1016 exp 0.0057214 -> 1.005738 Inexact Rounded expx1017 exp 9.811445 -> 18241.33 Inexact Rounded expx1018 exp 3.245249 -> 25.66810 Inexact Rounded expx1019 exp 0.3189742 -> 1.375716 Inexact Rounded expx1020 exp 0.8621610 -> 2.368273 Inexact Rounded expx1021 exp 0.0122511 -> 1.012326 Inexact Rounded expx1022 exp 2.202088 -> 9.043877 Inexact Rounded expx1023 exp 8.778203 -> 6491.202 Inexact Rounded expx1024 exp 0.1896279 -> 1.208800 Inexact Rounded expx1025 exp 0.4510947 -> 1.570030 Inexact Rounded expx1026 exp 0.276413 -> 1.318392 Inexact Rounded expx1027 exp 4.490067 -> 89.12742 Inexact Rounded expx1028 exp 0.0439786 -> 1.044960 Inexact Rounded expx1029 exp 0.8168245 -> 2.263301 Inexact Rounded expx1030 exp 0.0391658 -> 1.039943 Inexact Rounded expx1031 exp 9.261816 -> 10528.24 Inexact Rounded expx1032 exp 9.611186 -> 14930.87 Inexact Rounded expx1033 exp 9.118125 -> 9119.087 Inexact Rounded expx1034 exp 9.469083 -> 12953.00 Inexact Rounded expx1035 exp 0.0499983 -> 1.051269 Inexact Rounded expx1036 exp 0.0050746 -> 1.005087 Inexact Rounded expx1037 exp 0.0014696 -> 1.001471 Inexact Rounded expx1038 exp 9.138494 -> 9306.739 Inexact Rounded expx1039 exp 0.0065436 -> 1.006565 Inexact Rounded expx1040 exp 0.7284803 -> 2.071930 Inexact Rounded apd-3.2.1/testdata/ln.decTest000066400000000000000000001051731450022325000160200ustar00rootroot00000000000000------------------------------------------------------------------------ -- ln.decTest -- decimal natural logarithm -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 16 rounding: half_even maxExponent: 384 minexponent: -383 -- basics (examples in specification) precision: 9 lnxs001 ln 0 -> -Infinity lnxs002 ln 1.000 -> 0 lnxs003 ln 2.71828183 -> 1.00000000 Inexact Rounded lnxs004 ln 10 -> 2.30258509 Inexact Rounded lnxs005 ln +Infinity -> Infinity -- basics precision: 16 lnx0001 ln 0 -> -Infinity lnx0002 ln 1E-9 -> -20.72326583694641 Inexact Rounded lnx0003 ln 0.0007 -> -7.264430222920869 Inexact Rounded lnx0004 ln 0.1 -> -2.302585092994046 Inexact Rounded lnx0005 ln 0.7 -> -0.3566749439387324 Inexact Rounded lnx0006 ln 1 -> 0 lnx0007 ln 1.000 -> 0 lnx0008 ln 1.5 -> 0.4054651081081644 Inexact Rounded lnx0009 ln 2 -> 0.6931471805599453 Inexact Rounded lnx0010 ln 2.718281828459045 -> 0.9999999999999999 Inexact Rounded lnx0011 ln 2.718281828459046 -> 1.000000000000000 Inexact Rounded lnx0012 ln 2.718281828459047 -> 1.000000000000001 Inexact Rounded lnx0013 ln 10 -> 2.302585092994046 Inexact Rounded lnx0014 ln 10.5 -> 2.351375257163478 Inexact Rounded lnx0015 ln 9999 -> 9.210240366975849 Inexact Rounded lnx0016 ln 1E6 -> 13.81551055796427 Inexact Rounded lnx0017 ln 1E+9 -> 20.72326583694641 Inexact Rounded lnx0018 ln +Infinity -> Infinity -- notable cases -- negatives lnx0021 ln -1E-9 -> NaN Invalid_operation lnx0022 ln -0.0007 -> NaN Invalid_operation lnx0023 ln -0.1 -> NaN Invalid_operation lnx0024 ln -0.7 -> NaN Invalid_operation lnx0025 ln -1 -> NaN Invalid_operation lnx0026 ln -1.5 -> NaN Invalid_operation lnx0027 ln -2 -> NaN Invalid_operation lnx0029 ln -10.5 -> NaN Invalid_operation lnx0028 ln -9999 -> NaN Invalid_operation lnx0030 ln -2.718281828459045 -> NaN Invalid_operation lnx0031 ln -2.718281828459046 -> NaN Invalid_operation lnx0032 ln -0 -> -Infinity lnx0033 ln -0E+17 -> -Infinity lnx0034 ln -0E-17 -> -Infinity -- other zeros lnx0041 ln 0 -> -Infinity lnx0042 ln 0E+17 -> -Infinity lnx0043 ln 0E-17 -> -Infinity -- infinities lnx0045 ln -Infinity -> NaN Invalid_operation lnx0046 ln +Infinity -> Infinity -- ones lnx0050 ln 1 -> 0 lnx0051 ln 1.0 -> 0 lnx0052 ln 1.000000000000000 -> 0 lnx0053 ln 1.000000000000000000 -> 0 -- lower precision basics Precision: 7 lnx0101 ln 0 -> -Infinity lnx0102 ln 1E-9 -> -20.72327 Inexact Rounded lnx0103 ln 0.0007 -> -7.264430 Inexact Rounded lnx0104 ln 0.1 -> -2.302585 Inexact Rounded lnx0105 ln 0.7 -> -0.3566749 Inexact Rounded lnx0106 ln 1 -> 0 lnx0107 ln 1.5 -> 0.4054651 Inexact Rounded lnx0108 ln 2 -> 0.6931472 Inexact Rounded lnx0109 ln 2.718281828459045 -> 1.000000 Inexact Rounded lnx0110 ln 2.718281828459046 -> 1.000000 Inexact Rounded lnx0111 ln 2.718281828459047 -> 1.000000 Inexact Rounded lnx0112 ln 10 -> 2.302585 Inexact Rounded lnx0113 ln 10.5 -> 2.351375 Inexact Rounded lnx0114 ln 9999 -> 9.210240 Inexact Rounded lnx0115 ln 1E6 -> 13.81551 Inexact Rounded lnx0116 ln 1E+9 -> 20.72327 Inexact Rounded lnx0117 ln +Infinity -> Infinity Precision: 2 lnx0121 ln 0 -> -Infinity lnx0122 ln 1E-9 -> -21 Inexact Rounded lnx0123 ln 0.0007 -> -7.3 Inexact Rounded lnx0124 ln 0.1 -> -2.3 Inexact Rounded lnx0125 ln 0.7 -> -0.36 Inexact Rounded lnx0126 ln 1 -> 0 lnx0127 ln 1.5 -> 0.41 Inexact Rounded lnx0128 ln 2 -> 0.69 Inexact Rounded lnx0129 ln 2.718281828459045 -> 1.0 Inexact Rounded lnx0130 ln 2.718281828459046 -> 1.0 Inexact Rounded lnx0131 ln 2.718281828459047 -> 1.0 Inexact Rounded lnx0132 ln 10 -> 2.3 Inexact Rounded lnx0133 ln 10.5 -> 2.4 Inexact Rounded lnx0134 ln 9999 -> 9.2 Inexact Rounded lnx0135 ln 1E6 -> 14 Inexact Rounded lnx0136 ln 1E+9 -> 21 Inexact Rounded lnx0137 ln +Infinity -> Infinity Precision: 1 lnx0141 ln 0 -> -Infinity lnx0142 ln 1E-9 -> -2E+1 Inexact Rounded lnx0143 ln 0.0007 -> -7 Inexact Rounded lnx0144 ln 0.1 -> -2 Inexact Rounded lnx0145 ln 0.7 -> -0.4 Inexact Rounded lnx0146 ln 1 -> 0 lnx0147 ln 1.5 -> 0.4 Inexact Rounded lnx0148 ln 2 -> 0.7 Inexact Rounded lnx0149 ln 2.718281828459045 -> 1 Inexact Rounded lnx0150 ln 2.718281828459046 -> 1 Inexact Rounded lnx0151 ln 2.718281828459047 -> 1 Inexact Rounded lnx0152 ln 10 -> 2 Inexact Rounded lnx0153 ln 10.5 -> 2 Inexact Rounded lnx0154 ln 9999 -> 9 Inexact Rounded lnx0155 ln 1E6 -> 1E+1 Inexact Rounded lnx0156 ln 1E+9 -> 2E+1 Inexact Rounded lnx0157 ln +Infinity -> Infinity -- group low-precision ln(1)s: precision: 1 lnx0161 ln 1 -> 0 precision: 2 lnx0162 ln 1 -> 0 precision: 3 lnx0163 ln 1 -> 0 precision: 4 lnx0164 ln 1 -> 0 precision: 5 lnx0165 ln 1 -> 0 precision: 6 lnx0166 ln 1 -> 0 precision: 7 lnx0167 ln 1 -> 0 precision: 8 lnx0168 ln 1 -> 0 -- edge-test ln(2) and ln(10) in case of lookasides precision: 45 lnx201 ln 2 -> 0.693147180559945309417232121458176568075500134 Inexact Rounded lnx202 ln 10 -> 2.30258509299404568401799145468436420760110149 Inexact Rounded precision: 44 lnx203 ln 2 -> 0.69314718055994530941723212145817656807550013 Inexact Rounded lnx204 ln 10 -> 2.3025850929940456840179914546843642076011015 Inexact Rounded precision: 43 lnx205 ln 2 -> 0.6931471805599453094172321214581765680755001 Inexact Rounded lnx206 ln 10 -> 2.302585092994045684017991454684364207601101 Inexact Rounded precision: 42 lnx207 ln 2 -> 0.693147180559945309417232121458176568075500 Inexact Rounded lnx208 ln 10 -> 2.30258509299404568401799145468436420760110 Inexact Rounded precision: 41 lnx209 ln 2 -> 0.69314718055994530941723212145817656807550 Inexact Rounded lnx210 ln 10 -> 2.3025850929940456840179914546843642076011 Inexact Rounded precision: 40 lnx211 ln 2 -> 0.6931471805599453094172321214581765680755 Inexact Rounded lnx212 ln 10 -> 2.302585092994045684017991454684364207601 Inexact Rounded precision: 39 lnx213 ln 2 -> 0.693147180559945309417232121458176568076 Inexact Rounded lnx214 ln 10 -> 2.30258509299404568401799145468436420760 Inexact Rounded precision: 38 lnx215 ln 2 -> 0.69314718055994530941723212145817656808 Inexact Rounded lnx216 ln 10 -> 2.3025850929940456840179914546843642076 Inexact Rounded precision: 37 lnx217 ln 2 -> 0.6931471805599453094172321214581765681 Inexact Rounded lnx218 ln 10 -> 2.302585092994045684017991454684364208 Inexact Rounded precision: 36 lnx219 ln 2 -> 0.693147180559945309417232121458176568 Inexact Rounded lnx220 ln 10 -> 2.30258509299404568401799145468436421 Inexact Rounded precision: 35 lnx221 ln 2 -> 0.69314718055994530941723212145817657 Inexact Rounded lnx222 ln 10 -> 2.3025850929940456840179914546843642 Inexact Rounded precision: 34 lnx223 ln 2 -> 0.6931471805599453094172321214581766 Inexact Rounded lnx224 ln 10 -> 2.302585092994045684017991454684364 Inexact Rounded precision: 33 lnx225 ln 2 -> 0.693147180559945309417232121458177 Inexact Rounded lnx226 ln 10 -> 2.30258509299404568401799145468436 Inexact Rounded precision: 32 lnx227 ln 2 -> 0.69314718055994530941723212145818 Inexact Rounded lnx228 ln 10 -> 2.3025850929940456840179914546844 Inexact Rounded precision: 31 lnx229 ln 2 -> 0.6931471805599453094172321214582 Inexact Rounded lnx230 ln 10 -> 2.302585092994045684017991454684 Inexact Rounded precision: 30 lnx231 ln 2 -> 0.693147180559945309417232121458 Inexact Rounded lnx232 ln 10 -> 2.30258509299404568401799145468 Inexact Rounded -- extreme input range values maxExponent: 384 minExponent: -383 Precision: 16 lnx0901 ln 1e-400 -> -921.0340371976183 Inexact Rounded lnx0902 ln 1e+400 -> 921.0340371976183 Inexact Rounded lnx0903 ln 1e-999999 -> -2302582.790408953 Inexact Rounded lnx0904 ln 1e+999999 -> 2302582.790408953 Inexact Rounded lnx0905 ln 1e-1000013 -> -2302615.026600255 Inexact Rounded lnx0906 ln 2e-1000013 -> -2302614.333453074 Inexact Rounded lnx0910 ln 9.999999e+999999 -> 2302585.092993946 Inexact Rounded lnx0911 ln 9.9999999e+999999 -> 2302585.092994036 Inexact Rounded lnx0912 ln 9.99999999e+999999 -> 2302585.092994045 Inexact Rounded lnx0913 ln 9.999999999e+999999 -> 2302585.092994046 Inexact Rounded lnx0914 ln 9.999999999999e+999999 -> 2302585.092994046 Inexact Rounded lnx0915 ln 9.999999999999999e+999999 -> 2302585.092994046 Inexact Rounded lnx0916 ln 9.999999999999999999999999e+999999 -> 2302585.092994046 Inexact Rounded -- randoms -- P=50, within 0-999 Precision: 50 maxExponent: 384 minExponent: -383 lnx1501 ln 0.00098800906574486388604608477869812518857023768951 -> -6.9198186844033787995945147836955586009548513043689 Inexact Rounded lnx1502 ln 158.15866624664623070184595045304145949900714987827 -> 5.0635987458895647454907806507503825602758392287684 Inexact Rounded lnx1503 ln 0.00565661412059571925040285814021799775249288309321 -> -5.1749297776760632102047540300491550931651318975237 Inexact Rounded lnx1504 ln 0.00000006914232532620489602008402091666547903180607 -> -16.487098770877825308138976818688771638172333034347 Inexact Rounded lnx1505 ln 0.00025380374621297657504661540749355251231770070723 -> -8.2789492423005003205242162741569033124260321954589 Inexact Rounded lnx1506 ln 83.033654063877426261108592599182418953442677554806 -> 4.4192459962647137976949249810815698465031609843669 Inexact Rounded lnx1507 ln 0.00000000416863228092481651627734668440663678118729 -> -19.295677845122141772791294599714950175284915666430 Inexact Rounded lnx1508 ln 0.00000140847873187820570181214271960511080523457669 -> -13.473000349581967189668305314384952251556809480339 Inexact Rounded lnx1509 ln 66.176106555181527101630351127583944689752069132522 -> 4.1923194696232505883666171116966137694013431504252 Inexact Rounded lnx1510 ln 0.00000000000009899043487403590900111602024562297908 -> -29.943753166877840985821508112917991506656545174163 Inexact Rounded lnx1511 ln 0.00000000000324618296721747097510453388683912733569 -> -26.453541281444586819009546418577507163362590139422 Inexact Rounded lnx1512 ln 72.646968818463546449499147579023555008392860423385 -> 4.2856116660689646882852128853423566276718230426479 Inexact Rounded lnx1513 ln 0.00000000000000066755483124635612574263153825990523 -> -34.942910142802769319262875080398852491588707172483 Inexact Rounded lnx1514 ln 61.002910447202398204114909451851111424657671911002 -> 4.1109215752843377323363182051446177066434038096529 Inexact Rounded lnx1515 ln 917.06917611331980999227893584010544542312239174774 -> 6.8211829068303114128752453661946446979787826282907 Inexact Rounded lnx1516 ln 0.00000000170823794883673083358549749078972003965194 -> -20.187803436976150477297246666771626827057191023004 Inexact Rounded lnx1517 ln 0.53731767845358224445809761315159249898566542910649 -> -0.62116577939968409211736413628236285160048357000961 Inexact Rounded lnx1518 ln 0.00000000000000008965291392882804161299758708033373 -> -36.950585970980857376081265073276303670820056916206 Inexact Rounded lnx1519 ln 0.00000000006990244916026429904498278982530170295668 -> -23.383920429244457578373523508427783144589480420753 Inexact Rounded lnx1520 ln 4.0312542977070300070506064666536478373801988540614 -> 1.3940775676592451945795752796421391871302024763305 Inexact Rounded lnx1521 ln 271.84991311551875601432518819562391699324632396423 -> 5.6052501239873862517916679747146539808077431873478 Inexact Rounded lnx1522 ln 7.4118671629373864667229445746862314443895404818689 -> 2.0030823863706344628239147639318289961917060121141 Inexact Rounded lnx1523 ln 0.00000000000002026311452625364905357321664186034258 -> -31.529974180054438792043856877314043794320951134754 Inexact Rounded lnx1524 ln 0.00000000000009563398651261756952398250624737809347 -> -29.978248130576972953141284136962670021368834792579 Inexact Rounded lnx1525 ln 0.00000000009556772669409858653026558223465197808991 -> -23.071185939748285541228206161472956661196956741186 Inexact Rounded lnx1526 ln 6.8441648298027301292342057248737326152250794026761 -> 1.9233964395801946597272589473417948024361005082908 Inexact Rounded lnx1527 ln 0.00000000000073059699884439979394945822035704264577 -> -27.944914388353724718836101828677771967128509603158 Inexact Rounded lnx1528 ln 0.00000000000000002610078280419082263138064745416787 -> -38.184566367516207885573773320135965798717120735115 Inexact Rounded lnx1529 ln 0.00000000000000000150259517166294243088546806083283 -> -41.039337946266676108538170837580051699618334928421 Inexact Rounded lnx1530 ln 0.00000000000000087919160541714580707181969708502091 -> -34.667528818827671507514319744047440696187358676848 Inexact Rounded lnx1531 ln 0.00000000000395726725120787763271849577708068584598 -> -26.255467416961357741818735787226671938678424748431 Inexact Rounded lnx1532 ln 0.00000000002014334901669366218018377213150715938355 -> -24.628146955635359035289123027319969201693737159108 Inexact Rounded lnx1533 ln 0.00000008097927101101093117753938766241442896030637 -> -16.329072628469715178637178365710373398203190937454 Inexact Rounded lnx1534 ln 0.00000000000017115834162632864392039668116243984176 -> -29.396187292434898225453626794459285157263177528034 Inexact Rounded lnx1535 ln 0.39168317593866334087305459933723864294857086105035 -> -0.93730199062757240485836637306785037368746737693029 Inexact Rounded lnx1536 ln 79.335036798971515026519630103325369729637514127617 -> 4.3736798570287828823772149735170431010616961976965 Inexact Rounded lnx1537 ln 0.00000000000000056004952129926137413602116591493625 -> -35.118506463181870020730685884333000241039028127213 Inexact Rounded lnx1538 ln 0.00000006006035907843890918832481099660639553666078 -> -16.627915795747112566532705974853114454405010472043 Inexact Rounded lnx1539 ln 0.00000000085242024937414906371333826574632450587590 -> -20.882941460268101080186482230657774997273494107221 Inexact Rounded lnx1540 ln 0.00000000000043671099499262350316173246550771951561 -> -28.459504757285639221776305968469058854558726593945 Inexact Rounded -- P=34, within 0-999 Precision: 34 lnx1201 ln 0.0086732880815927182997566810334394 -> -4.747507311920844752486938187973721 Inexact Rounded lnx1202 ln 0.0007104103693460260609792222569854 -> -7.249667769903503023005549250347695 Inexact Rounded lnx1203 ln 786.8398945385105190697541493392742 -> 6.668024790031836340471824147010546 Inexact Rounded lnx1204 ln 0.7723073620282687656895190171967399 -> -0.2583726708506850868786816238217326 Inexact Rounded lnx1205 ln 0.0061057951517197631287183938412200 -> -5.098516933918797347064454103742635 Inexact Rounded lnx1206 ln 0.6181379708184393730103917562498745 -> -0.4810435926903365087463387760350021 Inexact Rounded lnx1207 ln 09.13888261229039989110753389096760 -> 2.212538125507975574509563027696021 Inexact Rounded lnx1208 ln 802.0105417063143696497292158147174 -> 6.687121752052341737234832203350214 Inexact Rounded lnx1209 ln 778.7749710387773713523028497333058 -> 6.657722135126935472086625031413031 Inexact Rounded lnx1210 ln 0.0024457295895346502513567679390616 -> -6.013411799940245345321348290398517 Inexact Rounded lnx1211 ln 0.0000511296947872828310338864217860 -> -9.881145118237281798081573131711636 Inexact Rounded lnx1212 ln 0.0000246803508602554924938685155658 -> -10.60950314264825661825360971430218 Inexact Rounded lnx1213 ln 9.027898199253511668242977766616082 -> 2.200319582778899029786017830557293 Inexact Rounded lnx1214 ln 0.0991812396542505631850692800904188 -> -2.310806398964672258823043180400384 Inexact Rounded lnx1215 ln 0.0000000000070238810143028811223924 -> -25.68170519961636647174714538290075 Inexact Rounded lnx1216 ln 2.630101665342826494730394729313167 -> 0.9670225014664367465128243039749559 Inexact Rounded lnx1217 ln 0.0056878928594359587691526063254683 -> -5.169415422904037819736637399445096 Inexact Rounded lnx1218 ln 567.3436047121057843908106573095590 -> 6.340965124964258486463444360787970 Inexact Rounded lnx1219 ln 1.199291248124655996614605745649725 -> 0.1817307557425911805765087755675657 Inexact Rounded lnx1220 ln 25.02050448582031098696267479135557 -> 3.219695668137659139544178905459317 Inexact Rounded lnx1221 ln 0.0000000000009939597023558756961300 -> -27.63707972996537636504396558259058 Inexact Rounded lnx1222 ln 0.0000007988551670159429716506430403 -> -14.04008617542597230988198612376415 Inexact Rounded lnx1223 ln 4.681515800176129184873770605589795 -> 1.543621946415383338972124445445748 Inexact Rounded lnx1224 ln 15.95126669161103011206658749345781 -> 2.769538242479483539275986395443539 Inexact Rounded lnx1225 ln 0.0301626783922211213675457279076066 -> -3.501149933677283341023932281826341 Inexact Rounded lnx1226 ln 000.0040544064881821770528475185674 -> -5.507950967557021671647165889608324 Inexact Rounded lnx1227 ln 29.01617095935593792095913785100360 -> 3.367853293862745651888450004473297 Inexact Rounded lnx1228 ln 78.01836167344736733024804243195323 -> 4.356944205055768575987781375003992 Inexact Rounded lnx1229 ln 0.0000000096545319316965321158634893 -> -18.45583840160965814462095477365013 Inexact Rounded lnx1230 ln 97.95475237720579752770587185074428 -> 4.584505661612812742208619358214729 Inexact Rounded lnx1231 ln 528.0609262050423246402564228432371 -> 6.269211667589138113396583894315956 Inexact Rounded lnx1232 ln 0.0000002250064349732969696660452972 -> -15.30713683526963996712167701738724 Inexact Rounded lnx1233 ln 47.97063637767998658567199049725754 -> 3.870589081585660692195989854842372 Inexact Rounded lnx1234 ln 0.0005394311344541432318853513414361 -> -7.524995428393925934087126702974121 Inexact Rounded lnx1235 ln 0.0000000090973385649567471674972633 -> -18.51528393158931783447035004125791 Inexact Rounded lnx1236 ln 0.0000000000238776490227576197317977 -> -24.45807828188389561331158879207262 Inexact Rounded lnx1237 ln 0.0000236587000231921532145326218758 -> -10.65177964499823314952429277979034 Inexact Rounded lnx1238 ln 499.1277448846130709827154556125942 -> 6.212862064761427967461188083514774 Inexact Rounded lnx1239 ln 0.0000003960192300284787663712417647 -> -14.74180306619298548093697608293284 Inexact Rounded lnx1240 ln 41.08268350829477451667228892495136 -> 3.715586706887278039173584859218960 Inexact Rounded -- P=16, within 0-99 Precision: 16 lnx1101 ln 7.964875261033948 -> 2.075041282352241 Inexact Rounded lnx1102 ln 13.54527396845394 -> 2.606037701870263 Inexact Rounded lnx1103 ln 0.0008026554341331 -> -7.127585034321814 Inexact Rounded lnx1104 ln 0.0000030582233261 -> -12.69767642300625 Inexact Rounded lnx1105 ln 0.0004477497509672 -> -7.711276073210766 Inexact Rounded lnx1106 ln 7.616268622474371 -> 2.030286567675148 Inexact Rounded lnx1107 ln 51.58329925806381 -> 3.943197962309569 Inexact Rounded lnx1108 ln 0.0018197497951263 -> -6.309056262549345 Inexact Rounded lnx1109 ln 2.956282457072984 -> 1.083932552334575 Inexact Rounded lnx1110 ln 0.3843325579189906 -> -0.9562470649400558 Inexact Rounded lnx1111 ln 0.0074466329265663 -> -4.899993304919237 Inexact Rounded lnx1112 ln 0.0003372478532993 -> -7.994692428206378 Inexact Rounded lnx1113 ln 0.0084792263167809 -> -4.770136069569271 Inexact Rounded lnx1114 ln 5.926756998151102 -> 1.779477182834305 Inexact Rounded lnx1115 ln 9.025699152180897 -> 2.200075969604119 Inexact Rounded lnx1116 ln 1.910124643533526 -> 0.6471684983238183 Inexact Rounded lnx1117 ln 0.8158922711411020 -> -0.2034729533939387 Inexact Rounded lnx1118 ln 0.0067080016475322 -> -5.004454189414139 Inexact Rounded lnx1119 ln 0.0047583242092716 -> -5.347859729601094 Inexact Rounded lnx1120 ln 0.0386647411641339 -> -3.252827175263113 Inexact Rounded lnx1121 ln 0.0050226427841761 -> -5.293799032774131 Inexact Rounded lnx1122 ln 6.927937541637261 -> 1.935562155866906 Inexact Rounded lnx1123 ln 0.0000095745343513 -> -11.55640365579814 Inexact Rounded lnx1124 ln 1.602465492956538 -> 0.4715433763243936 Inexact Rounded lnx1125 ln 38.98415625087535 -> 3.663155313610213 Inexact Rounded lnx1126 ln 5.343182042276734 -> 1.675821363568112 Inexact Rounded lnx1127 ln 55.89763703245816 -> 4.023522107934110 Inexact Rounded lnx1128 ln 0.7445257810280847 -> -0.2950077988101030 Inexact Rounded lnx1129 ln 1.631407314946094 -> 0.4894430257201248 Inexact Rounded lnx1130 ln 0.0005462451932602 -> -7.512442611116852 Inexact Rounded lnx1131 ln 0.0000864173269362 -> -9.356322359017317 Inexact Rounded lnx1132 ln 5.227161719132849 -> 1.653868438439637 Inexact Rounded lnx1133 ln 60.57078466941998 -> 4.103812675662452 Inexact Rounded lnx1134 ln 0.0992864325333160 -> -2.309746348350318 Inexact Rounded lnx1135 ln 09.48564268447325 -> 2.249779359074983 Inexact Rounded lnx1136 ln 0.0036106089355634 -> -5.623878840650787 Inexact Rounded lnx1137 ln 1.805176865587172 -> 0.5906585734593707 Inexact Rounded lnx1138 ln 62.59363259642255 -> 4.136663557220559 Inexact Rounded lnx1139 ln 4.373828261137201 -> 1.475638657912000 Inexact Rounded lnx1140 ln 0.994483524148738 -> -0.005531747794938690 Inexact Rounded -- P=7, within 0-9 Precision: 7 lnx1001 ln 0.0912025 -> -2.394673 Inexact Rounded lnx1002 ln 0.9728626 -> -0.02751242 Inexact Rounded lnx1003 ln 0.3886032 -> -0.9451965 Inexact Rounded lnx1004 ln 8.798639 -> 2.174597 Inexact Rounded lnx1005 ln 2.459121 -> 0.8998040 Inexact Rounded lnx1006 ln 2.013193 -> 0.6997220 Inexact Rounded lnx1007 ln 9.064857 -> 2.204405 Inexact Rounded lnx1008 ln 5.796417 -> 1.757240 Inexact Rounded lnx1009 ln 0.1143471 -> -2.168517 Inexact Rounded lnx1010 ln 0.5341542 -> -0.6270707 Inexact Rounded lnx1011 ln 6.693781 -> 1.901179 Inexact Rounded lnx1012 ln 0.0081779 -> -4.806320 Inexact Rounded lnx1013 ln 8.313616 -> 2.117895 Inexact Rounded lnx1014 ln 3.486925 -> 1.249020 Inexact Rounded lnx1015 ln 0.1801401 -> -1.714020 Inexact Rounded lnx1016 ln 0.5227148 -> -0.6487193 Inexact Rounded lnx1017 ln 7.818111 -> 2.056443 Inexact Rounded lnx1018 ln 0.0870671 -> -2.441076 Inexact Rounded lnx1019 ln 8.153966 -> 2.098504 Inexact Rounded lnx1020 ln 2.040975 -> 0.7134276 Inexact Rounded lnx1021 ln 1.481642 -> 0.3931509 Inexact Rounded lnx1022 ln 0.2610123 -> -1.343188 Inexact Rounded lnx1023 ln 0.466723 -> -0.7620193 Inexact Rounded lnx1024 ln 0.0518756 -> -2.958907 Inexact Rounded lnx1025 ln 2.056410 -> 0.7209617 Inexact Rounded lnx1026 ln 0.181522 -> -1.706378 Inexact Rounded lnx1027 ln 0.515551 -> -0.6625190 Inexact Rounded lnx1028 ln 8.425089 -> 2.131214 Inexact Rounded lnx1029 ln 2.077091 -> 0.7309684 Inexact Rounded lnx1030 ln 6.212705 -> 1.826596 Inexact Rounded lnx1031 ln 5.729343 -> 1.745601 Inexact Rounded lnx1032 ln 4.831251 -> 1.575105 Inexact Rounded lnx1033 ln 2.029760 -> 0.7079176 Inexact Rounded lnx1034 ln 8.615060 -> 2.153512 Inexact Rounded lnx1035 ln 0.0611511 -> -2.794407 Inexact Rounded lnx1036 ln 5.195269 -> 1.647748 Inexact Rounded lnx1037 ln 9.617686 -> 2.263604 Inexact Rounded lnx1038 ln 0.0049382 -> -5.310754 Inexact Rounded lnx1039 ln 2.786840 -> 1.024908 Inexact Rounded lnx1040 ln 0.0091073 -> -4.698679 Inexact Rounded -- from here 3-digit tests are based on reverse exp tests precision: 9 rounding: half_even maxExponent: 384 minexponent: -383 lnx001 ln 0 -> -Infinity lnx002 ln 0.367879441 -> -1.00000000 Inexact Rounded lnx003 ln 1 -> 0 lnx005 ln 2.71828183 -> 1.00000000 Inexact Rounded lnx006 ln 2.00000000 -> 0.693147181 Inexact Rounded lnx007 ln +Infinity -> Infinity -- tiny edge cases precision: 7 lnx011 ln 1.105171 -> 0.1000001 Inexact Rounded lnx012 ln 1.010050 -> 0.009999835 Inexact Rounded lnx013 ln 1.000010 -> 0.000009999950 Inexact Rounded lnx014 ln 1.000001 -> 9.999995E-7 Inexact Rounded lnx015 ln 1.000000 -> 0 -- basic e=0, e=1, e=2, e=4, e>=8 cases precision: 7 lnx041 ln 2.718282 -> 1.000000 Inexact Rounded lnx042 ln 0.3678794 -> -1.000000 Inexact Rounded lnx043 ln 22026.47 -> 10.00000 Inexact Rounded lnx044 ln 0.00004539993 -> -10.00000 Inexact Rounded lnx045 ln 2.688117E+43 -> 100.0000 Inexact Rounded lnx046 ln 3.720076E-44 -> -100.0000 Inexact Rounded lnx047 ln Infinity -> Infinity lnx048 ln 0E-389 -> -Infinity -- miscellanea precision: 16 lnx055 ln 2.717658486884572E-236 -> -542.4103112874415 Inexact Rounded precision: 17 lnx056 ln 2.7176584868845721E-236 -> -542.41031128744146 Inexact Rounded precision: 18 lnx057 ln 2.71765848688457211E-236 -> -542.410311287441459 Inexact Rounded precision: 19 lnx058 ln 2.717658486884572112E-236 -> -542.4103112874414592 Inexact Rounded precision: 20 lnx059 ln 2.7176584868845721118E-236 -> -542.41031128744145917 Inexact Rounded -- inputs ending in ..500.., ..499.., ..100.., ..999.. sequences precision: 50 lnx102 ln 0.9999999100000040499998785000027 -> -9.0000000000000000000000033749953829996446124861750E-8 Inexact Rounded precision: 30 lnx103 ln 0.999999910000004049999878500003 -> -8.99999999999999999999997337499E-8 Inexact Rounded precision: 29 lnx104 ln 0.99999991000000404999987850000 -> -9.0000000000000000000002733750E-8 Inexact Rounded precision: 28 lnx105 ln 0.9999999100000040499998785000 -> -9.000000000000000000000273375E-8 Inexact Rounded precision: 27 lnx106 ln 0.999999910000004049999878500 -> -9.00000000000000000000027338E-8 Inexact Rounded precision: 26 lnx107 ln 0.99999991000000404999987850 -> -9.0000000000000000000002734E-8 Inexact Rounded precision: 25 lnx108 ln 0.9999999100000040499998785 -> -9.000000000000000000000273E-8 Inexact Rounded precision: 24 lnx109 ln 0.999999910000004049999879 -> -8.99999999999999995000027E-8 Inexact Rounded precision: 23 lnx110 ln 0.99999991000000404999988 -> -8.9999999999999998500003E-8 Inexact Rounded precision: 22 lnx111 ln 0.9999999100000040499999 -> -8.999999999999997850000E-8 Inexact Rounded precision: 21 lnx112 ln 0.999999910000004050000 -> -8.99999999999998785000E-8 Inexact Rounded precision: 20 lnx113 ln 0.99999991000000405000 -> -8.9999999999999878500E-8 Inexact Rounded precision: 19 lnx114 ln 0.9999999100000040500 -> -8.999999999999987850E-8 Inexact Rounded precision: 18 lnx115 ln 0.999999910000004050 -> -8.99999999999998785E-8 Inexact Rounded -- next may be a > 0.5ulp case; a more precise answer is: -- -8.99999999999998784999918E-8 precision: 17 lnx116 ln 0.99999991000000405 -> -8.9999999999999878E-8 Inexact Rounded precision: 16 lnx117 ln 0.9999999100000040 -> -9.000000004999988E-8 Inexact Rounded precision: 15 lnx118 ln 0.999999910000004 -> -9.00000000499999E-8 Inexact Rounded precision: 14 lnx119 ln 0.99999991000000 -> -9.0000004050000E-8 Inexact Rounded precision: 13 lnx120 ln 0.9999999100000 -> -9.000000405000E-8 Inexact Rounded precision: 12 lnx121 ln 0.999999910000 -> -9.00000040500E-8 Inexact Rounded precision: 11 lnx122 ln 0.99999991000 -> -9.0000004050E-8 Inexact Rounded precision: 10 lnx123 ln 0.9999999100 -> -9.000000405E-8 Inexact Rounded precision: 9 lnx124 ln 0.999999910 -> -9.00000041E-8 Inexact Rounded precision: 8 lnx125 ln 0.99999991 -> -9.0000004E-8 Inexact Rounded precision: 7 lnx126 ln 0.9999999 -> -1.000000E-7 Inexact Rounded precision: 16 lnx126b ln 0.9999999 -> -1.000000050000003E-7 Inexact Rounded precision: 6 lnx127 ln 0.999999 -> -0.00000100000 Inexact Rounded precision: 5 lnx128 ln 0.99999 -> -0.000010000 Inexact Rounded precision: 4 lnx129 ln 0.9999 -> -0.0001000 Inexact Rounded precision: 3 lnx130 ln 0.999 -> -0.00100 Inexact Rounded precision: 2 lnx131 ln 0.99 -> -0.010 Inexact Rounded precision: 1 lnx132 ln 0.9 -> -0.1 Inexact Rounded -- cases near 1 -- 1 2345678901234567890 precision: 20 lnx401 ln 2.7182818284589365041 -> 0.99999999999996000000 Inexact Rounded lnx402 ln 2.7182818284589636869 -> 0.99999999999997000000 Inexact Rounded lnx403 ln 2.7182818284589908697 -> 0.99999999999997999999 Inexact Rounded lnx404 ln 2.7182818284590180525 -> 0.99999999999998999998 Inexact Rounded lnx405 ln 2.7182818284590452354 -> 1.0000000000000000000 Inexact Rounded lnx406 ln 2.7182818284593170635 -> 1.0000000000001000000 Inexact Rounded lnx407 ln 2.7182818284595888917 -> 1.0000000000002000000 Inexact Rounded precision: 14 lnx411 ln 2.7182818284589 -> 0.99999999999995 Inexact Rounded lnx413 ln 2.7182818284590 -> 0.99999999999998 Inexact Rounded lnx416 ln 2.7182818284591 -> 1.0000000000000 Inexact Rounded lnx417 ln 2.7182818284592 -> 1.0000000000001 Inexact Rounded -- overflows, including some exp overprecise borderlines precision: 7 maxExponent: 384 minExponent: -383 lnx709 ln 9.999999E+384 -> 886.4953 Inexact Rounded lnx711 ln 9.999992E+384 -> 886.4953 Inexact Rounded precision: 16 lnx722 ln 9.999999999999999E+384 -> 886.4952608027076 Inexact Rounded lnx724 ln 9.999999999999917E+384 -> 886.4952608027076 Inexact Rounded lnx726 ln 9.999999999999117E+384 -> 886.4952608027075 Inexact Rounded -- and more... precision: 15 maxExponent: 999 minExponent: -999 lnx731 ln 9.99999999999999E+999 -> 2302.58509299405 Inexact Rounded -- next may be a > 0.5ulp case; a more precise answer is: -- 2302.58509299404495001799145442 lnx732 ln 9.99999999999266E+999 -> 2302.58509299404 Inexact Rounded lnx733 ln 9.99999999999265E+999 -> 2302.58509299404 Inexact Rounded lnx734 ln 9.99999999999264E+999 -> 2302.58509299404 Inexact Rounded -- subnormals and underflows for exp, including underflow-to-zero edge point precision: 7 maxExponent: 384 minExponent: -383 lnx751 ln 0E-389 -> -Infinity lnx758 ln 1.000001E-383 -> -881.8901 Inexact Rounded lnx759 ln 9.99991E-384 -> -881.8901 Inexact Rounded lnx760 ln 4.4605E-385 -> -885.0000 Inexact Rounded lnx761 ln 2.221E-386 -> -887.9999 Inexact Rounded lnx762 ln 3.01E-387 -> -889.9985 Inexact Rounded lnx763 ln 1.7E-388 -> -892.8724 Inexact Rounded lnx764 ln 1.5E-388 -> -892.9976 Inexact Rounded lnx765 ln 9E-389 -> -893.5084 Inexact Rounded lnx766 ln 1E-389 -> -895.7056 Inexact Rounded lnx774 ln 0E-389 -> -Infinity -- special values lnx820 ln Infinity -> Infinity lnx821 ln 0 -> -Infinity lnx822 ln NaN -> NaN lnx823 ln sNaN -> NaN Invalid_operation -- propagating NaNs lnx824 ln sNaN123 -> NaN123 Invalid_operation lnx825 ln -sNaN321 -> -NaN321 Invalid_operation lnx826 ln NaN456 -> NaN456 lnx827 ln -NaN654 -> -NaN654 lnx828 ln NaN1 -> NaN1 -- Invalid operations due to restrictions -- [next two probably skipped by most test harnesses] precision: 100000000 lnx901 ln 1 -> NaN Invalid_context precision: 99999999 lnx902 ln 0 -> NaN Invalid_context precision: 9 maxExponent: 1000000 minExponent: -999999 lnx903 ln 1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999999 lnx904 ln 0 -> -Infinity maxExponent: 999999 minExponent: -1000000 lnx905 ln 1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999998 lnx906 ln 0 -> -Infinity -- payload decapitate precision: 5 lnx910 ln -sNaN1234567890 -> -NaN67890 Invalid_operation -- Null test lnx900 ln # -> NaN Invalid_operation apd-3.2.1/testdata/log10.decTest000066400000000000000000000775561450022325000163460ustar00rootroot00000000000000------------------------------------------------------------------------ -- log10.decTest -- decimal logarithm in base 10 -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This emphasises the testing of notable cases, as they will often -- have unusual paths (especially the 10**n results). extended: 1 precision: 16 rounding: half_even maxExponent: 384 minexponent: -383 -- examples in specification precision: 9 logxs000 log10 0 -> -Infinity logxs001 log10 0.001 -> -3 logxs002 log10 1 -> 0 logxs003 log10 2 -> 0.301029996 Inexact Rounded logxs004 log10 10 -> 1 logxs005 log10 70 -> 1.84509804 Inexact Rounded logxs006 log10 +Infinity -> Infinity -- basics (examples in specification, etc.) precision: 16 logx0000 log10 0 -> -Infinity logx0001 log10 7E-1000 -> -999.1549019599857 Inexact Rounded logx0002 log10 1.1E-9 -> -8.958607314841775 Inexact Rounded logx0003 log10 0.0007 -> -3.154901959985743 Inexact Rounded logx0004 log10 0.11 -> -0.9586073148417750 Inexact Rounded logx0005 log10 0.7 -> -0.1549019599857432 Inexact Rounded logx0006 log10 1 -> 0 logx0007 log10 1.5 -> 0.1760912590556812 Inexact Rounded logx0008 log10 2 -> 0.3010299956639812 Inexact Rounded logx0009 log10 2.718281828459045 -> 0.4342944819032518 Inexact Rounded logx0010 log10 2.718281828459046 -> 0.4342944819032519 Inexact Rounded logx0011 log10 2.718281828459047 -> 0.4342944819032521 Inexact Rounded logx0012 log10 7 -> 0.8450980400142568 Inexact Rounded logx0013 log10 10 -> 1 logx0014 log10 10.5 -> 1.021189299069938 Inexact Rounded logx0015 log10 11 -> 1.041392685158225 Inexact Rounded logx0016 log10 70 -> 1.845098040014257 Inexact Rounded logx0017 log10 9999 -> 3.999956568380192 Inexact Rounded logx0018 log10 1.21E6 -> 6.082785370316450 Inexact Rounded logx0019 log10 1.1E+9 -> 9.041392685158225 Inexact Rounded logx0020 log10 7E+1000 -> 1000.845098040014 Inexact Rounded logx0021 log10 +Infinity -> Infinity -- notable cases -- negatives logx0031 log10 -1E-9 -> NaN Invalid_operation logx0032 log10 -0.0007 -> NaN Invalid_operation logx0033 log10 -0.1 -> NaN Invalid_operation logx0034 log10 -0.7 -> NaN Invalid_operation logx0035 log10 -1 -> NaN Invalid_operation logx0036 log10 -1.5 -> NaN Invalid_operation logx0037 log10 -2 -> NaN Invalid_operation logx0038 log10 -10.5 -> NaN Invalid_operation logx0039 log10 -10.5 -> NaN Invalid_operation logx0040 log10 -9999 -> NaN Invalid_operation logx0041 log10 -10 -> NaN Invalid_operation logx0042 log10 -0 -> -Infinity logx0043 log10 -0E+17 -> -Infinity logx0044 log10 -0E-17 -> -Infinity -- other zeros logx0051 log10 0 -> -Infinity logx0052 log10 0E+17 -> -Infinity logx0053 log10 0E-17 -> -Infinity -- infinities logx0055 log10 -Infinity -> NaN Invalid_operation logx0056 log10 +Infinity -> Infinity -- ones logx0061 log10 1 -> 0 logx0062 log10 1.0 -> 0 logx0063 log10 1.000000000000000 -> 0 logx0064 log10 1.000000000000000000 -> 0 -- notable cases -- exact powers of 10 logx1100 log10 1 -> 0 logx1101 log10 10 -> 1 logx1102 log10 100 -> 2 logx1103 log10 1000 -> 3 logx1104 log10 10000 -> 4 logx1105 log10 100000 -> 5 logx1106 log10 1000000 -> 6 logx1107 log10 10000000 -> 7 logx1108 log10 100000000 -> 8 logx1109 log10 1000000000 -> 9 logx1110 log10 10000000000 -> 10 logx1111 log10 100000000000 -> 11 logx1112 log10 1000000000000 -> 12 logx1113 log10 0.00000000001 -> -11 logx1114 log10 0.0000000001 -> -10 logx1115 log10 0.000000001 -> -9 logx1116 log10 0.00000001 -> -8 logx1117 log10 0.0000001 -> -7 logx1118 log10 0.000001 -> -6 logx1119 log10 0.00001 -> -5 logx1120 log10 0.0001 -> -4 logx1121 log10 0.001 -> -3 logx1122 log10 0.01 -> -2 logx1123 log10 0.1 -> -1 logx1124 log10 1E-99 -> -99 logx1125 log10 1E-100 -> -100 logx1126 log10 1E-383 -> -383 -- check normally exact cases round properly precision: 1 logx1141 log10 10000000000 -> 1E+1 Rounded logx1142 log10 1000000000000 -> 1E+1 Inexact Rounded logx1143 log10 1E+100 -> 1E+2 Rounded logx1144 log10 1E+123 -> 1E+2 Inexact Rounded logx1145 log10 1E+126 -> 1E+2 Inexact Rounded logx1146 log10 1E+916 -> 9E+2 Inexact Rounded logx1147 log10 1E+999 -> 1E+3 Inexact Rounded precision: 2 logx1151 log10 10000000000 -> 10 logx1152 log10 1000000000000 -> 12 logx1153 log10 1E+100 -> 1.0E+2 Rounded logx1154 log10 1E+123 -> 1.2E+2 Inexact Rounded logx1155 log10 1E+126 -> 1.3E+2 Inexact Rounded logx1156 log10 1E+916 -> 9.2E+2 Inexact Rounded logx1157 log10 1E+999 -> 1.0E+3 Inexact Rounded -- some half-way point rounds, other cases, and negatives logx1158 log10 1E+125 -> 1.2E+2 Inexact Rounded logx1159 log10 1E+135 -> 1.4E+2 Inexact Rounded logx1160 log10 1E+129 -> 1.3E+2 Inexact Rounded logx1161 log10 1E+131 -> 1.3E+2 Inexact Rounded logx1162 log10 1E-123 -> -1.2E+2 Inexact Rounded logx1163 log10 1E-126 -> -1.3E+2 Inexact Rounded logx1164 log10 1E-916 -> -9.2E+2 Inexact Rounded logx1165 log10 1E-999 -> -1.0E+3 Inexact Rounded logx1166 log10 1E-125 -> -1.2E+2 Inexact Rounded logx1167 log10 1E-135 -> -1.4E+2 Inexact Rounded logx1168 log10 1E-129 -> -1.3E+2 Inexact Rounded logx1169 log10 1E-131 -> -1.3E+2 Inexact Rounded precision: 3 logx1171 log10 10000000000 -> 10 logx1172 log10 1000000000000 -> 12 logx1173 log10 1E+100 -> 100 logx1174 log10 1E+123 -> 123 logx1175 log10 1E+126 -> 126 logx1176 log10 1E+916 -> 916 logx1177 log10 1E+999 -> 999 -- log10(2) .. tests both ln(2) and ln(10) constants, too precision: 50 logx1201 log10 2 -> 0.30102999566398119521373889472449302676818988146211 Inexact Rounded logx1202 log10 2.000 -> 0.30102999566398119521373889472449302676818988146211 Inexact Rounded logx1203 log10 0.2E1 -> 0.30102999566398119521373889472449302676818988146211 Inexact Rounded precision: 49 logx1204 log10 2 -> 0.3010299956639811952137388947244930267681898814621 Inexact Rounded precision: 48 logx1205 log10 2 -> 0.301029995663981195213738894724493026768189881462 Inexact Rounded precision: 47 logx1206 log10 2 -> 0.30102999566398119521373889472449302676818988146 Inexact Rounded precision: 46 logx1207 log10 2 -> 0.3010299956639811952137388947244930267681898815 Inexact Rounded precision: 45 logx1208 log10 2 -> 0.301029995663981195213738894724493026768189881 Inexact Rounded precision: 44 logx1209 log10 2 -> 0.30102999566398119521373889472449302676818988 Inexact Rounded precision: 43 logx1210 log10 2 -> 0.3010299956639811952137388947244930267681899 Inexact Rounded precision: 42 logx1211 log10 2 -> 0.301029995663981195213738894724493026768190 Inexact Rounded precision: 41 logx1212 log10 2 -> 0.30102999566398119521373889472449302676819 Inexact Rounded precision: 40 logx1213 log10 2 -> 0.3010299956639811952137388947244930267682 Inexact Rounded precision: 39 logx1214 log10 2 -> 0.301029995663981195213738894724493026768 Inexact Rounded precision: 38 logx1215 log10 2 -> 0.30102999566398119521373889472449302677 Inexact Rounded precision: 37 logx1216 log10 2 -> 0.3010299956639811952137388947244930268 Inexact Rounded precision: 36 logx1217 log10 2 -> 0.301029995663981195213738894724493027 Inexact Rounded precision: 35 logx1218 log10 2 -> 0.30102999566398119521373889472449303 Inexact Rounded precision: 34 logx1219 log10 2 -> 0.3010299956639811952137388947244930 Inexact Rounded precision: 33 logx1220 log10 2 -> 0.301029995663981195213738894724493 Inexact Rounded precision: 32 logx1221 log10 2 -> 0.30102999566398119521373889472449 Inexact Rounded precision: 31 logx1222 log10 2 -> 0.3010299956639811952137388947245 Inexact Rounded precision: 30 logx1223 log10 2 -> 0.301029995663981195213738894724 Inexact Rounded precision: 29 logx1224 log10 2 -> 0.30102999566398119521373889472 Inexact Rounded precision: 28 logx1225 log10 2 -> 0.3010299956639811952137388947 Inexact Rounded precision: 27 logx1226 log10 2 -> 0.301029995663981195213738895 Inexact Rounded precision: 26 logx1227 log10 2 -> 0.30102999566398119521373889 Inexact Rounded precision: 25 logx1228 log10 2 -> 0.3010299956639811952137389 Inexact Rounded precision: 24 logx1229 log10 2 -> 0.301029995663981195213739 Inexact Rounded precision: 23 logx1230 log10 2 -> 0.30102999566398119521374 Inexact Rounded precision: 22 logx1231 log10 2 -> 0.3010299956639811952137 Inexact Rounded precision: 21 logx1232 log10 2 -> 0.301029995663981195214 Inexact Rounded precision: 20 logx1233 log10 2 -> 0.30102999566398119521 Inexact Rounded precision: 19 logx1234 log10 2 -> 0.3010299956639811952 Inexact Rounded precision: 18 logx1235 log10 2 -> 0.301029995663981195 Inexact Rounded precision: 17 logx1236 log10 2 -> 0.30102999566398120 Inexact Rounded precision: 16 logx1237 log10 2 -> 0.3010299956639812 Inexact Rounded precision: 15 logx1238 log10 2 -> 0.301029995663981 Inexact Rounded precision: 14 logx1239 log10 2 -> 0.30102999566398 Inexact Rounded precision: 13 logx1240 log10 2 -> 0.3010299956640 Inexact Rounded precision: 12 logx1241 log10 2 -> 0.301029995664 Inexact Rounded precision: 11 logx1242 log10 2 -> 0.30102999566 Inexact Rounded precision: 10 logx1243 log10 2 -> 0.3010299957 Inexact Rounded precision: 9 logx1244 log10 2 -> 0.301029996 Inexact Rounded precision: 8 logx1245 log10 2 -> 0.30103000 Inexact Rounded precision: 7 logx1246 log10 2 -> 0.3010300 Inexact Rounded precision: 6 logx1247 log10 2 -> 0.301030 Inexact Rounded precision: 5 logx1248 log10 2 -> 0.30103 Inexact Rounded precision: 4 logx1249 log10 2 -> 0.3010 Inexact Rounded precision: 3 logx1250 log10 2 -> 0.301 Inexact Rounded precision: 2 logx1251 log10 2 -> 0.30 Inexact Rounded precision: 1 logx1252 log10 2 -> 0.3 Inexact Rounded maxExponent: 384 minExponent: -383 precision: 16 rounding: half_even -- More close-to-e, etc., tests precision: 34 logx1301 log10 2.718281828459045235360287471352661 -> 0.4342944819032518276511289189166048 Inexact Rounded logx1302 log10 2.718281828459045235360287471352662 -> 0.4342944819032518276511289189166050 Inexact Rounded logx1303 log10 2.718281828459045235360287471352663 -> 0.4342944819032518276511289189166052 Inexact Rounded logx1304 log10 0.99999999999999999999999999999999 -> -4.342944819032518276511289189166073E-33 Inexact Rounded logx1305 log10 0.999999999999999999999999999999999 -> -4.342944819032518276511289189166053E-34 Inexact Rounded logx1306 log10 0.9999999999999999999999999999999999 -> -4.342944819032518276511289189166051E-35 Inexact Rounded logx1307 log10 1.000000000000000000000000000000000 -> 0 logx1308 log10 1.0000000000000000000000000000000001 -> 4.342944819032518276511289189166051E-35 Inexact Rounded logx1309 log10 1.000000000000000000000000000000001 -> 4.342944819032518276511289189166049E-34 Inexact Rounded logx1310 log10 1.00000000000000000000000000000001 -> 4.342944819032518276511289189166029E-33 Inexact Rounded -- lower p precision: 7 logx1320 log10 0.999999 -> -4.342947E-7 Inexact Rounded logx1321 log10 0.9999999 -> -4.342945E-8 Inexact Rounded logx1322 log10 0.99999999 -> -4.342945E-9 Inexact Rounded logx1323 log10 0.999999999 -> -4.342945E-10 Inexact Rounded logx1324 log10 1.00000000 -> 0 logx1325 log10 1.00000001 -> 4.342945E-9 Inexact Rounded logx1326 log10 1.0000001 -> 4.342945E-8 Inexact Rounded logx1327 log10 1.000001 -> 4.342943E-7 Inexact Rounded -- near 10^3 precision: 9 logx1331 log10 999.9999998 -> 3.00000000 Inexact Rounded logx1332 log10 999.9999999 -> 3.00000000 Inexact Rounded logx1333 log10 1000.000000 -> 3 logx1334 log10 1000.000001 -> 3.00000000 Inexact Rounded logx1335 log10 1000.000002 -> 3.00000000 Inexact Rounded precision: 16 logx1341 log10 999.9999998 -> 2.999999999913141 Inexact Rounded logx1342 log10 999.9999999 -> 2.999999999956571 Inexact Rounded logx1343 log10 1000.000000 -> 3 logx1344 log10 1000.000001 -> 3.000000000434294 Inexact Rounded logx1345 log10 1000.000002 -> 3.000000000868589 Inexact Rounded -- suggestions from Ilan Nehama logx1400 log10 10E-3 -> -2 logx1401 log10 10E-2 -> -1 logx1402 log10 100E-2 -> 0 logx1403 log10 1000E-2 -> 1 logx1404 log10 10000E-2 -> 2 logx1405 log10 10E-1 -> 0 logx1406 log10 100E-1 -> 1 logx1407 log10 1000E-1 -> 2 logx1408 log10 10000E-1 -> 3 logx1409 log10 10E0 -> 1 logx1410 log10 100E0 -> 2 logx1411 log10 1000E0 -> 3 logx1412 log10 10000E0 -> 4 logx1413 log10 10E1 -> 2 logx1414 log10 100E1 -> 3 logx1415 log10 1000E1 -> 4 logx1416 log10 10000E1 -> 5 logx1417 log10 10E2 -> 3 logx1418 log10 100E2 -> 4 logx1419 log10 1000E2 -> 5 logx1420 log10 10000E2 -> 6 -- Randoms -- P=50, within 0-9999 Precision: 50 logx2501 log10 0.00035448001667968141775891246991912655961163345904 -> -3.4504082425411775290864053318247274944685586188505 Inexact Rounded logx2502 log10 70.636455726424311228255338637935330826995136597644 -> 1.8490288998408492045793070255302335558140975719247 Inexact Rounded logx2503 log10 0.00000000000000233550362473821889060812804063040169 -> -14.631619454343834858023578299142866557717904223667 Inexact Rounded logx2504 log10 97.783628621523244679901260358286898958832135433764 -> 1.9902661493224219517897657964362571690592734407330 Inexact Rounded logx2505 log10 0062.2377135315858392802612812022807838599572017342 -> 1.7940536293085066199287632725026837018486533544141 Inexact Rounded logx2506 log10 6.3767634652071053619977602804724129652981747879532 -> 0.80460030789825961615100163576080761326857374098644 Inexact Rounded logx2507 log10 63.297088981313278529306533814195068850532666658798 -> 1.8013837373724427092417170149098614410849353839673 Inexact Rounded logx2508 log10 0.00000077239693316881797717820110898167721602299187 -> -6.1121594592718550613773886241951966264826760310047 Inexact Rounded logx2509 log10 0.00000003953580359780185534830572461922527831395002 -> -7.4030094293833847136252547069905477213541787177561 Inexact Rounded logx2510 log10 754.62905817369989169188998111527272688791544577204 -> 2.8777335243761300047758534304371912099958057545416 Inexact Rounded logx2511 log10 0.00000048360378410241428936607147056283282849158312 -> -6.3155103095309353457604038397980091650760346334512 Inexact Rounded logx2512 log10 0.00007509037583645612577196104591672080542932166089 -> -4.1244157219700166314012344705538088030592896111026 Inexact Rounded logx2513 log10 0.00000000000705475944638915053419839063567898092064 -> -11.151517790256466048553810002525868198178167950377 Inexact Rounded logx2514 log10 9.6210300460497657917445410947099633479609165120661 -> 0.98322157093260978206633922877716078683518617768411 Inexact Rounded logx2515 log10 0.00000000050150361386555527496607245976120864985611 -> -9.2997259330798261040411086835563234390934934629340 Inexact Rounded logx2516 log10 098.24754029731994125797723545333677604490074810751 -> 1.9923216862874337077795278629351060819105679670633 Inexact Rounded logx2517 log10 7.5091998150046994320441463854301624742491015752980 -> 0.87559366078005924080766469158763499725414024128781 Inexact Rounded logx2518 log10 0.00000000000079540571273330075193668596942268542425 -> -12.099411294165176028817305108475326325006250936963 Inexact Rounded logx2519 log10 0.00000042395034799555215782907515074134154915491701 -> -6.3726850039125381134069450802108893075604464135297 Inexact Rounded logx2520 log10 56.683376304674355481905023145238799909301732694982 -> 1.7534557107853480435703421826077606250636580091754 Inexact Rounded logx2521 log10 48.734033811444195070807606721517169810438049581227 -> 1.6878323602741065190942654710049433808208291564049 Inexact Rounded logx2522 log10 0.00074830310930046865009851706989430228561880221063 -> -3.1259224502209974082223667712016445572431791920618 Inexact Rounded logx2523 log10 36.677348885111593384020836720396262497122708598359 -> 1.5643979364260796086754530282302605477567469395425 Inexact Rounded logx2524 log10 0.00000000000000004495678560480432858812419145833744 -> -16.347204748239740510014320630363244015916029619561 Inexact Rounded logx2525 log10 9509.5854013650642799374159131940108748594774307104 -> 3.9781615829916326741100166519726824430945406302661 Inexact Rounded logx2526 log10 0.07834891268689177014044454793608715276615743819097 -> -1.1059670262197643147805517398621288897669876996348 Inexact Rounded logx2527 log10 0.00000029584529880706128444454688454999032801904794 -> -6.5289353275814043710076526920566721570375026917206 Inexact Rounded logx2528 log10 3.0713496544497618098794332787772186176981011904294 -> 0.48732926103896828546424341029492468100431414072994 Inexact Rounded logx2529 log10 352.66392670788816474407442785460803833927136413943 -> 2.5473610388199562714709836398243933320284077008314 Inexact Rounded logx2530 log10 0.00304743125181876267210516527361742185617091801650 -> -2.5160660830163981967774124745311497447050056400207 Inexact Rounded logx2531 log10 0.00000076120535894952136499250364604538117729437183 -> -6.1184981629047051532448413863950776496652483019415 Inexact Rounded logx2532 log10 769.88795978534353052965286195053735007473187735815 -> 2.8864275277862652709986498581064117950288798222100 Inexact Rounded logx2533 log10 0.00000000000000041297494808612226304619570016336188 -> -15.384076292745415917510668454361868659468669804710 Inexact Rounded logx2534 log10 860.88864595714426940247940960258558876903741966974 -> 2.9349469800554277915920278090647283233440859155176 Inexact Rounded logx2535 log10 5839.0328812994787235900178587371051096898683972444 -> 3.7663409208972392569269125539438874737147906238543 Inexact Rounded logx2536 log10 0.00000028532710151284840471670497112821201598377841 -> -6.5446569753514027675878879843238065488490618159490 Inexact Rounded logx2537 log10 0.00000000000000009734490059931638483445631835651581 -> -16.011686794011271135978633880864278692254243106931 Inexact Rounded logx2538 log10 5.8610949526439529489252302463450302981511714144330 -> 0.76797875722452549281028552067645732490929361952278 Inexact Rounded logx2539 log10 6.6282432221115923372151148990137179611977576327206 -> 0.82139843639227213211012044000785757267155736071361 Inexact Rounded logx2540 log10 0.00000000001994071862386846626954819923923344413454 -> -10.700259194632339980266559224447212260115021637626 Inexact Rounded -- P=34, within 0-9999 Precision: 34 logx2201 log10 1.522513203889714179088327328864183 -> 0.1825610677098896250496651330492109 Inexact Rounded logx2202 log10 0.171123774769717316154080888930404 -> -0.7666896483548462582461898092764408 Inexact Rounded logx2203 log10 0.0000000997467236251714283104963838 -> -7.001101360652518274271569010312115 Inexact Rounded logx2204 log10 0.0008856103624122479769647543468633 -> -3.052757310476070891830490327138190 Inexact Rounded logx2205 log10 1.938274868738032930709498221236758 -> 0.2874153648259449520201536171714594 Inexact Rounded logx2206 log10 479.5667847823826713082613445010097 -> 2.680849095850361068709165157286435 Inexact Rounded logx2207 log10 8856.136599178820202141823157336804 -> 3.947244306584767101480454261950559 Inexact Rounded logx2208 log10 0.0000911026318801903982642871344858 -> -4.040469076434979398438617464033826 Inexact Rounded logx2209 log10 0.0000000000017271112650427414732630 -> -11.76267968314038748995178212654921 Inexact Rounded logx2210 log10 6.962605370078885647639503548229695 -> 0.8427717807200322352686396925992250 Inexact Rounded logx2211 log10 0.3354804428992793132855923541692781 -> -0.4743327923012159170967636070844834 Inexact Rounded logx2212 log10 2.079864257474859008252165836663504 -> 0.3180349916198059046812506741388856 Inexact Rounded logx2213 log10 2805.479529292939499220276986621988 -> 3.448007104139974344565978780624744 Inexact Rounded logx2214 log10 66.45731133034187374557028537213949 -> 1.822542767005644041661520936223086 Inexact Rounded logx2215 log10 0.0000001206521261762681738274822835 -> -6.918465020390216969561494755767318 Inexact Rounded logx2216 log10 0.0000000001884891916264401160472381 -> -9.724713548119065386091933007528633 Inexact Rounded logx2217 log10 0.0000015467279551726326581314582759 -> -5.810586065070435383755759514608738 Inexact Rounded logx2218 log10 0.0090776316728068586744633914135952 -> -2.042027442843745884503280954390114 Inexact Rounded logx2219 log10 0.0000000000024541106528713393740030 -> -11.61010585935635713090119156069479 Inexact Rounded logx2220 log10 14.12936879385863410081087750645856 -> 1.150122760895466989841057385742662 Inexact Rounded logx2221 log10 0.0000036912481831392922922647231392 -> -5.432826753789892283556211380824203 Inexact Rounded logx2222 log10 0.0000000004067477525420424270138734 -> -9.390674838050073122857868012475060 Inexact Rounded logx2223 log10 7080.122562705399744969319589806194 -> 3.850040775747103318724330047546916 Inexact Rounded logx2224 log10 261.3491411363679209175524790255725 -> 2.417221077227536319655699517530855 Inexact Rounded logx2225 log10 003.9945581449915240094728380041494 -> 0.6014687471531988260823066997845691 Inexact Rounded logx2226 log10 0.0000000000583549164588495206767840 -> -10.23392254834182677023231713519341 Inexact Rounded logx2227 log10 9567.961832607240278342761088487484 -> 3.980819434211107631569386147016368 Inexact Rounded logx2228 log10 06.26592979160342972777219828867033 -> 0.7969855243966221408595024012574729 Inexact Rounded logx2229 log10 0.0000000000589847046598067273287319 -> -10.22926059078206218717755253582907 Inexact Rounded logx2230 log10 567.9388648235589204769442863724997 -> 2.754301589058313576472380262907638 Inexact Rounded logx2231 log10 039.7790325480037778918162264883415 -> 1.599654216592019199639285308997886 Inexact Rounded logx2232 log10 0.0000000005123951921894162149817207 -> -9.290394953898862694847327137242690 Inexact Rounded logx2233 log10 0.0000000000038500999723636904276723 -> -11.41452799337924056186867324854691 Inexact Rounded logx2234 log10 0.0006726500658977759825616537935864 -> -3.172210810922768725687671849421792 Inexact Rounded logx2235 log10 260.2400250475967528429943779126507 -> 2.415374092073799204236801383070064 Inexact Rounded logx2236 log10 0.0000000006101942339385102585042548 -> -9.214531900562046557191261226632509 Inexact Rounded logx2237 log10 0.0000000010846867501382746760066557 -> -8.964695664883282406359874242387236 Inexact Rounded logx2238 log10 60.24078375568814769010333711509928 -> 1.779890613567084253168373266648922 Inexact Rounded logx2239 log10 0.0012058738711757669337600252986093 -> -2.918698115012605915753728220896010 Inexact Rounded logx2240 log10 230.9450930197841600611503095185600 -> 2.363508739056822846742942599628966 Inexact Rounded -- P=16, within 0-999 Precision: 16 logx2101 log10 0.0072067119605184 -> -2.142262835573038 Inexact Rounded logx2102 log10 503.6828482226624 -> 2.702157162195652 Inexact Rounded logx2103 log10 64.96074447821815 -> 1.812650993464174 Inexact Rounded logx2104 log10 48.75408597467246 -> 1.688011018842600 Inexact Rounded logx2105 log10 0.0329009839269587 -> -1.482791113975280 Inexact Rounded logx2106 log10 223.5320415060633 -> 2.349339784523410 Inexact Rounded logx2107 log10 73.12765002292194 -> 1.864081617476268 Inexact Rounded logx2108 log10 487.3749378358509 -> 2.687863192802252 Inexact Rounded logx2109 log10 0.0000019671987621 -> -5.706151757557926 Inexact Rounded logx2110 log10 0.0570680660609784 -> -1.243606844697873 Inexact Rounded logx2111 log10 33.10311638788998 -> 1.519868880976773 Inexact Rounded logx2112 log10 0.0687382699187077 -> -1.162801402868185 Inexact Rounded logx2113 log10 258.9416193626484 -> 2.413201859654145 Inexact Rounded logx2114 log10 0.0005306100136736 -> -3.275224558269725 Inexact Rounded logx2115 log10 65.78490393408572 -> 1.818126244825109 Inexact Rounded logx2116 log10 504.2328842073510 -> 2.702631165346958 Inexact Rounded logx2117 log10 9.417432755815027 -> 0.9739325278524503 Inexact Rounded logx2118 log10 006.7054835355498 -> 0.8264301004947640 Inexact Rounded logx2119 log10 0.0917012272363915 -> -1.037624852133399 Inexact Rounded logx2120 log10 5.959404385244921 -> 0.7752028561953401 Inexact Rounded logx2121 log10 0.0001209759148486 -> -3.917301084968903 Inexact Rounded logx2122 log10 0.0004706112139838 -> -3.327337728428039 Inexact Rounded logx2123 log10 0.0069700457377046 -> -2.156764372035771 Inexact Rounded logx2124 log10 0.5155584569852619 -> -0.2877220847805025 Inexact Rounded logx2125 log10 88.06005885607414 -> 1.944778971389913 Inexact Rounded logx2126 log10 0.0448240038219866 -> -1.348489353509709 Inexact Rounded logx2127 log10 3.419622484059565 -> 0.5339781639101145 Inexact Rounded logx2128 log10 5.171123353858721 -> 0.7135848977142854 Inexact Rounded logx2129 log10 0.0002133188319807 -> -3.670970802945872 Inexact Rounded logx2130 log10 46.21086703136966 -> 1.664744117045149 Inexact Rounded logx2131 log10 0.0000631053714415 -> -4.199933672639880 Inexact Rounded logx2132 log10 78.66019196870698 -> 1.895755001962469 Inexact Rounded logx2133 log10 0.0007152278351188 -> -3.145555592082297 Inexact Rounded logx2134 log10 45.52509819928536 -> 1.658250891256892 Inexact Rounded logx2135 log10 0.0000703227795740 -> -4.152903971697183 Inexact Rounded logx2136 log10 26.24438641426669 -> 1.419036423550599 Inexact Rounded logx2137 log10 0.0000044654829535 -> -5.350131564166817 Inexact Rounded logx2138 log10 0.7360702733062529 -> -0.1330807211893611 Inexact Rounded logx2139 log10 8.417059176469655 -> 0.9251603805112778 Inexact Rounded logx2140 log10 0.0002926570767968 -> -3.533640969664818 Inexact Rounded -- P=7, within 0-99 Precision: 7 logx2001 log10 57.26089 -> 1.757858 Inexact Rounded logx2002 log10 0.0575421 -> -1.240014 Inexact Rounded logx2003 log10 0.5918465 -> -0.2277909 Inexact Rounded logx2004 log10 0.0068776 -> -2.162563 Inexact Rounded logx2005 log10 0.0066833 -> -2.175009 Inexact Rounded logx2006 log10 9.926963 -> 0.9968164 Inexact Rounded logx2007 log10 0.0041852 -> -2.378284 Inexact Rounded logx2008 log10 84.15412 -> 1.925075 Inexact Rounded logx2009 log10 2.466856 -> 0.3921438 Inexact Rounded logx2010 log10 0.0058047 -> -2.236220 Inexact Rounded logx2011 log10 9.885154 -> 0.9949834 Inexact Rounded logx2012 log10 0.6667654 -> -0.1760269 Inexact Rounded logx2013 log10 34.65736 -> 1.539795 Inexact Rounded logx2014 log10 0.0026884 -> -2.570506 Inexact Rounded logx2015 log10 0.0432767 -> -1.363746 Inexact Rounded logx2016 log10 66.01407 -> 1.819637 Inexact Rounded logx2017 log10 0.0070572 -> -2.151368 Inexact Rounded logx2018 log10 0.0731613 -> -1.135719 Inexact Rounded logx2019 log10 9.838983 -> 0.9929502 Inexact Rounded logx2020 log10 15.89696 -> 1.201314 Inexact Rounded logx2021 log10 8.459247 -> 0.9273317 Inexact Rounded logx2022 log10 0.0010873 -> -2.963651 Inexact Rounded logx2023 log10 0.6498619 -> -0.1871789 Inexact Rounded logx2024 log10 0.0847008 -> -1.072112 Inexact Rounded logx2025 log10 0.0075489 -> -2.122116 Inexact Rounded logx2026 log10 51.11152 -> 1.708519 Inexact Rounded logx2027 log10 0.7233866 -> -0.1406295 Inexact Rounded logx2028 log10 2.254721 -> 0.3530928 Inexact Rounded logx2029 log10 6.568444 -> 0.8174625 Inexact Rounded logx2030 log10 83.72639 -> 1.922862 Inexact Rounded logx2031 log10 6.720585 -> 0.8274071 Inexact Rounded logx2032 log10 87.90366 -> 1.944007 Inexact Rounded logx2033 log10 0.0433324 -> -1.363187 Inexact Rounded logx2034 log10 34.63912 -> 1.539567 Inexact Rounded logx2035 log10 0.8089059 -> -0.09210200 Inexact Rounded logx2036 log10 7.793405 -> 0.8917272 Inexact Rounded logx2037 log10 0.0041757 -> -2.379271 Inexact Rounded logx2038 log10 7.135417 -> 0.8534194 Inexact Rounded logx2039 log10 12.49570 -> 1.096761 Inexact Rounded logx2040 log10 6.356276 -> 0.8032027 Inexact Rounded -------- maxExponent: 384 minExponent: -383 precision: 16 rounding: half_even -- special values logx820 log10 Infinity -> Infinity logx821 log10 0 -> -Infinity logx822 log10 NaN -> NaN logx823 log10 sNaN -> NaN Invalid_operation -- propagating NaNs logx824 log10 sNaN123 -> NaN123 Invalid_operation logx825 log10 -sNaN321 -> -NaN321 Invalid_operation logx826 log10 NaN456 -> NaN456 logx827 log10 -NaN654 -> -NaN654 logx828 log10 NaN1 -> NaN1 -- Invalid operations due to restrictions -- [next two probably skipped by most test harnesses] precision: 100000000 logx901 log10 1 -> NaN Invalid_context precision: 99999999 logx902 log10 0 -> NaN Invalid_context precision: 9 maxExponent: 1000000 minExponent: -999999 logx903 log10 1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999999 logx904 log10 0 -> -Infinity maxExponent: 999999 minExponent: -1000000 logx905 log10 1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999998 logx906 log10 0 -> -Infinity -- Null test logx900 log10 # -> NaN Invalid_operation apd-3.2.1/testdata/minus.decTest000066400000000000000000000165551450022325000165470ustar00rootroot00000000000000------------------------------------------------------------------------ -- minus.decTest -- decimal negation -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This set of tests primarily tests the existence of the operator. -- Subtraction, rounding, and more overflows are tested elsewhere. extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 minx001 minus '1' -> '-1' minx002 minus '-1' -> '1' minx003 minus '1.00' -> '-1.00' minx004 minus '-1.00' -> '1.00' minx005 minus '0' -> '0' minx006 minus '0.00' -> '0.00' minx007 minus '00.0' -> '0.0' minx008 minus '00.00' -> '0.00' minx009 minus '00' -> '0' minx010 minus '-2' -> '2' minx011 minus '2' -> '-2' minx012 minus '-2.00' -> '2.00' minx013 minus '2.00' -> '-2.00' minx014 minus '-0' -> '0' minx015 minus '-0.00' -> '0.00' minx016 minus '-00.0' -> '0.0' minx017 minus '-00.00' -> '0.00' minx018 minus '-00' -> '0' -- "lhs" zeros in plus and minus have exponent = operand minx020 minus '-0E3' -> '0E+3' minx021 minus '-0E2' -> '0E+2' minx022 minus '-0E1' -> '0E+1' minx023 minus '-0E0' -> '0' minx024 minus '+0E0' -> '0' minx025 minus '+0E1' -> '0E+1' minx026 minus '+0E2' -> '0E+2' minx027 minus '+0E3' -> '0E+3' minx030 minus '-5E3' -> '5E+3' minx031 minus '-5E8' -> '5E+8' minx032 minus '-5E13' -> '5E+13' minx033 minus '-5E18' -> '5E+18' minx034 minus '+5E3' -> '-5E+3' minx035 minus '+5E8' -> '-5E+8' minx036 minus '+5E13' -> '-5E+13' minx037 minus '+5E18' -> '-5E+18' minx050 minus '-2000000' -> '2000000' minx051 minus '2000000' -> '-2000000' precision: 7 minx052 minus '-2000000' -> '2000000' minx053 minus '2000000' -> '-2000000' precision: 6 minx054 minus '-2000000' -> '2.00000E+6' Rounded minx055 minus '2000000' -> '-2.00000E+6' Rounded precision: 3 minx056 minus '-2000000' -> '2.00E+6' Rounded minx057 minus '2000000' -> '-2.00E+6' Rounded -- more fixed, potential LHS swaps/overlays if done by 0 subtract x precision: 9 minx060 minus '56267E-10' -> '-0.0000056267' minx061 minus '56267E-5' -> '-0.56267' minx062 minus '56267E-2' -> '-562.67' minx063 minus '56267E-1' -> '-5626.7' minx065 minus '56267E-0' -> '-56267' minx066 minus '56267E+0' -> '-56267' minx067 minus '56267E+1' -> '-5.6267E+5' minx068 minus '56267E+2' -> '-5.6267E+6' minx069 minus '56267E+3' -> '-5.6267E+7' minx070 minus '56267E+4' -> '-5.6267E+8' minx071 minus '56267E+5' -> '-5.6267E+9' minx072 minus '56267E+6' -> '-5.6267E+10' minx080 minus '-56267E-10' -> '0.0000056267' minx081 minus '-56267E-5' -> '0.56267' minx082 minus '-56267E-2' -> '562.67' minx083 minus '-56267E-1' -> '5626.7' minx085 minus '-56267E-0' -> '56267' minx086 minus '-56267E+0' -> '56267' minx087 minus '-56267E+1' -> '5.6267E+5' minx088 minus '-56267E+2' -> '5.6267E+6' minx089 minus '-56267E+3' -> '5.6267E+7' minx090 minus '-56267E+4' -> '5.6267E+8' minx091 minus '-56267E+5' -> '5.6267E+9' minx092 minus '-56267E+6' -> '5.6267E+10' -- overflow tests maxexponent: 999999999 minexponent: -999999999 precision: 3 minx100 minus 9.999E+999999999 -> -Infinity Inexact Overflow Rounded minx101 minus -9.999E+999999999 -> Infinity Inexact Overflow Rounded -- subnormals and underflow precision: 3 maxexponent: 999 minexponent: -999 minx110 minus 1.00E-999 -> -1.00E-999 minx111 minus 0.1E-999 -> -1E-1000 Subnormal minx112 minus 0.10E-999 -> -1.0E-1000 Subnormal minx113 minus 0.100E-999 -> -1.0E-1000 Subnormal Rounded minx114 minus 0.01E-999 -> -1E-1001 Subnormal -- next is rounded to Emin minx115 minus 0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow minx116 minus 0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow minx117 minus 0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow minx118 minus 0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped minx119 minus 0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped minx120 minus 0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped minx130 minus -1.00E-999 -> 1.00E-999 minx131 minus -0.1E-999 -> 1E-1000 Subnormal minx132 minus -0.10E-999 -> 1.0E-1000 Subnormal minx133 minus -0.100E-999 -> 1.0E-1000 Subnormal Rounded minx134 minus -0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin minx135 minus -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow minx136 minus -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow minx137 minus -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow minx138 minus -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped minx139 minus -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped minx140 minus -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 minx301 minus 12345678000 -> -1.23456780E+10 Rounded minx302 minus 1234567800 -> -1.23456780E+9 Rounded minx303 minus 1234567890 -> -1.23456789E+9 Rounded minx304 minus 1234567891 -> -1.23456789E+9 Inexact Rounded minx305 minus 12345678901 -> -1.23456789E+10 Inexact Rounded minx306 minus 1234567896 -> -1.23456790E+9 Inexact Rounded precision: 15 -- still checking minx321 minus 12345678000 -> -12345678000 minx322 minus 1234567800 -> -1234567800 minx323 minus 1234567890 -> -1234567890 minx324 minus 1234567891 -> -1234567891 minx325 minus 12345678901 -> -12345678901 minx326 minus 1234567896 -> -1234567896 -- specials minx420 minus 'Inf' -> '-Infinity' minx421 minus '-Inf' -> 'Infinity' minx422 minus NaN -> NaN minx423 minus sNaN -> NaN Invalid_operation minx424 minus NaN255 -> NaN255 minx425 minus sNaN256 -> NaN256 Invalid_operation minx426 minus -NaN -> -NaN minx427 minus -sNaN -> -NaN Invalid_operation minx428 minus -NaN255 -> -NaN255 minx429 minus -sNaN256 -> -NaN256 Invalid_operation -- Null tests minx900 minus # -> NaN Invalid_operation apd-3.2.1/testdata/multiply.decTest000066400000000000000000001140721450022325000172640ustar00rootroot00000000000000------------------------------------------------------------------------ -- multiply.decTest -- decimal multiplication -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 -- sanity checks (as base, above) mulx000 multiply 2 2 -> 4 mulx001 multiply 2 3 -> 6 mulx002 multiply 5 1 -> 5 mulx003 multiply 5 2 -> 10 mulx004 multiply 1.20 2 -> 2.40 mulx005 multiply 1.20 0 -> 0.00 mulx006 multiply 1.20 -2 -> -2.40 mulx007 multiply -1.20 2 -> -2.40 mulx008 multiply -1.20 0 -> -0.00 mulx009 multiply -1.20 -2 -> 2.40 mulx010 multiply 5.09 7.1 -> 36.139 mulx011 multiply 2.5 4 -> 10.0 mulx012 multiply 2.50 4 -> 10.00 mulx013 multiply 1.23456789 1.00000000 -> 1.23456789 Rounded mulx014 multiply 9.999999999 9.999999999 -> 100.000000 Inexact Rounded mulx015 multiply 2.50 4 -> 10.00 precision: 6 mulx016 multiply 2.50 4 -> 10.00 mulx017 multiply 9.999999999 9.999999999 -> 100.000 Inexact Rounded mulx018 multiply 9.999999999 -9.999999999 -> -100.000 Inexact Rounded mulx019 multiply -9.999999999 9.999999999 -> -100.000 Inexact Rounded mulx020 multiply -9.999999999 -9.999999999 -> 100.000 Inexact Rounded -- 1999.12.21: next one is a edge case if intermediate longs are used precision: 15 mulx059 multiply 999999999999 9765625 -> 9.76562499999023E+18 Inexact Rounded precision: 30 mulx160 multiply 999999999999 9765625 -> 9765624999990234375 precision: 9 ----- -- zeros, etc. mulx021 multiply 0 0 -> 0 mulx022 multiply 0 -0 -> -0 mulx023 multiply -0 0 -> -0 mulx024 multiply -0 -0 -> 0 mulx025 multiply -0.0 -0.0 -> 0.00 mulx026 multiply -0.0 -0.0 -> 0.00 mulx027 multiply -0.0 -0.0 -> 0.00 mulx028 multiply -0.0 -0.0 -> 0.00 mulx030 multiply 5.00 1E-3 -> 0.00500 mulx031 multiply 00.00 0.000 -> 0.00000 mulx032 multiply 00.00 0E-3 -> 0.00000 -- rhs is 0 mulx033 multiply 0E-3 00.00 -> 0.00000 -- lhs is 0 mulx034 multiply -5.00 1E-3 -> -0.00500 mulx035 multiply -00.00 0.000 -> -0.00000 mulx036 multiply -00.00 0E-3 -> -0.00000 -- rhs is 0 mulx037 multiply -0E-3 00.00 -> -0.00000 -- lhs is 0 mulx038 multiply 5.00 -1E-3 -> -0.00500 mulx039 multiply 00.00 -0.000 -> -0.00000 mulx040 multiply 00.00 -0E-3 -> -0.00000 -- rhs is 0 mulx041 multiply 0E-3 -00.00 -> -0.00000 -- lhs is 0 mulx042 multiply -5.00 -1E-3 -> 0.00500 mulx043 multiply -00.00 -0.000 -> 0.00000 mulx044 multiply -00.00 -0E-3 -> 0.00000 -- rhs is 0 mulx045 multiply -0E-3 -00.00 -> 0.00000 -- lhs is 0 -- examples from decarith mulx050 multiply 1.20 3 -> 3.60 mulx051 multiply 7 3 -> 21 mulx052 multiply 0.9 0.8 -> 0.72 mulx053 multiply 0.9 -0 -> -0.0 mulx054 multiply 654321 654321 -> 4.28135971E+11 Inexact Rounded mulx060 multiply 123.45 1e7 -> 1.2345E+9 mulx061 multiply 123.45 1e8 -> 1.2345E+10 mulx062 multiply 123.45 1e+9 -> 1.2345E+11 mulx063 multiply 123.45 1e10 -> 1.2345E+12 mulx064 multiply 123.45 1e11 -> 1.2345E+13 mulx065 multiply 123.45 1e12 -> 1.2345E+14 mulx066 multiply 123.45 1e13 -> 1.2345E+15 -- test some intermediate lengths precision: 9 mulx080 multiply 0.1 123456789 -> 12345678.9 mulx081 multiply 0.1 1234567891 -> 123456789 Inexact Rounded mulx082 multiply 0.1 12345678912 -> 1.23456789E+9 Inexact Rounded mulx083 multiply 0.1 12345678912345 -> 1.23456789E+12 Inexact Rounded mulx084 multiply 0.1 123456789 -> 12345678.9 precision: 8 mulx085 multiply 0.1 12345678912 -> 1.2345679E+9 Inexact Rounded mulx086 multiply 0.1 12345678912345 -> 1.2345679E+12 Inexact Rounded precision: 7 mulx087 multiply 0.1 12345678912 -> 1.234568E+9 Inexact Rounded mulx088 multiply 0.1 12345678912345 -> 1.234568E+12 Inexact Rounded precision: 9 mulx090 multiply 123456789 0.1 -> 12345678.9 mulx091 multiply 1234567891 0.1 -> 123456789 Inexact Rounded mulx092 multiply 12345678912 0.1 -> 1.23456789E+9 Inexact Rounded mulx093 multiply 12345678912345 0.1 -> 1.23456789E+12 Inexact Rounded mulx094 multiply 123456789 0.1 -> 12345678.9 precision: 8 mulx095 multiply 12345678912 0.1 -> 1.2345679E+9 Inexact Rounded mulx096 multiply 12345678912345 0.1 -> 1.2345679E+12 Inexact Rounded precision: 7 mulx097 multiply 12345678912 0.1 -> 1.234568E+9 Inexact Rounded mulx098 multiply 12345678912345 0.1 -> 1.234568E+12 Inexact Rounded -- test some more edge cases and carries maxexponent: 9999 minexponent: -9999 precision: 33 mulx101 multiply 9 9 -> 81 mulx102 multiply 9 90 -> 810 mulx103 multiply 9 900 -> 8100 mulx104 multiply 9 9000 -> 81000 mulx105 multiply 9 90000 -> 810000 mulx106 multiply 9 900000 -> 8100000 mulx107 multiply 9 9000000 -> 81000000 mulx108 multiply 9 90000000 -> 810000000 mulx109 multiply 9 900000000 -> 8100000000 mulx110 multiply 9 9000000000 -> 81000000000 mulx111 multiply 9 90000000000 -> 810000000000 mulx112 multiply 9 900000000000 -> 8100000000000 mulx113 multiply 9 9000000000000 -> 81000000000000 mulx114 multiply 9 90000000000000 -> 810000000000000 mulx115 multiply 9 900000000000000 -> 8100000000000000 mulx116 multiply 9 9000000000000000 -> 81000000000000000 mulx117 multiply 9 90000000000000000 -> 810000000000000000 mulx118 multiply 9 900000000000000000 -> 8100000000000000000 mulx119 multiply 9 9000000000000000000 -> 81000000000000000000 mulx120 multiply 9 90000000000000000000 -> 810000000000000000000 mulx121 multiply 9 900000000000000000000 -> 8100000000000000000000 mulx122 multiply 9 9000000000000000000000 -> 81000000000000000000000 mulx123 multiply 9 90000000000000000000000 -> 810000000000000000000000 -- test some more edge cases without carries mulx131 multiply 3 3 -> 9 mulx132 multiply 3 30 -> 90 mulx133 multiply 3 300 -> 900 mulx134 multiply 3 3000 -> 9000 mulx135 multiply 3 30000 -> 90000 mulx136 multiply 3 300000 -> 900000 mulx137 multiply 3 3000000 -> 9000000 mulx138 multiply 3 30000000 -> 90000000 mulx139 multiply 3 300000000 -> 900000000 mulx140 multiply 3 3000000000 -> 9000000000 mulx141 multiply 3 30000000000 -> 90000000000 mulx142 multiply 3 300000000000 -> 900000000000 mulx143 multiply 3 3000000000000 -> 9000000000000 mulx144 multiply 3 30000000000000 -> 90000000000000 mulx145 multiply 3 300000000000000 -> 900000000000000 mulx146 multiply 3 3000000000000000 -> 9000000000000000 mulx147 multiply 3 30000000000000000 -> 90000000000000000 mulx148 multiply 3 300000000000000000 -> 900000000000000000 mulx149 multiply 3 3000000000000000000 -> 9000000000000000000 mulx150 multiply 3 30000000000000000000 -> 90000000000000000000 mulx151 multiply 3 300000000000000000000 -> 900000000000000000000 mulx152 multiply 3 3000000000000000000000 -> 9000000000000000000000 mulx153 multiply 3 30000000000000000000000 -> 90000000000000000000000 maxexponent: 999999999 minexponent: -999999999 precision: 9 -- test some cases that are close to exponent overflow/underflow mulx170 multiply 1 9e999999999 -> 9E+999999999 mulx171 multiply 1 9.9e999999999 -> 9.9E+999999999 mulx172 multiply 1 9.99e999999999 -> 9.99E+999999999 mulx173 multiply 9e999999999 1 -> 9E+999999999 mulx174 multiply 9.9e999999999 1 -> 9.9E+999999999 mulx176 multiply 9.99e999999999 1 -> 9.99E+999999999 mulx177 multiply 1 9.99999999e999999999 -> 9.99999999E+999999999 mulx178 multiply 9.99999999e999999999 1 -> 9.99999999E+999999999 mulx180 multiply 0.1 9e-999999998 -> 9E-999999999 mulx181 multiply 0.1 99e-999999998 -> 9.9E-999999998 mulx182 multiply 0.1 999e-999999998 -> 9.99E-999999997 mulx183 multiply 0.1 9e-999999998 -> 9E-999999999 mulx184 multiply 0.1 99e-999999998 -> 9.9E-999999998 mulx185 multiply 0.1 999e-999999998 -> 9.99E-999999997 mulx186 multiply 0.1 999e-999999997 -> 9.99E-999999996 mulx187 multiply 0.1 9999e-999999997 -> 9.999E-999999995 mulx188 multiply 0.1 99999e-999999997 -> 9.9999E-999999994 mulx190 multiply 1 9e-999999998 -> 9E-999999998 mulx191 multiply 1 99e-999999998 -> 9.9E-999999997 mulx192 multiply 1 999e-999999998 -> 9.99E-999999996 mulx193 multiply 9e-999999998 1 -> 9E-999999998 mulx194 multiply 99e-999999998 1 -> 9.9E-999999997 mulx195 multiply 999e-999999998 1 -> 9.99E-999999996 mulx196 multiply 1e-599999999 1e-400000000 -> 1E-999999999 mulx197 multiply 1e-600000000 1e-399999999 -> 1E-999999999 mulx198 multiply 1.2e-599999999 1.2e-400000000 -> 1.44E-999999999 mulx199 multiply 1.2e-600000000 1.2e-399999999 -> 1.44E-999999999 mulx201 multiply 1e599999999 1e400000000 -> 1E+999999999 mulx202 multiply 1e600000000 1e399999999 -> 1E+999999999 mulx203 multiply 1.2e599999999 1.2e400000000 -> 1.44E+999999999 mulx204 multiply 1.2e600000000 1.2e399999999 -> 1.44E+999999999 -- long operand triangle precision: 33 mulx246 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916511992830 Inexact Rounded precision: 32 mulx247 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651199283 Inexact Rounded precision: 31 mulx248 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165119928 Inexact Rounded precision: 30 mulx249 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916511993 Inexact Rounded precision: 29 mulx250 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651199 Inexact Rounded precision: 28 mulx251 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165120 Inexact Rounded precision: 27 mulx252 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916512 Inexact Rounded precision: 26 mulx253 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651 Inexact Rounded precision: 25 mulx254 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165 Inexact Rounded precision: 24 mulx255 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671917 Inexact Rounded precision: 23 mulx256 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967192 Inexact Rounded precision: 22 mulx257 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719 Inexact Rounded precision: 21 mulx258 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369672 Inexact Rounded precision: 20 mulx259 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967 Inexact Rounded precision: 19 mulx260 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933697 Inexact Rounded precision: 18 mulx261 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193370 Inexact Rounded precision: 17 mulx262 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119337 Inexact Rounded precision: 16 mulx263 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011934 Inexact Rounded precision: 15 mulx264 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193 Inexact Rounded precision: 14 mulx265 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119 Inexact Rounded precision: 13 mulx266 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908012 Inexact Rounded precision: 12 mulx267 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801 Inexact Rounded precision: 11 mulx268 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080 Inexact Rounded precision: 10 mulx269 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908 Inexact Rounded precision: 9 mulx270 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.291 Inexact Rounded precision: 8 mulx271 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29 Inexact Rounded precision: 7 mulx272 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.3 Inexact Rounded precision: 6 mulx273 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433 Inexact Rounded precision: 5 mulx274 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.4543E+5 Inexact Rounded precision: 4 mulx275 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.454E+5 Inexact Rounded precision: 3 mulx276 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.45E+5 Inexact Rounded precision: 2 mulx277 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.5E+5 Inexact Rounded precision: 1 mulx278 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1E+5 Inexact Rounded -- test some edge cases with exact rounding maxexponent: 9999 minexponent: -9999 precision: 9 mulx301 multiply 9 9 -> 81 mulx302 multiply 9 90 -> 810 mulx303 multiply 9 900 -> 8100 mulx304 multiply 9 9000 -> 81000 mulx305 multiply 9 90000 -> 810000 mulx306 multiply 9 900000 -> 8100000 mulx307 multiply 9 9000000 -> 81000000 mulx308 multiply 9 90000000 -> 810000000 mulx309 multiply 9 900000000 -> 8.10000000E+9 Rounded mulx310 multiply 9 9000000000 -> 8.10000000E+10 Rounded mulx311 multiply 9 90000000000 -> 8.10000000E+11 Rounded mulx312 multiply 9 900000000000 -> 8.10000000E+12 Rounded mulx313 multiply 9 9000000000000 -> 8.10000000E+13 Rounded mulx314 multiply 9 90000000000000 -> 8.10000000E+14 Rounded mulx315 multiply 9 900000000000000 -> 8.10000000E+15 Rounded mulx316 multiply 9 9000000000000000 -> 8.10000000E+16 Rounded mulx317 multiply 9 90000000000000000 -> 8.10000000E+17 Rounded mulx318 multiply 9 900000000000000000 -> 8.10000000E+18 Rounded mulx319 multiply 9 9000000000000000000 -> 8.10000000E+19 Rounded mulx320 multiply 9 90000000000000000000 -> 8.10000000E+20 Rounded mulx321 multiply 9 900000000000000000000 -> 8.10000000E+21 Rounded mulx322 multiply 9 9000000000000000000000 -> 8.10000000E+22 Rounded mulx323 multiply 9 90000000000000000000000 -> 8.10000000E+23 Rounded -- fastpath breakers precision: 29 mulx330 multiply 1.491824697641270317824852952837224 1.105170918075647624811707826490246514675628614562883537345747603 -> 1.6487212707001281468486507878 Inexact Rounded precision: 55 mulx331 multiply 0.8958341352965282506768545828765117803873717284891040428 0.8958341352965282506768545828765117803873717284891040428 -> 0.8025187979624784829842553829934069955890983696752228299 Inexact Rounded -- tryzeros cases precision: 7 rounding: half_up maxExponent: 92 minexponent: -92 mulx504 multiply 0E-60 1000E-60 -> 0E-98 Clamped mulx505 multiply 100E+60 0E+60 -> 0E+92 Clamped -- mixed with zeros maxexponent: 999999999 minexponent: -999999999 precision: 9 mulx541 multiply 0 -1 -> -0 mulx542 multiply -0 -1 -> 0 mulx543 multiply 0 1 -> 0 mulx544 multiply -0 1 -> -0 mulx545 multiply -1 0 -> -0 mulx546 multiply -1 -0 -> 0 mulx547 multiply 1 0 -> 0 mulx548 multiply 1 -0 -> -0 mulx551 multiply 0.0 -1 -> -0.0 mulx552 multiply -0.0 -1 -> 0.0 mulx553 multiply 0.0 1 -> 0.0 mulx554 multiply -0.0 1 -> -0.0 mulx555 multiply -1.0 0 -> -0.0 mulx556 multiply -1.0 -0 -> 0.0 mulx557 multiply 1.0 0 -> 0.0 mulx558 multiply 1.0 -0 -> -0.0 mulx561 multiply 0 -1.0 -> -0.0 mulx562 multiply -0 -1.0 -> 0.0 mulx563 multiply 0 1.0 -> 0.0 mulx564 multiply -0 1.0 -> -0.0 mulx565 multiply -1 0.0 -> -0.0 mulx566 multiply -1 -0.0 -> 0.0 mulx567 multiply 1 0.0 -> 0.0 mulx568 multiply 1 -0.0 -> -0.0 mulx571 multiply 0.0 -1.0 -> -0.00 mulx572 multiply -0.0 -1.0 -> 0.00 mulx573 multiply 0.0 1.0 -> 0.00 mulx574 multiply -0.0 1.0 -> -0.00 mulx575 multiply -1.0 0.0 -> -0.00 mulx576 multiply -1.0 -0.0 -> 0.00 mulx577 multiply 1.0 0.0 -> 0.00 mulx578 multiply 1.0 -0.0 -> -0.00 -- Specials mulx580 multiply Inf -Inf -> -Infinity mulx581 multiply Inf -1000 -> -Infinity mulx582 multiply Inf -1 -> -Infinity mulx583 multiply Inf -0 -> NaN Invalid_operation mulx584 multiply Inf 0 -> NaN Invalid_operation mulx585 multiply Inf 1 -> Infinity mulx586 multiply Inf 1000 -> Infinity mulx587 multiply Inf Inf -> Infinity mulx588 multiply -1000 Inf -> -Infinity mulx589 multiply -Inf Inf -> -Infinity mulx590 multiply -1 Inf -> -Infinity mulx591 multiply -0 Inf -> NaN Invalid_operation mulx592 multiply 0 Inf -> NaN Invalid_operation mulx593 multiply 1 Inf -> Infinity mulx594 multiply 1000 Inf -> Infinity mulx595 multiply Inf Inf -> Infinity mulx600 multiply -Inf -Inf -> Infinity mulx601 multiply -Inf -1000 -> Infinity mulx602 multiply -Inf -1 -> Infinity mulx603 multiply -Inf -0 -> NaN Invalid_operation mulx604 multiply -Inf 0 -> NaN Invalid_operation mulx605 multiply -Inf 1 -> -Infinity mulx606 multiply -Inf 1000 -> -Infinity mulx607 multiply -Inf Inf -> -Infinity mulx608 multiply -1000 Inf -> -Infinity mulx609 multiply -Inf -Inf -> Infinity mulx610 multiply -1 -Inf -> Infinity mulx611 multiply -0 -Inf -> NaN Invalid_operation mulx612 multiply 0 -Inf -> NaN Invalid_operation mulx613 multiply 1 -Inf -> -Infinity mulx614 multiply 1000 -Inf -> -Infinity mulx615 multiply Inf -Inf -> -Infinity mulx621 multiply NaN -Inf -> NaN mulx622 multiply NaN -1000 -> NaN mulx623 multiply NaN -1 -> NaN mulx624 multiply NaN -0 -> NaN mulx625 multiply NaN 0 -> NaN mulx626 multiply NaN 1 -> NaN mulx627 multiply NaN 1000 -> NaN mulx628 multiply NaN Inf -> NaN mulx629 multiply NaN NaN -> NaN mulx630 multiply -Inf NaN -> NaN mulx631 multiply -1000 NaN -> NaN mulx632 multiply -1 NaN -> NaN mulx633 multiply -0 NaN -> NaN mulx634 multiply 0 NaN -> NaN mulx635 multiply 1 NaN -> NaN mulx636 multiply 1000 NaN -> NaN mulx637 multiply Inf NaN -> NaN mulx641 multiply sNaN -Inf -> NaN Invalid_operation mulx642 multiply sNaN -1000 -> NaN Invalid_operation mulx643 multiply sNaN -1 -> NaN Invalid_operation mulx644 multiply sNaN -0 -> NaN Invalid_operation mulx645 multiply sNaN 0 -> NaN Invalid_operation mulx646 multiply sNaN 1 -> NaN Invalid_operation mulx647 multiply sNaN 1000 -> NaN Invalid_operation mulx648 multiply sNaN NaN -> NaN Invalid_operation mulx649 multiply sNaN sNaN -> NaN Invalid_operation mulx650 multiply NaN sNaN -> NaN Invalid_operation mulx651 multiply -Inf sNaN -> NaN Invalid_operation mulx652 multiply -1000 sNaN -> NaN Invalid_operation mulx653 multiply -1 sNaN -> NaN Invalid_operation mulx654 multiply -0 sNaN -> NaN Invalid_operation mulx655 multiply 0 sNaN -> NaN Invalid_operation mulx656 multiply 1 sNaN -> NaN Invalid_operation mulx657 multiply 1000 sNaN -> NaN Invalid_operation mulx658 multiply Inf sNaN -> NaN Invalid_operation mulx659 multiply NaN sNaN -> NaN Invalid_operation -- propagating NaNs mulx661 multiply NaN9 -Inf -> NaN9 mulx662 multiply NaN8 999 -> NaN8 mulx663 multiply NaN71 Inf -> NaN71 mulx664 multiply NaN6 NaN5 -> NaN6 mulx665 multiply -Inf NaN4 -> NaN4 mulx666 multiply -999 NaN33 -> NaN33 mulx667 multiply Inf NaN2 -> NaN2 mulx671 multiply sNaN99 -Inf -> NaN99 Invalid_operation mulx672 multiply sNaN98 -11 -> NaN98 Invalid_operation mulx673 multiply sNaN97 NaN -> NaN97 Invalid_operation mulx674 multiply sNaN16 sNaN94 -> NaN16 Invalid_operation mulx675 multiply NaN95 sNaN93 -> NaN93 Invalid_operation mulx676 multiply -Inf sNaN92 -> NaN92 Invalid_operation mulx677 multiply 088 sNaN91 -> NaN91 Invalid_operation mulx678 multiply Inf sNaN90 -> NaN90 Invalid_operation mulx679 multiply NaN sNaN89 -> NaN89 Invalid_operation mulx681 multiply -NaN9 -Inf -> -NaN9 mulx682 multiply -NaN8 999 -> -NaN8 mulx683 multiply -NaN71 Inf -> -NaN71 mulx684 multiply -NaN6 -NaN5 -> -NaN6 mulx685 multiply -Inf -NaN4 -> -NaN4 mulx686 multiply -999 -NaN33 -> -NaN33 mulx687 multiply Inf -NaN2 -> -NaN2 mulx691 multiply -sNaN99 -Inf -> -NaN99 Invalid_operation mulx692 multiply -sNaN98 -11 -> -NaN98 Invalid_operation mulx693 multiply -sNaN97 NaN -> -NaN97 Invalid_operation mulx694 multiply -sNaN16 -sNaN94 -> -NaN16 Invalid_operation mulx695 multiply -NaN95 -sNaN93 -> -NaN93 Invalid_operation mulx696 multiply -Inf -sNaN92 -> -NaN92 Invalid_operation mulx697 multiply 088 -sNaN91 -> -NaN91 Invalid_operation mulx698 multiply Inf -sNaN90 -> -NaN90 Invalid_operation mulx699 multiply -NaN -sNaN89 -> -NaN89 Invalid_operation mulx701 multiply -NaN -Inf -> -NaN mulx702 multiply -NaN 999 -> -NaN mulx703 multiply -NaN Inf -> -NaN mulx704 multiply -NaN -NaN -> -NaN mulx705 multiply -Inf -NaN0 -> -NaN mulx706 multiply -999 -NaN -> -NaN mulx707 multiply Inf -NaN -> -NaN mulx711 multiply -sNaN -Inf -> -NaN Invalid_operation mulx712 multiply -sNaN -11 -> -NaN Invalid_operation mulx713 multiply -sNaN00 NaN -> -NaN Invalid_operation mulx714 multiply -sNaN -sNaN -> -NaN Invalid_operation mulx715 multiply -NaN -sNaN -> -NaN Invalid_operation mulx716 multiply -Inf -sNaN -> -NaN Invalid_operation mulx717 multiply 088 -sNaN -> -NaN Invalid_operation mulx718 multiply Inf -sNaN -> -NaN Invalid_operation mulx719 multiply -NaN -sNaN -> -NaN Invalid_operation -- overflow and underflow tests .. note subnormal results maxexponent: 999999999 minexponent: -999999999 mulx730 multiply +1.23456789012345E-0 9E+999999999 -> Infinity Inexact Overflow Rounded mulx731 multiply 9E+999999999 +1.23456789012345E-0 -> Infinity Inexact Overflow Rounded mulx732 multiply +0.100 9E-999999999 -> 9.00E-1000000000 Subnormal mulx733 multiply 9E-999999999 +0.100 -> 9.00E-1000000000 Subnormal mulx735 multiply -1.23456789012345E-0 9E+999999999 -> -Infinity Inexact Overflow Rounded mulx736 multiply 9E+999999999 -1.23456789012345E-0 -> -Infinity Inexact Overflow Rounded mulx737 multiply -0.100 9E-999999999 -> -9.00E-1000000000 Subnormal mulx738 multiply 9E-999999999 -0.100 -> -9.00E-1000000000 Subnormal mulx739 multiply 1e-599999999 1e-400000001 -> 1E-1000000000 Subnormal mulx740 multiply 1e-599999999 1e-400000000 -> 1E-999999999 mulx741 multiply 1e-600000000 1e-400000000 -> 1E-1000000000 Subnormal mulx742 multiply 9e-999999998 0.01 -> 9E-1000000000 Subnormal mulx743 multiply 9e-999999998 0.1 -> 9E-999999999 mulx744 multiply 0.01 9e-999999998 -> 9E-1000000000 Subnormal mulx745 multiply 1e599999999 1e400000001 -> Infinity Overflow Inexact Rounded mulx746 multiply 1e599999999 1e400000000 -> 1E+999999999 mulx747 multiply 1e600000000 1e400000000 -> Infinity Overflow Inexact Rounded mulx748 multiply 9e999999998 100 -> Infinity Overflow Inexact Rounded mulx749 multiply 9e999999998 10 -> 9.0E+999999999 mulx750 multiply 100 9e999999998 -> Infinity Overflow Inexact Rounded -- signs mulx751 multiply 1e+777777777 1e+411111111 -> Infinity Overflow Inexact Rounded mulx752 multiply 1e+777777777 -1e+411111111 -> -Infinity Overflow Inexact Rounded mulx753 multiply -1e+777777777 1e+411111111 -> -Infinity Overflow Inexact Rounded mulx754 multiply -1e+777777777 -1e+411111111 -> Infinity Overflow Inexact Rounded mulx755 multiply 1e-777777777 1e-411111111 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped mulx756 multiply 1e-777777777 -1e-411111111 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped mulx757 multiply -1e-777777777 1e-411111111 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped mulx758 multiply -1e-777777777 -1e-411111111 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- 'subnormal' boundary (all hard underflow or overflow in base arithemtic) precision: 9 mulx760 multiply 1e-600000000 1e-400000001 -> 1E-1000000001 Subnormal mulx761 multiply 1e-600000000 1e-400000002 -> 1E-1000000002 Subnormal mulx762 multiply 1e-600000000 1e-400000003 -> 1E-1000000003 Subnormal mulx763 multiply 1e-600000000 1e-400000004 -> 1E-1000000004 Subnormal mulx764 multiply 1e-600000000 1e-400000005 -> 1E-1000000005 Subnormal mulx765 multiply 1e-600000000 1e-400000006 -> 1E-1000000006 Subnormal mulx766 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal mulx767 multiply 1e-600000000 1e-400000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped mulx768 multiply 1e-600000000 1e-400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped mulx769 multiply 1e-600000000 1e-400000010 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- [no equivalent of 'subnormal' for overflow] mulx770 multiply 1e+600000000 1e+400000001 -> Infinity Overflow Inexact Rounded mulx771 multiply 1e+600000000 1e+400000002 -> Infinity Overflow Inexact Rounded mulx772 multiply 1e+600000000 1e+400000003 -> Infinity Overflow Inexact Rounded mulx773 multiply 1e+600000000 1e+400000004 -> Infinity Overflow Inexact Rounded mulx774 multiply 1e+600000000 1e+400000005 -> Infinity Overflow Inexact Rounded mulx775 multiply 1e+600000000 1e+400000006 -> Infinity Overflow Inexact Rounded mulx776 multiply 1e+600000000 1e+400000007 -> Infinity Overflow Inexact Rounded mulx777 multiply 1e+600000000 1e+400000008 -> Infinity Overflow Inexact Rounded mulx778 multiply 1e+600000000 1e+400000009 -> Infinity Overflow Inexact Rounded mulx779 multiply 1e+600000000 1e+400000010 -> Infinity Overflow Inexact Rounded -- 'subnormal' test edge condition at higher precisions precision: 99 mulx780 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal mulx781 multiply 1e-600000000 1e-400000008 -> 1E-1000000008 Subnormal mulx782 multiply 1e-600000000 1e-400000097 -> 1E-1000000097 Subnormal mulx783 multiply 1e-600000000 1e-400000098 -> 0E-1000000097 Underflow Subnormal Inexact Rounded Clamped precision: 999 mulx784 multiply 1e-600000000 1e-400000997 -> 1E-1000000997 Subnormal mulx785 multiply 1e-600000000 1e-400000998 -> 0E-1000000997 Underflow Subnormal Inexact Rounded Clamped -- following testcases [through mulx800] not yet run against code precision: 9999 mulx786 multiply 1e-600000000 1e-400009997 -> 1E-1000009997 Subnormal mulx787 multiply 1e-600000000 1e-400009998 -> 0E-1000009997 Underflow Subnormal Inexact Rounded Clamped precision: 99999 mulx788 multiply 1e-600000000 1e-400099997 -> 1E-1000099997 Subnormal mulx789 multiply 1e-600000000 1e-400099998 -> 0E-1000099997 Underflow Subnormal Inexact Rounded Clamped precision: 999999 mulx790 multiply 1e-600000000 1e-400999997 -> 1E-1000999997 Subnormal mulx791 multiply 1e-600000000 1e-400999998 -> 0E-1000999997 Underflow Subnormal Inexact Rounded Clamped precision: 9999999 mulx792 multiply 1e-600000000 1e-409999997 -> 1E-1009999997 Subnormal mulx793 multiply 1e-600000000 1e-409999998 -> 0E-1009999997 Underflow Subnormal Inexact Rounded Clamped precision: 99999999 mulx794 multiply 1e-600000000 1e-499999997 -> 1E-1099999997 Subnormal mulx795 multiply 1e-600000000 1e-499999998 -> 0E-1099999997 Underflow Subnormal Inexact Rounded Clamped precision: 999999999 mulx796 multiply 1e-999999999 1e-999999997 -> 1E-1999999996 Subnormal mulx797 multiply 1e-999999999 1e-999999998 -> 1E-1999999997 Subnormal mulx798 multiply 1e-999999999 1e-999999999 -> 0E-1999999997 Underflow Subnormal Inexact Rounded Clamped mulx799 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal mulx800 multiply 1e-600000000 1e-400000008 -> 1E-1000000008 Subnormal -- test subnormals rounding precision: 5 maxExponent: 999 minexponent: -999 rounding: half_even mulx801 multiply 1.0000E-999 1 -> 1.0000E-999 mulx802 multiply 1.000E-999 1e-1 -> 1.000E-1000 Subnormal mulx803 multiply 1.00E-999 1e-2 -> 1.00E-1001 Subnormal mulx804 multiply 1.0E-999 1e-3 -> 1.0E-1002 Subnormal mulx805 multiply 1.0E-999 1e-4 -> 1E-1003 Subnormal Rounded mulx806 multiply 1.3E-999 1e-4 -> 1E-1003 Underflow Subnormal Inexact Rounded mulx807 multiply 1.5E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx808 multiply 1.7E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx809 multiply 2.3E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx810 multiply 2.5E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx811 multiply 2.7E-999 1e-4 -> 3E-1003 Underflow Subnormal Inexact Rounded mulx812 multiply 1.49E-999 1e-4 -> 1E-1003 Underflow Subnormal Inexact Rounded mulx813 multiply 1.50E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx814 multiply 1.51E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx815 multiply 2.49E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx816 multiply 2.50E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded mulx817 multiply 2.51E-999 1e-4 -> 3E-1003 Underflow Subnormal Inexact Rounded mulx818 multiply 1E-999 1e-4 -> 1E-1003 Subnormal mulx819 multiply 3E-999 1e-5 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx820 multiply 5E-999 1e-5 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx821 multiply 7E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded mulx822 multiply 9E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded mulx823 multiply 9.9E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded mulx824 multiply 1E-999 -1e-4 -> -1E-1003 Subnormal mulx825 multiply 3E-999 -1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx826 multiply -5E-999 1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx827 multiply 7E-999 -1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded mulx828 multiply -9E-999 1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded mulx829 multiply 9.9E-999 -1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded mulx830 multiply 3.0E-999 -1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx831 multiply 1.0E-501 1e-501 -> 1.0E-1002 Subnormal mulx832 multiply 2.0E-501 2e-501 -> 4.0E-1002 Subnormal mulx833 multiply 4.0E-501 4e-501 -> 1.60E-1001 Subnormal mulx834 multiply 10.0E-501 10e-501 -> 1.000E-1000 Subnormal mulx835 multiply 30.0E-501 30e-501 -> 9.000E-1000 Subnormal mulx836 multiply 40.0E-501 40e-501 -> 1.6000E-999 -- squares mulx840 multiply 1E-502 1e-502 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx841 multiply 1E-501 1e-501 -> 1E-1002 Subnormal mulx842 multiply 2E-501 2e-501 -> 4E-1002 Subnormal mulx843 multiply 4E-501 4e-501 -> 1.6E-1001 Subnormal mulx844 multiply 10E-501 10e-501 -> 1.00E-1000 Subnormal mulx845 multiply 30E-501 30e-501 -> 9.00E-1000 Subnormal mulx846 multiply 40E-501 40e-501 -> 1.600E-999 -- cubes mulx850 multiply 1E-670 1e-335 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx851 multiply 1E-668 1e-334 -> 1E-1002 Subnormal mulx852 multiply 4E-668 2e-334 -> 8E-1002 Subnormal mulx853 multiply 9E-668 3e-334 -> 2.7E-1001 Subnormal mulx854 multiply 16E-668 4e-334 -> 6.4E-1001 Subnormal mulx855 multiply 25E-668 5e-334 -> 1.25E-1000 Subnormal mulx856 multiply 10E-668 100e-334 -> 1.000E-999 -- test derived from result of 0.099 ** 999 at 15 digits with unlimited exponent precision: 19 mulx860 multiply 6636851557994578716E-520 6636851557994578716E-520 -> 4.40477986028551E-1003 Underflow Subnormal Inexact Rounded -- Long operand overflow may be a different path precision: 3 maxExponent: 999999999 minexponent: -999999999 mulx870 multiply 1 9.999E+999999999 -> Infinity Inexact Overflow Rounded mulx871 multiply 1 -9.999E+999999999 -> -Infinity Inexact Overflow Rounded mulx872 multiply 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded mulx873 multiply -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded -- check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 mulx881 multiply 1.2347E-40 1.2347E-40 -> 1.524E-80 Inexact Rounded Subnormal Underflow mulx882 multiply 1.234E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow mulx883 multiply 1.23E-40 1.23E-40 -> 1.513E-80 Inexact Rounded Subnormal Underflow mulx884 multiply 1.2E-40 1.2E-40 -> 1.44E-80 Subnormal mulx885 multiply 1.2E-40 1.2E-41 -> 1.44E-81 Subnormal mulx886 multiply 1.2E-40 1.2E-42 -> 1.4E-82 Subnormal Inexact Rounded Underflow mulx887 multiply 1.2E-40 1.3E-42 -> 1.6E-82 Subnormal Inexact Rounded Underflow mulx888 multiply 1.3E-40 1.3E-42 -> 1.7E-82 Subnormal Inexact Rounded Underflow mulx889 multiply 1.3E-40 1.3E-43 -> 2E-83 Subnormal Inexact Rounded Underflow mulx890 multiply 1.3E-41 1.3E-43 -> 0E-83 Clamped Subnormal Inexact Rounded Underflow mulx891 multiply 1.2345E-39 1.234E-40 -> 1.5234E-79 Inexact Rounded mulx892 multiply 1.23456E-39 1.234E-40 -> 1.5234E-79 Inexact Rounded mulx893 multiply 1.2345E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow mulx894 multiply 1.23456E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow mulx895 multiply 1.2345E-41 1.234E-40 -> 1.52E-81 Inexact Rounded Subnormal Underflow mulx896 multiply 1.23456E-41 1.234E-40 -> 1.52E-81 Inexact Rounded Subnormal Underflow -- Now explore the case where we get a normal result with Underflow precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 mulx900 multiply 0.3000000000E-191 0.3000000000E-191 -> 9.00000000000000E-384 Subnormal Rounded mulx901 multiply 0.3000000001E-191 0.3000000001E-191 -> 9.00000000600000E-384 Underflow Inexact Subnormal Rounded mulx902 multiply 9.999999999999999E-383 0.0999999999999 -> 9.99999999999000E-384 Underflow Inexact Subnormal Rounded mulx903 multiply 9.999999999999999E-383 0.09999999999999 -> 9.99999999999900E-384 Underflow Inexact Subnormal Rounded mulx904 multiply 9.999999999999999E-383 0.099999999999999 -> 9.99999999999990E-384 Underflow Inexact Subnormal Rounded mulx905 multiply 9.999999999999999E-383 0.0999999999999999 -> 9.99999999999999E-384 Underflow Inexact Subnormal Rounded -- prove operands are exact mulx906 multiply 9.999999999999999E-383 1 -> 9.999999999999999E-383 mulx907 multiply 1 0.09999999999999999 -> 0.09999999999999999 -- the next rounds to Nmin mulx908 multiply 9.999999999999999E-383 0.09999999999999999 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded mulx909 multiply 9.999999999999999E-383 0.099999999999999999 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded mulx910 multiply 9.999999999999999E-383 0.0999999999999999999 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded mulx911 multiply 9.999999999999999E-383 0.09999999999999999999 -> 1.000000000000000E-383 Underflow Inexact Subnormal Rounded -- Examples from SQL proposal (Krishna Kulkarni) precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 mulx1001 multiply 130E-2 120E-2 -> 1.5600 mulx1002 multiply 130E-2 12E-1 -> 1.560 mulx1003 multiply 130E-2 1E0 -> 1.30 mulx1004 multiply 1E2 1E4 -> 1E+6 -- payload decapitate precision: 5 mulx1010 multiply 11 -sNaN1234567890 -> -NaN67890 Invalid_operation -- Null tests mulx990 multiply 10 # -> NaN Invalid_operation mulx991 multiply # 10 -> NaN Invalid_operation apd-3.2.1/testdata/plus.decTest000066400000000000000000000175031450022325000163710ustar00rootroot00000000000000------------------------------------------------------------------------ -- plus.decTest -- decimal monadic addition -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This set of tests primarily tests the existence of the operator. -- Addition and rounding, and most overflows, are tested elsewhere. extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 plux001 plus '1' -> '1' plux002 plus '-1' -> '-1' plux003 plus '1.00' -> '1.00' plux004 plus '-1.00' -> '-1.00' plux005 plus '0' -> '0' plux006 plus '0.00' -> '0.00' plux007 plus '00.0' -> '0.0' plux008 plus '00.00' -> '0.00' plux009 plus '00' -> '0' plux010 plus '-2' -> '-2' plux011 plus '2' -> '2' plux012 plus '-2.00' -> '-2.00' plux013 plus '2.00' -> '2.00' plux014 plus '-0' -> '0' plux015 plus '-0.00' -> '0.00' plux016 plus '-00.0' -> '0.0' plux017 plus '-00.00' -> '0.00' plux018 plus '-00' -> '0' plux020 plus '-2000000' -> '-2000000' plux021 plus '2000000' -> '2000000' precision: 7 plux022 plus '-2000000' -> '-2000000' plux023 plus '2000000' -> '2000000' precision: 6 plux024 plus '-2000000' -> '-2.00000E+6' Rounded plux025 plus '2000000' -> '2.00000E+6' Rounded precision: 3 plux026 plus '-2000000' -> '-2.00E+6' Rounded plux027 plus '2000000' -> '2.00E+6' Rounded -- more fixed, potential LHS swaps if done by add 0 precision: 9 plux060 plus '56267E-10' -> '0.0000056267' plux061 plus '56267E-5' -> '0.56267' plux062 plus '56267E-2' -> '562.67' plux063 plus '56267E-1' -> '5626.7' plux065 plus '56267E-0' -> '56267' plux066 plus '56267E+0' -> '56267' plux067 plus '56267E+1' -> '5.6267E+5' plux068 plus '56267E+2' -> '5.6267E+6' plux069 plus '56267E+3' -> '5.6267E+7' plux070 plus '56267E+4' -> '5.6267E+8' plux071 plus '56267E+5' -> '5.6267E+9' plux072 plus '56267E+6' -> '5.6267E+10' plux080 plus '-56267E-10' -> '-0.0000056267' plux081 plus '-56267E-5' -> '-0.56267' plux082 plus '-56267E-2' -> '-562.67' plux083 plus '-56267E-1' -> '-5626.7' plux085 plus '-56267E-0' -> '-56267' plux086 plus '-56267E+0' -> '-56267' plux087 plus '-56267E+1' -> '-5.6267E+5' plux088 plus '-56267E+2' -> '-5.6267E+6' plux089 plus '-56267E+3' -> '-5.6267E+7' plux090 plus '-56267E+4' -> '-5.6267E+8' plux091 plus '-56267E+5' -> '-5.6267E+9' plux092 plus '-56267E+6' -> '-5.6267E+10' -- "lhs" zeros in plus and minus have exponent = operand plux120 plus '-0E3' -> '0E+3' plux121 plus '-0E2' -> '0E+2' plux122 plus '-0E1' -> '0E+1' plux123 plus '-0E0' -> '0' plux124 plus '+0E0' -> '0' plux125 plus '+0E1' -> '0E+1' plux126 plus '+0E2' -> '0E+2' plux127 plus '+0E3' -> '0E+3' plux130 plus '-5E3' -> '-5E+3' plux131 plus '-5E8' -> '-5E+8' plux132 plus '-5E13' -> '-5E+13' plux133 plus '-5E18' -> '-5E+18' plux134 plus '+5E3' -> '5E+3' plux135 plus '+5E8' -> '5E+8' plux136 plus '+5E13' -> '5E+13' plux137 plus '+5E18' -> '5E+18' -- specials plux150 plus 'Inf' -> 'Infinity' plux151 plus '-Inf' -> '-Infinity' plux152 plus NaN -> NaN plux153 plus sNaN -> NaN Invalid_operation plux154 plus NaN77 -> NaN77 plux155 plus sNaN88 -> NaN88 Invalid_operation plux156 plus -NaN -> -NaN plux157 plus -sNaN -> -NaN Invalid_operation plux158 plus -NaN77 -> -NaN77 plux159 plus -sNaN88 -> -NaN88 Invalid_operation -- overflow tests maxexponent: 999999999 minexponent: -999999999 precision: 3 plux160 plus 9.999E+999999999 -> Infinity Inexact Overflow Rounded plux161 plus -9.999E+999999999 -> -Infinity Inexact Overflow Rounded -- subnormals and underflow precision: 3 maxexponent: 999 minexponent: -999 plux210 plus 1.00E-999 -> 1.00E-999 plux211 plus 0.1E-999 -> 1E-1000 Subnormal plux212 plus 0.10E-999 -> 1.0E-1000 Subnormal plux213 plus 0.100E-999 -> 1.0E-1000 Subnormal Rounded plux214 plus 0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin plux215 plus 0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow plux216 plus 0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow plux217 plus 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow plux218 plus 0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped plux219 plus 0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped plux220 plus 0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped plux230 plus -1.00E-999 -> -1.00E-999 plux231 plus -0.1E-999 -> -1E-1000 Subnormal plux232 plus -0.10E-999 -> -1.0E-1000 Subnormal plux233 plus -0.100E-999 -> -1.0E-1000 Subnormal Rounded plux234 plus -0.01E-999 -> -1E-1001 Subnormal -- next is rounded to Emin plux235 plus -0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow plux236 plus -0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow plux237 plus -0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow plux238 plus -0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped plux239 plus -0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped plux240 plus -0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped -- subnormals clamped to 0-Etiny precision: 16 maxExponent: 384 minExponent: -383 plux251 plus 7E-398 -> 7E-398 Subnormal plux252 plus 0E-398 -> 0E-398 plux253 plus 7E-399 -> 1E-398 Subnormal Underflow Inexact Rounded plux254 plus 4E-399 -> 0E-398 Clamped Subnormal Underflow Inexact Rounded plux255 plus 7E-400 -> 0E-398 Clamped Subnormal Underflow Inexact Rounded plux256 plus 7E-401 -> 0E-398 Clamped Subnormal Underflow Inexact Rounded plux257 plus 0E-399 -> 0E-398 Clamped plux258 plus 0E-400 -> 0E-398 Clamped plux259 plus 0E-401 -> 0E-398 Clamped -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 plux301 plus 12345678000 -> 1.23456780E+10 Rounded plux302 plus 1234567800 -> 1.23456780E+9 Rounded plux303 plus 1234567890 -> 1.23456789E+9 Rounded plux304 plus 1234567891 -> 1.23456789E+9 Inexact Rounded plux305 plus 12345678901 -> 1.23456789E+10 Inexact Rounded plux306 plus 1234567896 -> 1.23456790E+9 Inexact Rounded -- still checking precision: 15 plux321 plus 12345678000 -> 12345678000 plux322 plus 1234567800 -> 1234567800 plux323 plus 1234567890 -> 1234567890 plux324 plus 1234567891 -> 1234567891 plux325 plus 12345678901 -> 12345678901 plux326 plus 1234567896 -> 1234567896 precision: 9 -- Null tests plu900 plus # -> NaN Invalid_operation apd-3.2.1/testdata/power.decTest000066400000000000000000002744231450022325000165500ustar00rootroot00000000000000------------------------------------------------------------------------ -- power.decTest -- decimal exponentiation [power(x, y)] -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- In addition to the power operator testcases here, see also the file -- powersqrt.decTest which includes all the tests from -- squareroot.decTest implemented using power(x, 0.5) extended: 1 precision: 16 rounding: half_even maxExponent: 384 minExponent: -383 -- base checks. Note 0**0 is an error. powx001 power '0' '0' -> NaN Invalid_operation powx002 power '0' '1' -> '0' powx003 power '0' '2' -> '0' powx004 power '1' '0' -> '1' powx005 power '1' '1' -> '1' powx006 power '1' '2' -> '1' powx010 power '2' '0' -> '1' powx011 power '2' '1' -> '2' powx012 power '2' '2' -> '4' powx013 power '2' '3' -> '8' powx014 power '2' '4' -> '16' powx015 power '2' '5' -> '32' powx016 power '2' '6' -> '64' powx017 power '2' '7' -> '128' powx018 power '2' '8' -> '256' powx019 power '2' '9' -> '512' powx020 power '2' '10' -> '1024' powx021 power '2' '11' -> '2048' powx022 power '2' '12' -> '4096' powx023 power '2' '15' -> '32768' powx024 power '2' '16' -> '65536' powx025 power '2' '31' -> '2147483648' -- NB 0 not stripped in next powx026 power '2' '32' -> '4294967296' precision: 9 powx027 power '2' '31' -> '2.14748365E+9' Inexact Rounded -- NB 0 not stripped in next powx028 power '2' '32' -> '4.29496730E+9' Inexact Rounded precision: 10 powx029 power '2' '31' -> '2147483648' powx030 power '2' '32' -> '4294967296' precision: 9 powx031 power '3' '2' -> 9 powx032 power '4' '2' -> 16 powx033 power '5' '2' -> 25 powx034 power '6' '2' -> 36 powx035 power '7' '2' -> 49 powx036 power '8' '2' -> 64 powx037 power '9' '2' -> 81 powx038 power '10' '2' -> 100 powx039 power '11' '2' -> 121 powx040 power '12' '2' -> 144 powx041 power '3' '3' -> 27 powx042 power '4' '3' -> 64 powx043 power '5' '3' -> 125 powx044 power '6' '3' -> 216 powx045 power '7' '3' -> 343 powx047 power '-3' '3' -> -27 powx048 power '-4' '3' -> -64 powx049 power '-5' '3' -> -125 powx050 power '-6' '3' -> -216 powx051 power '-7' '3' -> -343 powx052 power '10' '0' -> 1 powx053 power '10' '1' -> 10 powx054 power '10' '2' -> 100 powx055 power '10' '3' -> 1000 powx056 power '10' '4' -> 10000 powx057 power '10' '5' -> 100000 powx058 power '10' '6' -> 1000000 powx059 power '10' '7' -> 10000000 powx060 power '10' '8' -> 100000000 powx061 power '10' '9' -> 1.00000000E+9 Rounded powx062 power '10' '22' -> 1.00000000E+22 Rounded powx063 power '10' '77' -> 1.00000000E+77 Rounded powx064 power '10' '99' -> 1.00000000E+99 Rounded powx070 power '0.3' '0' -> '1' powx071 power '0.3' '1' -> '0.3' powx072 power '0.3' '1.00' -> '0.3' powx073 power '0.3' '2.00' -> '0.09' powx074 power '0.3' '2.000000000' -> '0.09' powx075 power '6.0' '1' -> '6.0' -- NB zeros not stripped powx076 power '6.0' '2' -> '36.00' -- .. powx077 power '-3' '2' -> '9' -- from NetRexx book powx078 power '4' '3' -> '64' -- .. (sort of) powx080 power 0.1 0 -> 1 powx081 power 0.1 1 -> 0.1 powx082 power 0.1 2 -> 0.01 powx083 power 0.1 3 -> 0.001 powx084 power 0.1 4 -> 0.0001 powx085 power 0.1 5 -> 0.00001 powx086 power 0.1 6 -> 0.000001 powx087 power 0.1 7 -> 1E-7 powx088 power 0.1 8 -> 1E-8 powx089 power 0.1 9 -> 1E-9 powx090 power 101 2 -> 10201 powx091 power 101 3 -> 1030301 powx092 power 101 4 -> 104060401 powx093 power 101 5 -> 1.05101005E+10 Inexact Rounded powx094 power 101 6 -> 1.06152015E+12 Inexact Rounded powx095 power 101 7 -> 1.07213535E+14 Inexact Rounded -- negative powers powx099 power '1' '-1' -> 1 powx100 power '3' '-1' -> 0.333333333 Inexact Rounded powx101 power '2' '-1' -> 0.5 powx102 power '2' '-2' -> 0.25 powx103 power '2' '-4' -> 0.0625 powx104 power '2' '-8' -> 0.00390625 powx105 power '2' '-16' -> 0.0000152587891 Inexact Rounded powx106 power '2' '-32' -> 2.32830644E-10 Inexact Rounded powx108 power '2' '-64' -> 5.42101086E-20 Inexact Rounded powx110 power '10' '-8' -> 1E-8 powx111 power '10' '-7' -> 1E-7 powx112 power '10' '-6' -> 0.000001 powx113 power '10' '-5' -> 0.00001 powx114 power '10' '-4' -> 0.0001 powx115 power '10' '-3' -> 0.001 powx116 power '10' '-2' -> 0.01 powx117 power '10' '-1' -> 0.1 powx121 power '10' '-77' -> '1E-77' powx122 power '10' '-22' -> '1E-22' powx123 power '2' '-1' -> '0.5' powx124 power '2' '-2' -> '0.25' powx125 power '2' '-4' -> '0.0625' powx126 power '0' '-1' -> Infinity powx127 power '0' '-2' -> Infinity powx128 power -0 '-1' -> -Infinity powx129 power -0 '-2' -> Infinity -- "0.5" tests from original Rexx diagnostics [loop unrolled] powx200 power 0.5 0 -> 1 powx201 power 0.5 1 -> 0.5 powx202 power 0.5 2 -> 0.25 powx203 power 0.5 3 -> 0.125 powx204 power 0.5 4 -> 0.0625 powx205 power 0.5 5 -> 0.03125 powx206 power 0.5 6 -> 0.015625 powx207 power 0.5 7 -> 0.0078125 powx208 power 0.5 8 -> 0.00390625 powx209 power 0.5 9 -> 0.001953125 powx210 power 0.5 10 -> 0.0009765625 powx211 power 1 100000000 -> 1 powx212 power 1 999999998 -> 1 powx213 power 1 999999999 -> 1 -- The Vienna case. Checks both setup and 1/acc working precision -- Modified 1998.12.14 as RHS no longer rounded before use (must fit) -- Modified 1990.02.04 as LHS is now rounded (instead of truncated to guard) -- '123456789E+10' -- lhs .. rounded to 1.23E+18 -- '-1.23000e+2' -- rhs .. [was: -1.23455e+2, rounds to -123] -- Modified 2002.10.06 -- finally, no input rounding -- With input rounding, result would be 8.74E-2226 precision: 3 maxexponent: 5000 minexponent: -5000 powx219 power '123456789E+10' '-1.23000e+2' -> '5.54E-2226' Inexact Rounded -- zeros maxexponent: +96 minexponent: -95 precision: 7 powx223 power 0E-30 3 -> 0 powx224 power 0E-10 3 -> 0 powx225 power 0E-1 3 -> 0 powx226 power 0E+0 3 -> 0 powx227 power 0 3 -> 0 powx228 power 0E+1 3 -> 0 powx229 power 0E+10 3 -> 0 powx230 power 0E+30 3 -> 0 powx231 power 3 0E-30 -> 1 powx232 power 3 0E-10 -> 1 powx233 power 3 0E-1 -> 1 powx234 power 3 0E+0 -> 1 powx235 power 3 0 -> 1 powx236 power 3 0E+1 -> 1 powx237 power 3 0E+10 -> 1 powx238 power 3 0E+30 -> 1 powx239 power 0E-30 -3 -> Infinity powx240 power 0E-10 -3 -> Infinity powx241 power 0E-1 -3 -> Infinity powx242 power 0E+0 -3 -> Infinity powx243 power 0 -3 -> Infinity powx244 power 0E+1 -3 -> Infinity powx245 power 0E+10 -3 -> Infinity powx246 power 0E+30 -3 -> Infinity powx247 power -3 0E-30 -> 1 powx248 power -3 0E-10 -> 1 powx249 power -3 0E-1 -> 1 powx250 power -3 0E+0 -> 1 powx251 power -3 0 -> 1 powx252 power -3 0E+1 -> 1 powx253 power -3 0E+10 -> 1 powx254 power -3 0E+30 -> 1 -- a few lhs negatives precision: 9 maxExponent: 999 minexponent: -999 powx260 power -10 '0' -> 1 powx261 power -10 '1' -> -10 powx262 power -10 '2' -> 100 powx263 power -10 '3' -> -1000 powx264 power -10 '4' -> 10000 powx265 power -10 '5' -> -100000 powx266 power -10 '6' -> 1000000 powx267 power -10 '7' -> -10000000 powx268 power -10 '8' -> 100000000 powx269 power -10 '9' -> -1.00000000E+9 Rounded powx270 power -10 '22' -> 1.00000000E+22 Rounded powx271 power -10 '77' -> -1.00000000E+77 Rounded powx272 power -10 '99' -> -1.00000000E+99 Rounded -- some more edge cases precision: 15 maxExponent: 999 minexponent: -999 powx391 power 0.1 999 -> 1E-999 powx392 power 0.099 999 -> 4.360732062E-1004 Underflow Subnormal Inexact Rounded powx393 power 0.098 999 -> 1.71731E-1008 Underflow Subnormal Inexact Rounded powx394 power 0.097 999 -> 6E-1013 Underflow Subnormal Inexact Rounded powx395 power 0.096 999 -> 0E-1013 Underflow Subnormal Inexact Rounded Clamped powx396 power 0.01 999 -> 0E-1013 Underflow Subnormal Inexact Rounded Clamped powx397 power 0.02 100000000 -> 0E-1013 Underflow Subnormal Inexact Rounded Clamped -- multiply tests are here to aid checking and test for consistent handling -- of underflow precision: 5 maxexponent: 999 minexponent: -999 -- squares mulx400 multiply 1E-502 1e-502 -> 0E-1003 Subnormal Inexact Underflow Rounded Clamped mulx401 multiply 1E-501 1e-501 -> 1E-1002 Subnormal mulx402 multiply 2E-501 2e-501 -> 4E-1002 Subnormal mulx403 multiply 4E-501 4e-501 -> 1.6E-1001 Subnormal mulx404 multiply 10E-501 10e-501 -> 1.00E-1000 Subnormal mulx405 multiply 30E-501 30e-501 -> 9.00E-1000 Subnormal mulx406 multiply 40E-501 40e-501 -> 1.600E-999 powx400 power 1E-502 2 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx401 power 1E-501 2 -> 1E-1002 Subnormal powx402 power 2E-501 2 -> 4E-1002 Subnormal powx403 power 4E-501 2 -> 1.6E-1001 Subnormal powx404 power 10E-501 2 -> 1.00E-1000 Subnormal powx405 power 30E-501 2 -> 9.00E-1000 Subnormal powx406 power 40E-501 2 -> 1.600E-999 -- cubes mulx410 multiply 1E-670 1e-335 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped mulx411 multiply 1E-668 1e-334 -> 1E-1002 Subnormal mulx412 multiply 4E-668 2e-334 -> 8E-1002 Subnormal mulx413 multiply 9E-668 3e-334 -> 2.7E-1001 Subnormal mulx414 multiply 16E-668 4e-334 -> 6.4E-1001 Subnormal mulx415 multiply 25E-668 5e-334 -> 1.25E-1000 Subnormal mulx416 multiply 10E-668 100e-334 -> 1.000E-999 powx410 power 1E-335 3 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx411 power 1E-334 3 -> 1E-1002 Subnormal powx412 power 2E-334 3 -> 8E-1002 Subnormal powx413 power 3E-334 3 -> 2.7E-1001 Subnormal powx414 power 4E-334 3 -> 6.4E-1001 Subnormal powx415 power 5E-334 3 -> 1.25E-1000 Subnormal powx416 power 10E-334 3 -> 1.000E-999 -- negative powers, testing subnormals precision: 5 maxExponent: 999 minexponent: -999 powx421 power 2.5E-501 -2 -> Infinity Overflow Inexact Rounded powx422 power 2.5E-500 -2 -> 1.6E+999 powx423 power 2.5E+499 -2 -> 1.6E-999 powx424 power 2.5E+500 -2 -> 1.6E-1001 Subnormal powx425 power 2.5E+501 -2 -> 2E-1003 Underflow Subnormal Inexact Rounded powx426 power 2.5E+502 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx427 power 0.25E+499 -2 -> 1.6E-997 powx428 power 0.25E+500 -2 -> 1.6E-999 powx429 power 0.25E+501 -2 -> 1.6E-1001 Subnormal powx430 power 0.25E+502 -2 -> 2E-1003 Underflow Subnormal Inexact Rounded powx431 power 0.25E+503 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx432 power 0.04E+499 -2 -> 6.25E-996 powx433 power 0.04E+500 -2 -> 6.25E-998 powx434 power 0.04E+501 -2 -> 6.25E-1000 Subnormal powx435 power 0.04E+502 -2 -> 6.2E-1002 Underflow Subnormal Inexact Rounded powx436 power 0.04E+503 -2 -> 1E-1003 Underflow Subnormal Inexact Rounded powx437 power 0.04E+504 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx441 power 0.04E+334 -3 -> 1.5625E-998 powx442 power 0.04E+335 -3 -> 1.56E-1001 Underflow Subnormal Inexact Rounded powx443 power 0.04E+336 -3 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped powx444 power 0.25E+333 -3 -> 6.4E-998 powx445 power 0.25E+334 -3 -> 6.4E-1001 Subnormal powx446 power 0.25E+335 -3 -> 1E-1003 Underflow Subnormal Inexact Rounded powx447 power 0.25E+336 -3 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped -- check sign for cubes and a few squares powx448 power -0.04E+334 -3 -> -1.5625E-998 powx449 power -0.04E+335 -3 -> -1.56E-1001 Underflow Subnormal Inexact Rounded powx450 power -0.04E+336 -3 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped powx451 power -0.25E+333 -3 -> -6.4E-998 powx452 power -0.25E+334 -3 -> -6.4E-1001 Subnormal powx453 power -0.25E+335 -3 -> -1E-1003 Underflow Subnormal Inexact Rounded powx454 power -0.25E+336 -3 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped powx455 power -0.04E+499 -2 -> 6.25E-996 powx456 power -0.04E+500 -2 -> 6.25E-998 powx457 power -0.04E+501 -2 -> 6.25E-1000 Subnormal powx458 power -0.04E+502 -2 -> 6.2E-1002 Underflow Subnormal Inexact Rounded -- test -0s precision: 9 powx560 power 0 0 -> NaN Invalid_operation powx561 power 0 -0 -> NaN Invalid_operation powx562 power -0 0 -> NaN Invalid_operation powx563 power -0 -0 -> NaN Invalid_operation powx564 power 1 0 -> 1 powx565 power 1 -0 -> 1 powx566 power -1 0 -> 1 powx567 power -1 -0 -> 1 powx568 power 0 1 -> 0 powx569 power 0 -1 -> Infinity powx570 power -0 1 -> -0 powx571 power -0 -1 -> -Infinity powx572 power 0 2 -> 0 powx573 power 0 -2 -> Infinity powx574 power -0 2 -> 0 powx575 power -0 -2 -> Infinity powx576 power 0 3 -> 0 powx577 power 0 -3 -> Infinity powx578 power -0 3 -> -0 powx579 power -0 -3 -> -Infinity -- Specials powx580 power Inf -Inf -> 0 powx581 power Inf -1000 -> 0 powx582 power Inf -1 -> 0 powx583 power Inf -0.5 -> 0 powx584 power Inf -0 -> 1 powx585 power Inf 0 -> 1 powx586 power Inf 0.5 -> Infinity powx587 power Inf 1 -> Infinity powx588 power Inf 1000 -> Infinity powx589 power Inf Inf -> Infinity powx590 power -1000 Inf -> NaN Invalid_operation powx591 power -Inf Inf -> NaN Invalid_operation powx592 power -1 Inf -> NaN Invalid_operation powx593 power -0.5 Inf -> NaN Invalid_operation powx594 power -0 Inf -> 0 powx595 power 0 Inf -> 0 powx596 power 0.5 Inf -> 0 powx597 power 1 Inf -> 1.00000000 Inexact Rounded powx598 power 1000 Inf -> Infinity powx599 power Inf Inf -> Infinity powx600 power -Inf -Inf -> NaN Invalid_operation powx601 power -Inf -1000 -> 0 powx602 power -Inf -1 -> -0 powx603 power -Inf -0.5 -> NaN Invalid_operation powx604 power -Inf -0 -> 1 powx605 power -Inf 0 -> 1 powx606 power -Inf 0.5 -> NaN Invalid_operation powx607 power -Inf 1 -> -Infinity powx608 power -Inf 1000 -> Infinity powx609 power -Inf Inf -> NaN Invalid_operation powx610 power -1000 Inf -> NaN Invalid_operation powx611 power -Inf -Inf -> NaN Invalid_operation powx612 power -1 -Inf -> NaN Invalid_operation powx613 power -0.5 -Inf -> NaN Invalid_operation powx614 power -0 -Inf -> Infinity powx615 power 0 -Inf -> Infinity powx616 power 0.5 -Inf -> Infinity powx617 power 1 -Inf -> 1.00000000 Inexact Rounded powx618 power 1000 -Inf -> 0 powx619 power Inf -Inf -> 0 powx621 power NaN -Inf -> NaN powx622 power NaN -1000 -> NaN powx623 power NaN -1 -> NaN powx624 power NaN -0.5 -> NaN powx625 power NaN -0 -> NaN powx626 power NaN 0 -> NaN powx627 power NaN 0.5 -> NaN powx628 power NaN 1 -> NaN powx629 power NaN 1000 -> NaN powx630 power NaN Inf -> NaN powx631 power NaN NaN -> NaN powx632 power -Inf NaN -> NaN powx633 power -1000 NaN -> NaN powx634 power -1 NaN -> NaN powx635 power -0 NaN -> NaN powx636 power 0 NaN -> NaN powx637 power 1 NaN -> NaN powx638 power 1000 NaN -> NaN powx639 power Inf NaN -> NaN powx641 power sNaN -Inf -> NaN Invalid_operation powx642 power sNaN -1000 -> NaN Invalid_operation powx643 power sNaN -1 -> NaN Invalid_operation powx644 power sNaN -0.5 -> NaN Invalid_operation powx645 power sNaN -0 -> NaN Invalid_operation powx646 power sNaN 0 -> NaN Invalid_operation powx647 power sNaN 0.5 -> NaN Invalid_operation powx648 power sNaN 1 -> NaN Invalid_operation powx649 power sNaN 1000 -> NaN Invalid_operation powx650 power sNaN NaN -> NaN Invalid_operation powx651 power sNaN sNaN -> NaN Invalid_operation powx652 power NaN sNaN -> NaN Invalid_operation powx653 power -Inf sNaN -> NaN Invalid_operation powx654 power -1000 sNaN -> NaN Invalid_operation powx655 power -1 sNaN -> NaN Invalid_operation powx656 power -0.5 sNaN -> NaN Invalid_operation powx657 power -0 sNaN -> NaN Invalid_operation powx658 power 0 sNaN -> NaN Invalid_operation powx659 power 0.5 sNaN -> NaN Invalid_operation powx660 power 1 sNaN -> NaN Invalid_operation powx661 power 1000 sNaN -> NaN Invalid_operation powx662 power Inf sNaN -> NaN Invalid_operation powx663 power NaN sNaN -> NaN Invalid_operation -- NaN propagation powx670 power NaN3 sNaN7 -> NaN7 Invalid_operation powx671 power sNaN8 NaN6 -> NaN8 Invalid_operation powx672 power 1 sNaN7 -> NaN7 Invalid_operation powx673 power sNaN8 1 -> NaN8 Invalid_operation powx674 power Inf sNaN7 -> NaN7 Invalid_operation powx675 power sNaN8 Inf -> NaN8 Invalid_operation powx676 power Inf NaN9 -> NaN9 powx677 power NaN6 Inf -> NaN6 powx678 power 1 NaN5 -> NaN5 powx679 power NaN2 1 -> NaN2 powx680 power NaN2 Nan4 -> NaN2 powx681 power NaN Nan4 -> NaN powx682 power NaN345 Nan -> NaN345 powx683 power Inf -sNaN7 -> -NaN7 Invalid_operation powx684 power -sNaN8 Inf -> -NaN8 Invalid_operation powx685 power Inf -NaN9 -> -NaN9 powx686 power -NaN6 Inf -> -NaN6 powx687 power -NaN2 -Nan4 -> -NaN2 -- long operand and RHS range checks maxexponent: 999 minexponent: -999 precision: 9 powx701 power 12345678000 1 -> 1.23456780E+10 Rounded powx702 power 1234567800 1 -> 1.23456780E+9 Rounded powx703 power 1234567890 1 -> 1.23456789E+9 Rounded powx704 power 1234567891 1 -> 1.23456789E+9 Inexact Rounded powx705 power 12345678901 1 -> 1.23456789E+10 Inexact Rounded powx706 power 1234567896 1 -> 1.23456790E+9 Inexact Rounded precision: 15 -- still checking powx741 power 12345678000 1 -> 12345678000 powx742 power 1234567800 1 -> 1234567800 powx743 power 1234567890 1 -> 1234567890 powx744 power 1234567891 1 -> 1234567891 powx745 power 12345678901 1 -> 12345678901 powx746 power 1234567896 1 -> 1234567896 maxexponent: 999999 minexponent: -999999 precision: 9 -- near out-of-range edge cases powx163 power '10' '999999' -> '1.00000000E+999999' Rounded powx164 power '10' '999998' -> '1.00000000E+999998' Rounded powx165 power '10' '999997' -> '1.00000000E+999997' Rounded powx166 power '10' '333333' -> '1.00000000E+333333' Rounded powx183 power '7' '1000000' -> 1.09651419E+845098 Inexact Rounded powx184 power '7' '1000001' -> 7.67559934E+845098 Inexact Rounded powx186 power '7' '-1000001' -> 1.30282986E-845099 Inexact Rounded powx187 power '7' '-1000000' -> 9.11980901E-845099 Inexact Rounded powx118 power '10' '-333333' -> 1E-333333 powx119 power '10' '-999998' -> 1E-999998 powx120 power '10' '-999999' -> 1E-999999 powx181 power '7' '999998' -> 2.23778406E+845096 Inexact Rounded powx182 power '7' '999999' -> 1.56644884E+845097 Inexact Rounded powx189 power '7' '-999999' -> 6.38386631E-845098 Inexact Rounded powx190 power '7' '-999998' -> 4.46870641E-845097 Inexact Rounded -- overflow and underflow tests precision: 9 powx277 power 9 999999 -> 3.59084629E+954241 Inexact Rounded powx278 power 9.99999999 999999 -> 9.99000501E+999998 Inexact Rounded powx279 power 10 999999 -> 1.00000000E+999999 Rounded powx280 power 10.0000001 999999 -> 1.01005016E+999999 Inexact Rounded powx281 power 10.000001 999999 -> 1.10517080E+999999 Inexact Rounded powx282 power 10.00001 999999 -> 2.71827775E+999999 Inexact Rounded powx283 power 10.0001 999999 -> Infinity Overflow Inexact Rounded powx285 power 11 999999 -> Infinity Overflow Inexact Rounded powx286 power 12 999999 -> Infinity Overflow Inexact Rounded powx287 power 999 999999 -> Infinity Overflow Inexact Rounded powx288 power 999999999 999999 -> Infinity Overflow Inexact Rounded powx289 power 9.9E999999999 999999 -> Infinity Overflow Inexact Rounded powx290 power 0.5 999999 -> 2.02006812E-301030 Inexact Rounded powx291 power 0.1 999999 -> 1E-999999 -- unrounded powx292 power 0.09 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx293 power 0.05 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx294 power 0.01 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx295 power 0.0001 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx297 power 0.0000001 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx298 power 0.0000000001 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx299 power 1E-999999999 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx310 power -9 999999 -> -3.59084629E+954241 Inexact Rounded powx311 power -10 999999 -> -1.00000000E+999999 Rounded powx312 power -10.0001 999999 -> -Infinity Overflow Inexact Rounded powx313 power -10.1 999999 -> -Infinity Overflow Inexact Rounded powx314 power -11 999999 -> -Infinity Overflow Inexact Rounded powx315 power -12 999999 -> -Infinity Overflow Inexact Rounded powx316 power -999 999999 -> -Infinity Overflow Inexact Rounded powx317 power -999999 999999 -> -Infinity Overflow Inexact Rounded powx318 power -999999999 999999 -> -Infinity Overflow Inexact Rounded powx319 power -9.9E999999999 999999 -> -Infinity Overflow Inexact Rounded powx320 power -0.5 999999 -> -2.02006812E-301030 Inexact Rounded powx321 power -0.1 999999 -> -1E-999999 powx322 power -0.09 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx323 power -0.05 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx324 power -0.01 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx325 power -0.0001 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx327 power -0.0000001 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx328 power -0.0000000001 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx329 power -1E-999999999 999999 -> -0E-1000007 Underflow Subnormal Inexact Rounded Clamped -- note no trim of next result powx330 power -9 999998 -> 3.98982921E+954240 Inexact Rounded powx331 power -10 999998 -> 1.00000000E+999998 Rounded powx332 power -10.0001 999998 -> Infinity Overflow Inexact Rounded powx333 power -10.1 999998 -> Infinity Overflow Inexact Rounded powx334 power -11 999998 -> Infinity Overflow Inexact Rounded powx335 power -12 999998 -> Infinity Overflow Inexact Rounded powx336 power -999 999998 -> Infinity Overflow Inexact Rounded powx337 power -999999 999998 -> Infinity Overflow Inexact Rounded powx338 power -999999999 999998 -> Infinity Overflow Inexact Rounded powx339 power -9.9E999999999 999998 -> Infinity Overflow Inexact Rounded powx340 power -0.5 999998 -> 4.04013624E-301030 Inexact Rounded powx341 power -0.1 999998 -> 1E-999998 -- NB exact unrounded powx342 power -0.09 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx343 power -0.05 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx344 power -0.01 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx345 power -0.0001 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx347 power -0.0000001 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx348 power -0.0000000001 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx349 power -1E-999999999 999998 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped -- some subnormals precision: 9 -- [precision is 9, so smallest exponent is -1000000007 powx350 power 1e-1 500000 -> 1E-500000 powx351 power 1e-2 999999 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx352 power 1e-2 500000 -> 1E-1000000 Subnormal powx353 power 1e-2 500001 -> 1E-1000002 Subnormal powx354 power 1e-2 500002 -> 1E-1000004 Subnormal powx355 power 1e-2 500003 -> 1E-1000006 Subnormal powx356 power 1e-2 500004 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped powx360 power 0.010001 500000 -> 5.17176082E-999979 Inexact Rounded powx361 power 0.010000001 500000 -> 1.0512711E-1000000 Underflow Subnormal Inexact Rounded powx362 power 0.010000001 500001 -> 1.05127E-1000002 Underflow Subnormal Inexact Rounded powx363 power 0.0100000009 500000 -> 1.0460279E-1000000 Underflow Subnormal Inexact Rounded powx364 power 0.0100000001 500000 -> 1.0050125E-1000000 Underflow Subnormal Inexact Rounded powx365 power 0.01 500000 -> 1E-1000000 Subnormal powx366 power 0.0099999999 500000 -> 9.950125E-1000001 Underflow Subnormal Inexact Rounded powx367 power 0.0099999998 500000 -> 9.900498E-1000001 Underflow Subnormal Inexact Rounded powx368 power 0.0099999997 500000 -> 9.851119E-1000001 Underflow Subnormal Inexact Rounded powx369 power 0.0099999996 500000 -> 9.801987E-1000001 Underflow Subnormal Inexact Rounded powx370 power 0.009 500000 -> 0E-1000007 Underflow Subnormal Inexact Rounded Clamped -- 1/subnormal -> overflow powx371 power 1e-1 -500000 -> 1E+500000 powx372 power 1e-2 -999999 -> Infinity Overflow Inexact Rounded powx373 power 1e-2 -500000 -> Infinity Overflow Inexact Rounded powx374 power 1e-2 -500001 -> Infinity Overflow Inexact Rounded powx375 power 1e-2 -500002 -> Infinity Overflow Inexact Rounded powx376 power 1e-2 -500003 -> Infinity Overflow Inexact Rounded powx377 power 1e-2 -500004 -> Infinity Overflow Inexact Rounded powx381 power 0.010001 -500000 -> 1.93357743E+999978 Inexact Rounded powx382 power 0.010000001 -500000 -> 9.51229427E+999999 Inexact Rounded powx383 power 0.010000001 -500001 -> Infinity Overflow Inexact Rounded powx384 power 0.0100000009 -500000 -> 9.55997484E+999999 Inexact Rounded powx385 power 0.0100000001 -500000 -> 9.95012479E+999999 Inexact Rounded powx386 power 0.01 -500000 -> Infinity Overflow Inexact Rounded powx387 power 0.009999 -500000 -> Infinity Overflow Inexact Rounded -- negative power giving subnormal powx388 power 100.000001 -500000 -> 9.950125E-1000001 Underflow Subnormal Inexact Rounded -- test some 'false integer' boundaries precision: 16 rounding: half_even maxExponent: 384 minExponent: -383 powx501 power 100 1E+1 -> 1.000000000000000E+20 Rounded powx502 power 100 1E+2 -> 1.000000000000000E+200 Rounded powx503 power 100 1E+3 -> Infinity Overflow Inexact Rounded powx504 power 100 1E+4 -> Infinity Overflow Inexact Rounded powx505 power 100 1E+5 -> Infinity Overflow Inexact Rounded powx506 power 100 1E+6 -> Infinity Overflow Inexact Rounded powx507 power 100 1E+7 -> Infinity Overflow Inexact Rounded powx508 power 100 1E+8 -> Infinity Overflow Inexact Rounded powx509 power 100 1E+9 -> Infinity Overflow Inexact Rounded powx510 power 100 1E+10 -> Infinity Overflow Inexact Rounded powx511 power 100 1E+11 -> Infinity Overflow Inexact Rounded powx512 power 100 1E+12 -> Infinity Overflow Inexact Rounded powx513 power 100 1E+13 -> Infinity Overflow Inexact Rounded powx514 power 100 1E+14 -> Infinity Overflow Inexact Rounded powx515 power 100 1E+15 -> Infinity Overflow Inexact Rounded powx516 power 100 1E+16 -> Infinity Overflow Inexact Rounded powx517 power 100 1E+17 -> Infinity Overflow Inexact Rounded powx518 power 100 1E+18 -> Infinity Overflow Inexact Rounded powx519 power 100 1E+19 -> Infinity Overflow Inexact Rounded powx520 power 100 1E+20 -> Infinity Overflow Inexact Rounded powx521 power 100 1E+21 -> Infinity Overflow Inexact Rounded powx522 power 100 1E+22 -> Infinity Overflow Inexact Rounded powx523 power 100 1E+23 -> Infinity Overflow Inexact Rounded powx524 power 100 1E+24 -> Infinity Overflow Inexact Rounded powx525 power 100 1E+25 -> Infinity Overflow Inexact Rounded powx526 power 100 1E+26 -> Infinity Overflow Inexact Rounded powx527 power 100 1E+27 -> Infinity Overflow Inexact Rounded powx528 power 100 1E+28 -> Infinity Overflow Inexact Rounded powx529 power 100 1E+29 -> Infinity Overflow Inexact Rounded powx530 power 100 1E+30 -> Infinity Overflow Inexact Rounded powx531 power 100 1E+40 -> Infinity Overflow Inexact Rounded powx532 power 100 1E+50 -> Infinity Overflow Inexact Rounded powx533 power 100 1E+100 -> Infinity Overflow Inexact Rounded powx534 power 100 1E+383 -> Infinity Overflow Inexact Rounded -- a check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 powx750 power 1.2347E-40 2 -> 1.524E-80 Inexact Rounded Subnormal Underflow -- Null tests powx900 power 1 # -> NaN Invalid_operation powx901 power # 1 -> NaN Invalid_operation ---------------------------------------------------------------------- -- Below here are tests with a precision or context outside of the -- -- decNumber 'mathematical functions' restricted range. These -- -- remain supported in decNumber to minimize breakage, but may be -- -- outside the range of other implementations. -- ---------------------------------------------------------------------- maxexponent: 999999999 minexponent: -999999999 precision: 9 powx1063 power '10' '999999999' -> '1.00000000E+999999999' Rounded powx1064 power '10' '999999998' -> '1.00000000E+999999998' Rounded powx1065 power '10' '999999997' -> '1.00000000E+999999997' Rounded powx1066 power '10' '333333333' -> '1.00000000E+333333333' Rounded -- next two are integer-out-of range powx1183 power '7' '1000000000' -> NaN Invalid_context powx1184 power '7' '1000000001' -> NaN Invalid_context powx1186 power '7' '-1000000001' -> 1.38243630E-845098041 Inexact Rounded powx1187 power '7' '-1000000000' -> 9.67705411E-845098041 Inexact Rounded -- out-of-range edge cases powx1118 power '10' '-333333333' -> 1E-333333333 powx1119 power '10' '-999999998' -> 1E-999999998 powx1120 power '10' '-999999999' -> 1E-999999999 powx1181 power '7' '999999998' -> 2.10892313E+845098038 Inexact Rounded powx1182 power '7' '999999999' -> 1.47624619E+845098039 Inexact Rounded powx1189 power '7' '-999999999' -> 6.77393787E-845098040 Inexact Rounded powx1190 power '7' '-999999998' -> 4.74175651E-845098039 Inexact Rounded -- A (rare) case where the last digit is not within 0.5 ULP with classic precision precision: 9 powx1215 power "-21971575.0E+31454441" "-7" -> "-4.04549502E-220181139" Inexact Rounded precision: 20 powx1216 power "-21971575.0E+31454441" "-7" -> "-4.0454950249324891788E-220181139" Inexact Rounded -- overflow and underflow tests precision: 9 powx1280 power 9 999999999 -> 3.05550054E+954242508 Inexact Rounded powx1281 power 10 999999999 -> 1.00000000E+999999999 Rounded powx1282 power 10.0001 999999999 -> Infinity Overflow Inexact Rounded powx1283 power 10.1 999999999 -> Infinity Overflow Inexact Rounded powx1284 power 11 999999999 -> Infinity Overflow Inexact Rounded powx1285 power 12 999999999 -> Infinity Overflow Inexact Rounded powx1286 power 999 999999999 -> Infinity Overflow Inexact Rounded powx1287 power 999999 999999999 -> Infinity Overflow Inexact Rounded powx1288 power 999999999 999999999 -> Infinity Overflow Inexact Rounded powx1289 power 9.9E999999999 999999999 -> Infinity Overflow Inexact Rounded powx1290 power 0.5 999999999 -> 4.33559594E-301029996 Inexact Rounded powx1291 power 0.1 999999999 -> 1E-999999999 -- unrounded powx1292 power 0.09 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1293 power 0.05 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1294 power 0.01 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1295 power 0.0001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1297 power 0.0000001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1298 power 0.0000000001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1299 power 1E-999999999 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1310 power -9 999999999 -> -3.05550054E+954242508 Inexact Rounded powx1311 power -10 999999999 -> -1.00000000E+999999999 Rounded powx1312 power -10.0001 999999999 -> -Infinity Overflow Inexact Rounded powx1313 power -10.1 999999999 -> -Infinity Overflow Inexact Rounded powx1314 power -11 999999999 -> -Infinity Overflow Inexact Rounded powx1315 power -12 999999999 -> -Infinity Overflow Inexact Rounded powx1316 power -999 999999999 -> -Infinity Overflow Inexact Rounded powx1317 power -999999 999999999 -> -Infinity Overflow Inexact Rounded powx1318 power -999999999 999999999 -> -Infinity Overflow Inexact Rounded powx1319 power -9.9E999999999 999999999 -> -Infinity Overflow Inexact Rounded powx1320 power -0.5 999999999 -> -4.33559594E-301029996 Inexact Rounded powx1321 power -0.1 999999999 -> -1E-999999999 powx1322 power -0.09 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1323 power -0.05 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1324 power -0.01 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1325 power -0.0001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1327 power -0.0000001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1328 power -0.0000000001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1329 power -1E-999999999 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- note no trim of next result powx1330 power -9 999999998 -> 3.39500060E+954242507 Inexact Rounded powx1331 power -10 999999998 -> 1.00000000E+999999998 Rounded powx1332 power -10.0001 999999998 -> Infinity Overflow Inexact Rounded powx1333 power -10.1 999999998 -> Infinity Overflow Inexact Rounded powx1334 power -11 999999998 -> Infinity Overflow Inexact Rounded powx1335 power -12 999999998 -> Infinity Overflow Inexact Rounded powx1336 power -999 999999998 -> Infinity Overflow Inexact Rounded powx1337 power -999999 999999998 -> Infinity Overflow Inexact Rounded powx1338 power -999999999 999999998 -> Infinity Overflow Inexact Rounded powx1339 power -9.9E999999999 999999998 -> Infinity Overflow Inexact Rounded powx1340 power -0.5 999999998 -> 8.67119187E-301029996 Inexact Rounded powx1341 power -0.1 999999998 -> 1E-999999998 -- NB exact unrounded powx1342 power -0.09 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1343 power -0.05 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1344 power -0.01 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1345 power -0.0001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1347 power -0.0000001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1348 power -0.0000000001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1349 power -1E-999999999 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- some subnormals precision: 9 -- [precision is 9, so smallest exponent is -1000000007 powx1350 power 1e-1 500000000 -> 1E-500000000 powx1351 power 1e-2 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1352 power 1e-2 500000000 -> 1E-1000000000 Subnormal powx1353 power 1e-2 500000001 -> 1E-1000000002 Subnormal powx1354 power 1e-2 500000002 -> 1E-1000000004 Subnormal powx1355 power 1e-2 500000003 -> 1E-1000000006 Subnormal powx1356 power 1e-2 500000004 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1360 power 0.010001 500000000 -> 4.34941988E-999978287 Inexact Rounded powx1361 power 0.010000001 500000000 -> 5.18469257E-999999979 Inexact Rounded powx1362 power 0.010000001 500000001 -> 5.18469309E-999999981 Inexact Rounded powx1363 power 0.0100000009 500000000 -> 3.49342003E-999999981 Inexact Rounded powx1364 power 0.0100000001 500000000 -> 1.48413155E-999999998 Inexact Rounded powx1365 power 0.01 500000000 -> 1E-1000000000 Subnormal powx1366 power 0.0099999999 500000000 -> 6.7379E-1000000003 Underflow Subnormal Inexact Rounded powx1367 power 0.0099999998 500000000 -> 4.54E-1000000005 Underflow Subnormal Inexact Rounded powx1368 power 0.0099999997 500000000 -> 3E-1000000007 Underflow Subnormal Inexact Rounded powx1369 power 0.0099999996 500000000 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped powx1370 power 0.009 500000000 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped -- 1/subnormal -> overflow powx1371 power 1e-1 -500000000 -> 1E+500000000 powx1372 power 1e-2 -999999999 -> Infinity Overflow Inexact Rounded powx1373 power 1e-2 -500000000 -> Infinity Overflow Inexact Rounded powx1374 power 1e-2 -500000001 -> Infinity Overflow Inexact Rounded powx1375 power 1e-2 -500000002 -> Infinity Overflow Inexact Rounded powx1376 power 1e-2 -500000003 -> Infinity Overflow Inexact Rounded powx1377 power 1e-2 -500000004 -> Infinity Overflow Inexact Rounded powx1381 power 0.010001 -500000000 -> 2.29915719E+999978286 Inexact Rounded powx1382 power 0.010000001 -500000000 -> 1.92875467E+999999978 Inexact Rounded powx1383 power 0.010000001 -500000001 -> 1.92875448E+999999980 Inexact Rounded powx1384 power 0.0100000009 -500000000 -> 2.86252438E+999999980 Inexact Rounded powx1385 power 0.0100000001 -500000000 -> 6.73794717E+999999997 Inexact Rounded powx1386 power 0.01 -500000000 -> Infinity Overflow Inexact Rounded powx1387 power 0.009999 -500000000 -> Infinity Overflow Inexact Rounded -- negative power giving subnormal powx1388 power 100.000001 -500000000 -> 6.7379E-1000000003 Underflow Subnormal Inexact Rounded ---------------------------------------------------------------------- -- Below here are the tests with a non-integer rhs, including the -- -- tests that previously caused Invalid operation. An integer-only -- -- (on rhs) implementation should handle all the tests above as -- -- shown, and would flag most of the following tests as Invalid. -- ---------------------------------------------------------------------- precision: 16 rounding: half_even maxExponent: 384 minExponent: -383 powx2000 power 7 '10000000000' -> Infinity Overflow Inexact Rounded powx2001 power 2 '2.000001' -> 4.000002772589683 Inexact Rounded powx2002 power 2 '2.00000000' -> 4 powx2003 power 2 '2.000000001' -> 4.000000002772589 Inexact Rounded powx2004 power 2 '2.0000000001' -> 4.000000000277259 Inexact Rounded powx2005 power 2 '2.00000000001' -> 4.000000000027726 Inexact Rounded powx2006 power 2 '2.000000000001' -> 4.000000000002773 Inexact Rounded powx2007 power 2 '2.0000000000001' -> 4.000000000000277 Inexact Rounded powx2008 power 2 '2.00000000000001' -> 4.000000000000028 Inexact Rounded powx2009 power 2 '2.000000000000001' -> 4.000000000000003 Inexact Rounded powx2010 power 2 '2.0000000000000001' -> 4.000000000000000 Inexact Rounded -- 1 234567890123456 powx2011 power 1 1234 -> 1 precision: 4 powx2012 power 1 1234 -> 1 precision: 3 powx2013 power 1 1234 -> 1 powx2014 power 1 12.34e+2 -> 1 powx2015 power 1 12.3 -> 1.00 Inexact Rounded powx2016 power 1 12.0 -> 1 powx2017 power 1 1.01 -> 1.00 Inexact Rounded powx2018 power 2 1.00 -> 2 powx2019 power 2 2.00 -> 4 precision: 9 powx2030 power 1 1.0001 -> 1.00000000 Inexact Rounded powx2031 power 1 1.0000001 -> 1.00000000 Inexact Rounded powx2032 power 1 1.0000000001 -> 1.00000000 Inexact Rounded powx2033 power 1 1.0000000000001 -> 1.00000000 Inexact Rounded precision: 5 powx2034 power 1 1.0001 -> 1.0000 Inexact Rounded powx2035 power 1 1.0000001 -> 1.0000 Inexact Rounded powx2036 power 1 1.0000000001 -> 1.0000 Inexact Rounded powx2037 power 1 1.0000000000001 -> 1.0000 Inexact Rounded powx2038 power 1 1.0000000000001 -> 1.0000 Inexact Rounded rounding: ceiling precision: 3 powx2039 power 1 1.01 -> 1.00 Inexact Rounded powx2040 power 1 12.3 -> 1.00 Inexact Rounded rounding: half_even -- 1 ** any integer, including big ones, should be exact powx2041 power 1 1000000000 -> 1 powx2042 power 1 9999999999 -> 1 powx2043 power 1 12345678000 -> 1 powx2044 power 1 1234567800 -> 1 powx2045 power 1 1234567890 -> 1 powx2046 power 1 11234567891 -> 1 powx2047 power 1 12345678901 -> 1 powx2048 power 1 1234567896 -> 1 powx2049 power 1 -1234567896 -> 1 powx2051 power 1 1000000000 -> 1 powx2052 power 1 -1000000000 -> 1 powx2053 power 1 12345678000 -> 1 powx2054 power 1 -1234567896 -> 1 powx2055 power 1 1000000000 -> 1 powx2056 power 1 4300000000 -> 1 powx2057 power 1 -1000000000 -> 1 -- negatives ... but not out of range for decNumber powx2061 power -1 100000 -> 1 powx2062 power -1 999999 -> -1 powx2063 power -1 1278000 -> 1 powx2064 power -1 127803 -> -1 powx2065 power -1 127890 -> 1 powx2066 power -1 1167891 -> -1 powx2067 power -1 1278901 -> -1 powx2068 power -1 127896 -> 1 powx2069 power -1 -167897 -> -1 powx2071 power -1 100000 -> 1 powx2072 power -1 -100001 -> -1 powx2073 power -1 1278000 -> 1 powx2074 power -1 -167896 -> 1 powx2075 power -1 100000 -> 1 powx2076 power -1 -100009 -> -1 -- The above were derived from the earlier version of power.decTest; -- now start new tests for power(x,y) for non-integer y precision: 9 -- tests from specification powx2081 power 2 3 -> '8' powx2082 power -2 3 -> '-8' powx2083 power 2 -3 -> '0.125' powx2084 power 1.7 '8' -> '69.7575744' Inexact Rounded powx2085 power 10 0.301029996 -> 2.00000000 Inexact Rounded powx2086 power Infinity '-1' -> '0' powx2087 power Infinity '0' -> '1' powx2088 power Infinity '1' -> 'Infinity' powx2089 power -Infinity '-1' -> '-0' powx2090 power -Infinity '0' -> '1' powx2091 power -Infinity '1' -> '-Infinity' powx2092 power -Infinity '2' -> 'Infinity' powx2093 power 0 0 -> 'NaN' Invalid_operation precision: 16 rounding: half_even maxExponent: 384 minExponent: -383 -- basics powx2100 power 1E-7 1E-7 -> 0.9999983881917339 Inexact Rounded powx2101 power 0.003 1E-7 -> 0.9999994190858697 Inexact Rounded powx2102 power 0.7 1E-7 -> 0.9999999643325062 Inexact Rounded powx2103 power 1.2 1E-7 -> 1.000000018232156 Inexact Rounded powx2104 power 71 1E-7 -> 1.000000426268079 Inexact Rounded powx2105 power 9E+9 1E-7 -> 1.000002292051668 Inexact Rounded powx2110 power 1E-7 0.003 -> 0.9527961640236519 Inexact Rounded powx2111 power 0.003 0.003 -> 0.9827235503366797 Inexact Rounded powx2112 power 0.7 0.003 -> 0.9989305474406207 Inexact Rounded powx2113 power 1.2 0.003 -> 1.000547114282834 Inexact Rounded powx2114 power 71 0.003 -> 1.012870156273545 Inexact Rounded powx2115 power 9E+9 0.003 -> 1.071180671278787 Inexact Rounded powx2120 power 1E-7 0.7 -> 0.00001258925411794167 Inexact Rounded powx2121 power 0.003 0.7 -> 0.01713897630281030 Inexact Rounded powx2122 power 0.7 0.7 -> 0.7790559126704491 Inexact Rounded powx2123 power 1.2 0.7 -> 1.136126977198889 Inexact Rounded powx2124 power 71 0.7 -> 19.76427300093870 Inexact Rounded powx2125 power 9E+9 0.7 -> 9289016.976853710 Inexact Rounded powx2130 power 1E-7 1.2 -> 3.981071705534973E-9 Inexact Rounded powx2131 power 0.003 1.2 -> 0.0009387403933595694 Inexact Rounded powx2132 power 0.7 1.2 -> 0.6518049405663864 Inexact Rounded powx2133 power 1.2 1.2 -> 1.244564747203978 Inexact Rounded powx2134 power 71 1.2 -> 166.5367244638552 Inexact Rounded powx2135 power 9E+9 1.2 -> 881233526124.8791 Inexact Rounded powx2140 power 1E-7 71 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2141 power 0.003 71 -> 7.509466514979725E-180 Inexact Rounded powx2142 power 0.7 71 -> 1.004525211269079E-11 Inexact Rounded powx2143 power 1.2 71 -> 418666.7483186515 Inexact Rounded powx2144 power 71 71 -> 2.750063734834616E+131 Inexact Rounded powx2145 power 9E+9 71 -> Infinity Inexact Rounded Overflow powx2150 power 1E-7 9E+9 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2151 power 0.003 9E+9 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2152 power 0.7 9E+9 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2153 power 1.2 9E+9 -> Infinity Inexact Rounded Overflow powx2154 power 71 9E+9 -> Infinity Inexact Rounded Overflow powx2155 power 9E+9 9E+9 -> Infinity Inexact Rounded Overflow -- number line milestones with lhs<1 and lhs>1 -- Overflow boundary (Nmax) powx2202 power 71 207.966651583983200 -> Infinity Inexact Rounded Overflow powx2201 power 71 207.966651583983199 -> 9.999999999999994E+384 Inexact Rounded powx2204 power 0.003 -152.603449817093577 -> Infinity Inexact Rounded Overflow powx2203 power 0.003 -152.603449817093576 -> 9.999999999999994E+384 Inexact Rounded -- Nmin boundary powx2211 power 71 -206.886305341988480 -> 1.000000000000005E-383 Inexact Rounded powx2212 power 71 -206.886305341988481 -> 1.000000000000001E-383 Inexact Rounded powx2213 power 71 -206.886305341988482 -> 9.99999999999997E-384 Inexact Rounded Underflow Subnormal powx2214 power 71 -206.886305341988483 -> 9.99999999999992E-384 Inexact Rounded Underflow Subnormal -- 9.999999999999924565357019820 powx2215 power 0.003 151.810704623238543 -> 1.000000000000009E-383 Inexact Rounded powx2216 power 0.003 151.810704623238544 -> 1.000000000000003E-383 Inexact Rounded powx2217 power 0.003 151.810704623238545 -> 9.99999999999997E-384 Inexact Rounded Underflow Subnormal powx2218 power 0.003 151.810704623238546 -> 9.99999999999991E-384 Inexact Rounded Underflow Subnormal -- Ntiny boundary, these edge cases determined using half_up rounding rounding: half_up powx2221 power 71 -215.151510469220498 -> 1E-398 Inexact Rounded Underflow Subnormal powx2222 power 71 -215.151510469220499 -> 1E-398 Inexact Rounded Underflow Subnormal powx2223 power 71 -215.151510469220500 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2224 power 71 -215.151510469220501 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2225 power 0.003 157.875613618285691 -> 1E-398 Inexact Rounded Underflow Subnormal powx2226 power 0.003 157.875613618285692 -> 1E-398 Inexact Rounded Underflow Subnormal powx2227 power 0.003 157.875613618285693 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped powx2228 power 0.003 220 -> 0E-398 Inexact Rounded Underflow Subnormal Clamped rounding: half_even -- power(10, y) are important ... -- Integer powers are exact, unless over/underflow powx2301 power 10 385 -> Infinity Overflow Inexact Rounded powx2302 power 10 384 -> 1.000000000000000E+384 Rounded powx2303 power 10 17 -> 1.000000000000000E+17 Rounded powx2304 power 10 16 -> 1.000000000000000E+16 Rounded powx2305 power 10 15 -> 1000000000000000 powx2306 power 10 10 -> 10000000000 powx2307 power 10 5 -> 100000 powx2308 power 10 1 -> 10 powx2309 power 10 0 -> 1 powx2310 power 10 -1 -> 0.1 powx2311 power 10 -5 -> 0.00001 powx2312 power 10 -6 -> 0.000001 powx2313 power 10 -7 -> 1E-7 powx2314 power 10 -8 -> 1E-8 powx2315 power 10 -9 -> 1E-9 powx2316 power 10 -10 -> 1E-10 powx2317 power 10 -383 -> 1E-383 powx2318 power 10 -384 -> 1E-384 Subnormal powx2319 power 10 -385 -> 1E-385 Subnormal powx2320 power 10 -397 -> 1E-397 Subnormal powx2321 power 10 -398 -> 1E-398 Subnormal powx2322 power 10 -399 -> 0E-398 Subnormal Underflow Inexact Rounded Clamped powx2323 power 10 -400 -> 0E-398 Subnormal Underflow Inexact Rounded Clamped -- Independent sanity check: 1961 Godfrey & Siddons four-figure logs powx2351 power 10 0.0000 -> 1 powx2352 power 10 0.3010 -> 1.999861869632744 Inexact Rounded powx2353 power 10 0.4771 -> 2.999853181190793 Inexact Rounded powx2354 power 10 0.6021 -> 4.000368510461250 Inexact Rounded powx2355 power 10 0.6990 -> 5.000345349769785 Inexact Rounded powx2356 power 10 0.7782 -> 6.000673538641164 Inexact Rounded powx2357 power 10 0.8451 -> 7.000031591308969 Inexact Rounded powx2358 power 10 0.9031 -> 8.000184448550990 Inexact Rounded powx2359 power 10 0.9542 -> 8.999119108700520 Inexact Rounded powx2360 power 10 0.9956 -> 9.899197750805841 Inexact Rounded powx2361 power 10 0.9996 -> 9.990793899844618 Inexact Rounded precision: 4 powx2371 power 10 0.0000 -> 1 powx2372 power 10 0.3010 -> 2.000 Inexact Rounded powx2373 power 10 0.4771 -> 3.000 Inexact Rounded powx2374 power 10 0.6021 -> 4.000 Inexact Rounded powx2375 power 10 0.6990 -> 5.000 Inexact Rounded powx2376 power 10 0.7782 -> 6.001 Inexact Rounded powx2377 power 10 0.8451 -> 7.000 Inexact Rounded powx2378 power 10 0.9031 -> 8.000 Inexact Rounded powx2379 power 10 0.9542 -> 8.999 Inexact Rounded powx2380 power 10 0.9956 -> 9.899 Inexact Rounded powx2381 power 10 0.9996 -> 9.991 Inexact Rounded -- 10**x ~=2 (inverse of the test in log10.decTest) precision: 50 powx2401 power 10 0.30102999566398119521373889472449302676818988146211 -> 2.0000000000000000000000000000000000000000000000000 Inexact Rounded precision: 49 powx2402 power 10 0.3010299956639811952137388947244930267681898814621 -> 2.000000000000000000000000000000000000000000000000 Inexact Rounded precision: 48 powx2403 power 10 0.301029995663981195213738894724493026768189881462 -> 2.00000000000000000000000000000000000000000000000 Inexact Rounded precision: 47 powx2404 power 10 0.30102999566398119521373889472449302676818988146 -> 2.0000000000000000000000000000000000000000000000 Inexact Rounded precision: 46 powx2405 power 10 0.3010299956639811952137388947244930267681898815 -> 2.000000000000000000000000000000000000000000000 Inexact Rounded precision: 45 powx2406 power 10 0.301029995663981195213738894724493026768189881 -> 2.00000000000000000000000000000000000000000000 Inexact Rounded precision: 44 powx2407 power 10 0.30102999566398119521373889472449302676818988 -> 2.0000000000000000000000000000000000000000000 Inexact Rounded precision: 43 powx2408 power 10 0.3010299956639811952137388947244930267681899 -> 2.000000000000000000000000000000000000000000 Inexact Rounded precision: 42 powx2409 power 10 0.301029995663981195213738894724493026768190 -> 2.00000000000000000000000000000000000000000 Inexact Rounded precision: 41 powx2410 power 10 0.30102999566398119521373889472449302676819 -> 2.0000000000000000000000000000000000000000 Inexact Rounded precision: 40 powx2411 power 10 0.3010299956639811952137388947244930267682 -> 2.000000000000000000000000000000000000000 Inexact Rounded precision: 39 powx2412 power 10 0.301029995663981195213738894724493026768 -> 2.00000000000000000000000000000000000000 Inexact Rounded precision: 38 powx2413 power 10 0.30102999566398119521373889472449302677 -> 2.0000000000000000000000000000000000000 Inexact Rounded precision: 37 powx2414 power 10 0.3010299956639811952137388947244930268 -> 2.000000000000000000000000000000000000 Inexact Rounded precision: 36 powx2415 power 10 0.301029995663981195213738894724493027 -> 2.00000000000000000000000000000000000 Inexact Rounded precision: 35 powx2416 power 10 0.30102999566398119521373889472449303 -> 2.0000000000000000000000000000000000 Inexact Rounded precision: 34 powx2417 power 10 0.3010299956639811952137388947244930 -> 2.000000000000000000000000000000000 Inexact Rounded precision: 33 powx2418 power 10 0.301029995663981195213738894724493 -> 2.00000000000000000000000000000000 Inexact Rounded precision: 32 powx2419 power 10 0.30102999566398119521373889472449 -> 2.0000000000000000000000000000000 Inexact Rounded precision: 31 powx2420 power 10 0.3010299956639811952137388947245 -> 2.000000000000000000000000000000 Inexact Rounded precision: 30 powx2421 power 10 0.301029995663981195213738894725 -> 2.00000000000000000000000000000 Inexact Rounded precision: 29 powx2422 power 10 0.30102999566398119521373889472 -> 2.0000000000000000000000000000 Inexact Rounded precision: 28 powx2423 power 10 0.3010299956639811952137388947 -> 2.000000000000000000000000000 Inexact Rounded precision: 27 powx2424 power 10 0.301029995663981195213738895 -> 2.00000000000000000000000000 Inexact Rounded precision: 26 powx2425 power 10 0.30102999566398119521373889 -> 2.0000000000000000000000000 Inexact Rounded precision: 25 powx2426 power 10 0.3010299956639811952137389 -> 2.000000000000000000000000 Inexact Rounded precision: 24 powx2427 power 10 0.301029995663981195213739 -> 2.00000000000000000000000 Inexact Rounded precision: 23 powx2428 power 10 0.30102999566398119521374 -> 2.0000000000000000000000 Inexact Rounded precision: 22 powx2429 power 10 0.3010299956639811952137 -> 2.000000000000000000000 Inexact Rounded precision: 21 powx2430 power 10 0.301029995663981195214 -> 2.00000000000000000000 Inexact Rounded precision: 20 powx2431 power 10 0.30102999566398119521 -> 2.0000000000000000000 Inexact Rounded precision: 19 powx2432 power 10 0.3010299956639811952 -> 2.000000000000000000 Inexact Rounded precision: 18 powx2433 power 10 0.301029995663981195 -> 2.00000000000000000 Inexact Rounded precision: 17 powx2434 power 10 0.30102999566398120 -> 2.0000000000000000 Inexact Rounded precision: 16 powx2435 power 10 0.3010299956639812 -> 2.000000000000000 Inexact Rounded precision: 15 powx2436 power 10 0.301029995663981 -> 2.00000000000000 Inexact Rounded precision: 14 powx2437 power 10 0.30102999566398 -> 2.0000000000000 Inexact Rounded precision: 13 powx2438 power 10 0.3010299956640 -> 2.000000000000 Inexact Rounded precision: 12 powx2439 power 10 0.301029995664 -> 2.00000000000 Inexact Rounded precision: 11 powx2440 power 10 0.30102999566 -> 2.0000000000 Inexact Rounded precision: 10 powx2441 power 10 0.3010299957 -> 2.000000000 Inexact Rounded precision: 9 powx2442 power 10 0.301029996 -> 2.00000000 Inexact Rounded precision: 8 powx2443 power 10 0.30103000 -> 2.0000000 Inexact Rounded precision: 7 powx2444 power 10 0.3010300 -> 2.000000 Inexact Rounded precision: 6 powx2445 power 10 0.301030 -> 2.00000 Inexact Rounded precision: 5 powx2446 power 10 0.30103 -> 2.0000 Inexact Rounded precision: 4 powx2447 power 10 0.3010 -> 2.000 Inexact Rounded precision: 3 powx2448 power 10 0.301 -> 2.00 Inexact Rounded precision: 2 powx2449 power 10 0.30 -> 2.0 Inexact Rounded precision: 1 powx2450 power 10 0.3 -> 2 Inexact Rounded maxExponent: 384 minExponent: -383 precision: 16 rounding: half_even -- Close-to-e tests precision: 34 powx2500 power 10 0.4342944819032518276511289189166048 -> 2.718281828459045235360287471352661 Inexact Rounded powx2501 power 10 0.4342944819032518276511289189166049 -> 2.718281828459045235360287471352661 Inexact Rounded powx2502 power 10 0.4342944819032518276511289189166050 -> 2.718281828459045235360287471352662 Inexact Rounded powx2503 power 10 0.4342944819032518276511289189166051 -> 2.718281828459045235360287471352663 Inexact Rounded powx2504 power 10 0.4342944819032518276511289189166052 -> 2.718281828459045235360287471352663 Inexact Rounded -- e**e, 16->34 powx2505 power 2.718281828459045 2.718281828459045 -> '15.15426224147925705633739513098219' Inexact Rounded -- Sequence around an integer powx2512 power 10 2.9999999999999999999999999999999997 -> 999.9999999999999999999999999999993 Inexact Rounded powx2513 power 10 2.9999999999999999999999999999999998 -> 999.9999999999999999999999999999995 Inexact Rounded powx2514 power 10 2.9999999999999999999999999999999999 -> 999.9999999999999999999999999999998 Inexact Rounded powx2515 power 10 3.0000000000000000000000000000000000 -> 1000 powx2516 power 10 3.0000000000000000000000000000000001 -> 1000.000000000000000000000000000000 Inexact Rounded powx2517 power 10 3.0000000000000000000000000000000002 -> 1000.000000000000000000000000000000 Inexact Rounded powx2518 power 10 3.0000000000000000000000000000000003 -> 1000.000000000000000000000000000001 Inexact Rounded -- randomly generated tests maxExponent: 384 minExponent: -383 -- P=34, within 0-999 -- positive arg2 Precision: 34 powx3201 power 5.301557744131969249145904611290735 369.3175647984435534243813466380579 -> 3.427165676345688240023113326603960E+267 Inexact Rounded powx3202 power 0.0000000000506875655819165973738225 21.93514102704466434121826965196878 -> 1.498169860033487321566659495340789E-226 Inexact Rounded powx3203 power 97.88877680721519917858007810494043 5.159898445242793470476673109899554 -> 18705942904.43290467281449559427982 Inexact Rounded powx3204 power 7.380441015594399747973924380493799 17.93614173904818313507525109033288 -> 3715757985820076.273336082702577274 Inexact Rounded powx3205 power 2.045623627647350918819219169855040 1082.999652407430697958175966996254 -> 4.208806435006704867447150904279854E+336 Inexact Rounded powx3206 power 0.0000000762582873112118926142955423 20.30534237055073996975203864170432 -> 2.967574278677013090697130349198877E-145 Inexact Rounded powx3207 power 0.0000000000194091470907814855660535 14.71164213947722238856835440242911 -> 2.564391397469554735037158345963280E-158 Inexact Rounded powx3208 power 0.0000000000509434185382818596853504 20.97051498204188277347203735421595 -> 1.420157372748083000927138678417272E-216 Inexact Rounded powx3209 power 0.0005389217212073307301395750745119 43.96798225485747315858678755538971 -> 1.957850185781292007977898626137240E-144 Inexact Rounded powx3210 power 498.5690105989136050444077447411198 128.1038813807243375878831104745803 -> 3.882212970903893127009102293596268E+345 Inexact Rounded powx3211 power 0.0000000935428918637303954281938975 5.736933454863278597460091596496099 -> 4.733219644540496152403967823635195E-41 Inexact Rounded powx3212 power 8.581586784734161309180363110126352 252.0229459968869784643374981477208 -> 1.907464842458674622356177850049873E+235 Inexact Rounded powx3213 power 294.1005302951621709143320795278305 155.5466374141708615975111014663722 -> 9.251717033292072959166737280729728E+383 Inexact Rounded powx3214 power 0.0000000041253343654396865855722090 19.00170974760425576247662125110472 -> 4.779566288553864405790921353593512E-160 Inexact Rounded powx3215 power 0.0000000000046912257352141395184092 24.66089523148729269098773236636878 -> 4.205126874048597849476723538057527E-280 Inexact Rounded powx3216 power 0.0000000000036796674296520639450494 22.09713956900694689234335912523078 -> 2.173081843837539818472071316420405E-253 Inexact Rounded powx3217 power 9.659887100303037657934372148567685 277.3765665424320875993026404492216 -> 1.614974043145519382749740616665041E+273 Inexact Rounded powx3218 power 0.0000083231310642229204398943076403 29.33123211782131466471359128190372 -> 1.013330439786660210757226597785328E-149 Inexact Rounded powx3219 power 0.0938084859086450954956863725653664 262.6091918199905272837286784975012 -> 1.262802485286301066967555821509344E-270 Inexact Rounded powx3220 power 8.194926977580900145696305910223304 184.3705133945546202012995485297248 -> 2.696353910907824016690021495828584E+168 Inexact Rounded powx3221 power 72.39594594653085161522285114566120 168.7721909489321402152033939836725 -> 7.379858293630460043361584410795031E+313 Inexact Rounded powx3222 power 0.0000000000003436856010144185445537 26.34329868961274988994452526178983 -> 4.585379573595865689605567720192768E-329 Inexact Rounded powx3223 power 20.18365633762226550254542489492623 127.2099705237021350103678072707790 -> 1.020919629336979353690271762206060E+166 Inexact Rounded powx3224 power 0.0000000553723990761530290129268131 8.157597566134754638015199501162405 -> 6.349030513396147480954474615067145E-60 Inexact Rounded powx3225 power 0.0001028742674265840656614682618035 93.99842317306603797965470281716482 -> 1.455871110222736531854990397769940E-375 Inexact Rounded powx3226 power 95.90195152775543876489746343266050 143.5992850002211509777720799352475 -> 3.881540015848530405189834366588567E+284 Inexact Rounded powx3227 power 0.0000000000041783747057233878360333 12.14591167764993506821334760954430 -> 6.190998557456885985124592807383163E-139 Inexact Rounded powx3228 power 0.5572830497086740798434917090018768 1001.921811263919522230330241349166 -> 3.871145158537170450093833881625838E-255 Inexact Rounded powx3229 power 516.4754759779093954790813881333232 29.23812463126309057800793645336343 -> 2.110986192408878294012450052929185E+79 Inexact Rounded powx3230 power 0.0000835892099464584776847299020706 27.64279992884843877453592659341588 -> 1.891535098905506689512376224943293E-113 Inexact Rounded powx3231 power 72.45836577748571838139900165184955 166.2562890735032545091688015160084 -> 1.784091549041561516923092542939141E+309 Inexact Rounded powx3232 power 305.1823317643335924007629563009032 83.01065159508472884219290136319623 -> 1.757493136164395229602456782779110E+206 Inexact Rounded powx3233 power 7.108527102951713603542835791733786 145.7057852766236365450463428821948 -> 1.285934774113104362663619896550528E+124 Inexact Rounded powx3234 power 6.471393503175464828149365697049824 64.11741937262455725284754171995720 -> 9.978990355881803195280027533011699E+51 Inexact Rounded powx3235 power 39.72898094138459885662380866268385 239.9677288017447400786672779735168 -> 5.422218208517098335832848487375086E+383 Inexact Rounded powx3236 power 0.0002865592332736973000183287329933 90.34733869590583787065642532641096 -> 8.293733126976212033209243257136796E-321 Inexact Rounded powx3237 power 0.0000011343384394864811195077357936 1.926568285528399656789140809399396 -> 3.516055639378350146874261077470142E-12 Inexact Rounded powx3238 power 0.0000000035321610295065299384889224 7.583861778824284092434085265265582 -> 7.970899823817369764381976286536230E-65 Inexact Rounded powx3239 power 657.5028301569352677543770758346683 90.55778453811965116200206020172758 -> 1.522530898581564200655160665723268E+255 Inexact Rounded powx3240 power 8.484756398325748879450577520251447 389.7468292476262478578280531222417 -> 8.595142803587368093392510310811218E+361 Inexact Rounded -- P=16, within 0-99 -- positive arg2 Precision: 16 powx3101 power 0.0000215524639223 48.37532522355252 -> 1.804663257287277E-226 Inexact Rounded powx3102 power 00.80705856227999 2706.777535121391 -> 1.029625065876157E-252 Inexact Rounded powx3103 power 3.445441676383689 428.5185892455830 -> 1.657401683096454E+230 Inexact Rounded powx3104 power 0.0040158689495826 159.5725558816240 -> 4.255743665762492E-383 Inexact Rounded powx3105 power 0.0000841553281215 38.32504413453944 -> 6.738653902512052E-157 Inexact Rounded powx3106 power 0.7322610252571353 502.1254457674118 -> 1.109978126985943E-68 Inexact Rounded powx3107 power 10.75052532144880 67.34180604734781 -> 2.873015019470189E+69 Inexact Rounded powx3108 power 26.20425952945617 104.6002671186488 -> 2.301859355777030E+148 Inexact Rounded powx3109 power 0.0000055737473850 31.16285859005424 -> 1.883348470100446E-164 Inexact Rounded powx3110 power 61.06096011360700 10.93608439088726 -> 3.382686473028249E+19 Inexact Rounded powx3111 power 9.340880853257137 179.9094938131726 -> 3.819299795937696E+174 Inexact Rounded powx3112 power 0.0000050767371756 72.03346394186741 -> 4.216236691569869E-382 Inexact Rounded powx3113 power 6.838478807860596 47.49665590602285 -> 4.547621630099203E+39 Inexact Rounded powx3114 power 0.1299324346439081 397.7440523576938 -> 3.065047705553981E-353 Inexact Rounded powx3115 power 0.0003418047034264 20.00516791512018 -> 4.546189665380487E-70 Inexact Rounded powx3116 power 0.0001276899611715 78.12968287355703 -> 5.960217405063995E-305 Inexact Rounded powx3117 power 25.93160588180509 252.6245071004620 -> 1.472171597589146E+357 Inexact Rounded powx3118 power 35.47516857763178 86.14723037360925 -> 3.324299908481125E+133 Inexact Rounded powx3119 power 0.0000048171086721 43.31965603038666 -> 4.572331516616228E-231 Inexact Rounded powx3120 power 17.97652681097851 144.4684576550292 -> 1.842509906097860E+181 Inexact Rounded powx3121 power 3.622765141518729 305.1948680344950 -> 4.132320967578704E+170 Inexact Rounded powx3122 power 0.0080959002453519 143.9899444945627 -> 6.474627812947047E-302 Inexact Rounded powx3123 power 9.841699927276571 299.2466668837188 -> 1.489097656208736E+297 Inexact Rounded powx3124 power 0.0786659206232355 347.4750796962570 -> 2.05764809646925E-384 Inexact Rounded Underflow Subnormal powx3125 power 0.0000084459792645 52.47348690745487 -> 6.076251876516942E-267 Inexact Rounded powx3126 power 27.86589909967504 191.7296537102283 -> 1.157064112989386E+277 Inexact Rounded powx3127 power 0.0000419907937234 58.44957702730767 -> 1.496950672075162E-256 Inexact Rounded powx3128 power 0.0000664977739382 80.06749213261876 -> 3.488517620107875E-335 Inexact Rounded powx3129 power 58.49554484886656 125.8480768373499 -> 2.449089862146640E+222 Inexact Rounded powx3130 power 15.02820060024449 212.3527988973338 -> 8.307913932682067E+249 Inexact Rounded powx3131 power 0.0002650089942992 30.92173123678761 -> 2.517827664836147E-111 Inexact Rounded powx3132 power 0.0007342977426578 69.49168880741123 -> 1.600168665674440E-218 Inexact Rounded powx3133 power 0.0063816068650629 150.1400094183812 -> 2.705057295799001E-330 Inexact Rounded powx3134 power 9.912921122728791 297.8274013633411 -> 4.967624993438900E+296 Inexact Rounded powx3135 power 1.988603563989245 768.4862967922182 -> 2.692842474899596E+229 Inexact Rounded powx3136 power 8.418014519517691 164.2431359980725 -> 9.106211585888836E+151 Inexact Rounded powx3137 power 6.068823604450686 120.2955212365837 -> 1.599431918105982E+94 Inexact Rounded powx3138 power 56.90062738303850 54.90468294683645 -> 2.312839177902428E+96 Inexact Rounded powx3139 power 5.710905139750871 73.44608752962156 -> 3.775876053709929E+55 Inexact Rounded powx3140 power 0.0000017446761203 1.223981492228899 -> 8.952936595465635E-8 Inexact Rounded -- P=7, within 0-9 -- positive arg2 Precision: 7 powx3001 power 8.738689 55.96523 -> 4.878180E+52 Inexact Rounded powx3002 power 0.0404763 147.4965 -> 3.689722E-206 Inexact Rounded powx3003 power 0.0604232 76.69778 -> 3.319183E-94 Inexact Rounded powx3004 power 0.0058855 107.5018 -> 1.768875E-240 Inexact Rounded powx3005 power 2.058302 1173.050 -> 5.778899E+367 Inexact Rounded powx3006 power 0.0056998 85.70157 -> 4.716783E-193 Inexact Rounded powx3007 power 0.8169297 3693.537 -> 4.475962E-325 Inexact Rounded powx3008 power 0.2810153 659.9568 -> 1.533177E-364 Inexact Rounded powx3009 power 4.617478 15.68308 -> 2.629748E+10 Inexact Rounded powx3010 power 0.0296418 244.2302 -> 6.207949E-374 Inexact Rounded powx3011 power 0.0036456 127.9987 -> 8.120891E-313 Inexact Rounded powx3012 power 0.5012813 577.5418 -> 6.088802E-174 Inexact Rounded powx3013 power 0.0033275 119.9800 -> 5.055049E-298 Inexact Rounded powx3014 power 0.0037652 111.7092 -> 1.560351E-271 Inexact Rounded powx3015 power 0.6463252 239.0568 -> 4.864564E-46 Inexact Rounded powx3016 power 4.784378 475.0521 -> 8.964460E+322 Inexact Rounded powx3017 power 4.610305 563.1791 -> 6.290298E+373 Inexact Rounded powx3018 power 0.0175167 80.52208 -> 3.623472E-142 Inexact Rounded powx3019 power 5.238307 356.7944 -> 4.011461E+256 Inexact Rounded powx3020 power 0.0003527 96.26347 -> 4.377932E-333 Inexact Rounded powx3021 power 0.0015155 136.0516 -> 2.57113E-384 Inexact Rounded Underflow Subnormal powx3022 power 5.753573 273.2340 -> 4.373184E+207 Inexact Rounded powx3023 power 7.778665 332.7917 -> 3.060640E+296 Inexact Rounded powx3024 power 1.432479 2046.064 -> 2.325829E+319 Inexact Rounded powx3025 power 5.610516 136.4563 -> 1.607502E+102 Inexact Rounded powx3026 power 0.0050697 137.4513 -> 3.522315E-316 Inexact Rounded powx3027 power 5.678737 85.16253 -> 1.713909E+64 Inexact Rounded powx3028 power 0.0816167 236.1973 -> 9.228802E-258 Inexact Rounded powx3029 power 0.2602805 562.0157 -> 2.944556E-329 Inexact Rounded powx3030 power 0.0080936 24.25367 -> 1.839755E-51 Inexact Rounded powx3031 power 4.092016 82.94603 -> 5.724948E+50 Inexact Rounded powx3032 power 0.0078255 7.204184 -> 6.675342E-16 Inexact Rounded powx3033 power 0.9917693 29846.44 -> 7.430177E-108 Inexact Rounded powx3034 power 1.610380 301.2467 -> 2.170142E+62 Inexact Rounded powx3035 power 0.0588236 212.1097 -> 1.023196E-261 Inexact Rounded powx3036 power 2.498069 531.4647 -> 2.054561E+211 Inexact Rounded powx3037 power 9.964342 326.5438 -> 1.089452E+326 Inexact Rounded powx3038 power 0.0820626 268.8718 -> 1.107350E-292 Inexact Rounded powx3039 power 6.176486 360.7779 -> 1.914449E+285 Inexact Rounded powx3040 power 4.206363 16.17288 -> 1.231314E+10 Inexact Rounded -- P=34, within 0-999 -- negative arg2 Precision: 34 powx3701 power 376.0915270000109486633402827007902 -35.69822349904102131649243701958463 -> 1.165722831225506457828653413200143E-92 Inexact Rounded powx3702 power 0.0000000503747440074613191665845314 -9.520308341497979093021813571450575 -> 3.000432478861883953977971226770410E+69 Inexact Rounded powx3703 power 290.6858731495339778337953407938308 -118.5459048597789693292455673428367 -> 9.357969047113989238392527565200302E-293 Inexact Rounded powx3704 power 4.598864607620052062908700928454182 -299.8323667698931125720218537483753 -> 2.069641269855413539579128114448478E-199 Inexact Rounded powx3705 power 2.556952676986830645708349254938903 -425.1755373251941383147998924703593 -> 4.428799777833598654260883861514638E-174 Inexact Rounded powx3706 power 0.0000005656198763404221986640610118 -32.83361380678301321230028730075315 -> 1.340270622401829145968477601029251E+205 Inexact Rounded powx3707 power 012.4841978642452960750801410372125 -214.3734291828712962809866663321921 -> 9.319857751170603140459057535971202E-236 Inexact Rounded powx3708 power 0.0000000056041586148066919174315551 -37.21129049213858341528033343116533 -> 1.118345010652454313186702341873169E+307 Inexact Rounded powx3709 power 0.0694569218941833767199998804202152 -8.697509072368973932501239815677732 -> 11862866995.51026489032838174290271 Inexact Rounded powx3710 power 6.380984024259450398729243522354144 -451.0635696889193561457985486366827 -> 8.800353109387322474809325670314330E-364 Inexact Rounded powx3711 power 786.0264840756809048288007204917801 -43.09935384678762773057342161718540 -> 1.616324183365644133979585419925934E-125 Inexact Rounded powx3712 power 96.07836427113204744101287948445130 -185.1414572546330024388914720271876 -> 8.586320815218383004023264980018610E-368 Inexact Rounded powx3713 power 0.0000000002332189796855870659792406 -5.779561613164628076880609893753327 -> 4.678450775876385793618570483345066E+55 Inexact Rounded powx3714 power 0.7254146672024602242369943237968857 -2115.512891397828615710130092245691 -> 8.539080958041689288202111403102495E+294 Inexact Rounded powx3715 power 0.0017380543649702864796144008592137 -6.307668017761022788220578633538713 -> 256309141459075651.2275798017695017 Inexact Rounded powx3716 power 05.29498758952276908267649116142379 -287.3233896734103442991981056134167 -> 1.039130027847489364009368608104291E-208 Inexact Rounded powx3717 power 15.64403593865932622003462779104178 -110.5296633358063267478609032002475 -> 9.750540276026524527375125980296142E-133 Inexact Rounded powx3718 power 89.69639006761571087634945077373508 -181.3209914139357665609268339422627 -> 8.335034232277762924539395632025281E-355 Inexact Rounded powx3719 power 6.974087483731006359914914110135058 -174.6815625746710345173615508179842 -> 4.553072265122011176641590109568031E-148 Inexact Rounded powx3720 power 0.0034393024010554821130553772681993 -93.60931598413919272595497100497364 -> 4.067468855817145539589988349449394E+230 Inexact Rounded powx3721 power 63.32834072300379155053737260965633 -168.3926799435088324825751446957616 -> 4.207907835462640471617519501741094E-304 Inexact Rounded powx3722 power 00.00216088174206276369011255907785 -70.12279562855442784757874508991013 -> 8.000657143378187029609343435067057E+186 Inexact Rounded powx3723 power 934.5957982703545893572134393004375 -102.2287735565878252484031426026726 -> 2.073813769209257617246544424827240E-304 Inexact Rounded powx3724 power 107.9116792558793921873995885441177 -44.11941092260869786313838181499158 -> 2.005476533631183268912552168759595E-90 Inexact Rounded powx3725 power 0.0000000000188049827381428191769262 -19.32118917192242027966847501724073 -> 1.713174297100918857053338286389034E+207 Inexact Rounded powx3726 power 614.9820907366248142166636259027728 -4.069913257030791586645250035698123 -> 4.462432572576935752713876293746717E-12 Inexact Rounded powx3727 power 752.0655175769182096165651274049422 -22.59292060348797472013598378334370 -> 1.039881526694635205040192531504131E-65 Inexact Rounded powx3728 power 72.20446632047659449616175456059013 -175.4705356401853924020842356605072 -> 7.529540175791582421966947814549028E-327 Inexact Rounded powx3729 power 518.8346486600403405764055847937416 -65.87320268592761588756963215588232 -> 1.420189426992170936958891180073151E-179 Inexact Rounded powx3730 power 3.457164372003960576453458502270716 -440.3201118177861273814529713443698 -> 6.176418595751201287186292664257369E-238 Inexact Rounded powx3731 power 7.908352793344189720739467675503991 -298.6646112894719680394152664740255 -> 5.935857120229147638104675057695125E-269 Inexact Rounded powx3732 power 0.0000004297399403788595027926075086 -22.66504617185071293588817501468339 -> 2.012270405520600820469665145636204E+144 Inexact Rounded powx3733 power 0.0000008592124097322966354868716443 -9.913109586558030204789520190180906 -> 1.354958763843310237046818832755215E+60 Inexact Rounded powx3734 power 161.4806080561258105880907470989925 -70.72907837434814261716311990271578 -> 6.632555003698945544941329872901929E-157 Inexact Rounded powx3735 power 0.0000000090669568624173832705631918 -36.53759624613665940127058439106640 -> 7.161808401023414735428130112941559E+293 Inexact Rounded powx3736 power 0.0000000000029440295978365709342752 -1.297354238738921988884421117731562 -> 911731060579291.7661267358872917380 Inexact Rounded powx3737 power 21.37477220144832172175460425143692 -76.95949933640539226475686997477889 -> 4.481741242418091914011962399912885E-103 Inexact Rounded powx3738 power 0.0000000000186657798201636342150903 -20.18296240350678245567049161730909 -> 3.483954007114900406906338526575672E+216 Inexact Rounded powx3739 power 0.0006522464792960191985996959126792 -80.03762491483514679886504099194414 -> 9.266548513614215557228467517053035E+254 Inexact Rounded powx3740 power 0.0000000032851343694200568966168055 -21.53462116926375512242403160008026 -> 4.873201679668455240861376213601189E+182 Inexact Rounded -- P=16, within 0-99 -- negative arg2 Precision: 16 powx3601 power 0.0000151338748474 -40.84655618364688 -> 7.628470824137755E+196 Inexact Rounded powx3602 power 0.1542771848654862 -435.8830009466800 -> 6.389817177800744E+353 Inexact Rounded powx3603 power 48.28477749367364 -218.5929209902050 -> 8.531049532576154E-369 Inexact Rounded powx3604 power 7.960775891584911 -12.78113732182505 -> 3.053270889769488E-12 Inexact Rounded powx3605 power 0.9430340651863058 -9010.470056913748 -> 3.313374654923807E+229 Inexact Rounded powx3606 power 0.0000202661501602 -65.57915207383306 -> 5.997379176536464E+307 Inexact Rounded powx3607 power 04.33007440798390 -232.0476834666588 -> 2.007827183010456E-148 Inexact Rounded powx3608 power 0.0000141944643914 -11.32407921958717 -> 7.902934485074846E+54 Inexact Rounded powx3609 power 0.0000021977758261 -53.53706138253307 -> 8.195631772317815E+302 Inexact Rounded powx3610 power 39.51297655474188 -19.40370976012326 -> 1.040699608072659E-31 Inexact Rounded powx3611 power 38.71210232488775 -66.58341618227921 -> 1.886855066146495E-106 Inexact Rounded powx3612 power 0.0000804235229062 -6.715207948992859 -> 3.134757864389333E+27 Inexact Rounded powx3613 power 0.0000073547092399 -11.27725685719934 -> 7.781428390953695E+57 Inexact Rounded powx3614 power 52.72181272599316 -186.1422311607435 -> 2.916601998744177E-321 Inexact Rounded powx3615 power 0.0969519963083306 -280.8220862151369 -> 3.955906885970987E+284 Inexact Rounded powx3616 power 94.07263302150081 -148.2031146071230 -> 3.361958990752490E-293 Inexact Rounded powx3617 power 85.80286965053704 -90.21453695813759 -> 3.715602429645798E-175 Inexact Rounded powx3618 power 03.52699858152259 -492.0414362539196 -> 4.507309220081092E-270 Inexact Rounded powx3619 power 0.0508278086396068 -181.0871731572167 -> 2.034428013017949E+234 Inexact Rounded powx3620 power 0.395576740303172 -915.5524507432392 -> 5.706585187437578E+368 Inexact Rounded powx3621 power 38.06105826789202 -49.75913753435335 -> 2.273188991431738E-79 Inexact Rounded powx3622 power 0.0003656748910646 -73.28988491310354 -> 7.768936940568763E+251 Inexact Rounded powx3623 power 0.0000006373551809 -51.30825234200690 -> 7.697618167701985E+317 Inexact Rounded powx3624 power 82.41729920673856 -35.73319631625699 -> 3.424042354585529E-69 Inexact Rounded powx3625 power 0.7845821453127670 -971.4982028897663 -> 2.283415527661089E+102 Inexact Rounded powx3626 power 4.840983673433497 -182.3730452370515 -> 1.220591407927770E-125 Inexact Rounded powx3627 power 0.0000006137592139 -2.122139474431484 -> 15231217034839.29 Inexact Rounded powx3628 power 0.0003657962862984 -35.97993782448099 -> 4.512701319250839E+123 Inexact Rounded powx3629 power 40.93693004443150 -165.1362408792997 -> 6.044276411057239E-267 Inexact Rounded powx3630 power 0.2941552583028898 -17.41046264945892 -> 1787833103.503346 Inexact Rounded powx3631 power 63.99335135369977 -69.92417205168579 -> 5.099359804872509E-127 Inexact Rounded powx3632 power 0.0000657924467388 -89.14497293588313 -> 6.145878266688521E+372 Inexact Rounded powx3633 power 11.35071250339147 -323.3705865614542 -> 6.863626248766775E-342 Inexact Rounded powx3634 power 23.88024718470895 -277.7117513329510 -> 2.006441422612815E-383 Inexact Rounded powx3635 power 0.0000009111939914 -58.51782946929182 -> 2.954352883996773E+353 Inexact Rounded powx3636 power 0.0000878179048782 -75.81060420238669 -> 3.306878455207585E+307 Inexact Rounded powx3637 power 07.39190564273779 -287.5047307244636 -> 1.692080354659805E-250 Inexact Rounded powx3638 power 0.0000298310819799 -1.844740377759355 -> 222874718.7238888 Inexact Rounded powx3639 power 0.0000006412929384 -28.24850078229290 -> 8.737164230666529E+174 Inexact Rounded powx3640 power 0.0000010202965998 -47.17573701956498 -> 4.392845306049341E+282 Inexact Rounded -- P=7, within 0-9 -- negative arg2 Precision: 7 powx3501 power 0.326324 -71.96509 -> 1.000673E+35 Inexact Rounded powx3502 power 0.0017635 -0.7186967 -> 95.28419 Inexact Rounded powx3503 power 8.564155 -253.0899 -> 8.850512E-237 Inexact Rounded powx3504 power 8.987272 -2.155789 -> 0.008793859 Inexact Rounded powx3505 power 9.604856 -139.9630 -> 3.073492E-138 Inexact Rounded powx3506 power 0.8472919 -2539.085 -> 5.372686E+182 Inexact Rounded powx3507 power 5.312329 -60.32965 -> 1.753121E-44 Inexact Rounded powx3508 power 0.0338294 -100.5440 -> 7.423939E+147 Inexact Rounded powx3509 power 0.0017777 -130.8583 -> 7.565629E+359 Inexact Rounded powx3510 power 8.016154 -405.5689 -> 2.395977E-367 Inexact Rounded powx3511 power 5.016570 -327.8906 -> 2.203784E-230 Inexact Rounded powx3512 power 0.8161743 -744.5276 -> 4.786899E+65 Inexact Rounded powx3513 power 0.0666343 -164.7320 -> 5.951240E+193 Inexact Rounded powx3514 power 0.0803966 -202.2666 -> 2.715512E+221 Inexact Rounded powx3515 power 0.0014752 -12.55547 -> 3.518905E+35 Inexact Rounded powx3516 power 9.737565 -14.69615 -> 2.975672E-15 Inexact Rounded powx3517 power 0.6634172 -152.7308 -> 1.654458E+27 Inexact Rounded powx3518 power 0.0009337 -33.32939 -> 9.575039E+100 Inexact Rounded powx3519 power 8.679922 -224.4194 -> 2.392446E-211 Inexact Rounded powx3520 power 7.390494 -161.9483 -> 2.088375E-141 Inexact Rounded powx3521 power 0.4631489 -417.1673 -> 2.821106E+139 Inexact Rounded powx3522 power 0.0095471 -7.677458 -> 3.231855E+15 Inexact Rounded powx3523 power 6.566339 -176.1867 -> 9.965633E-145 Inexact Rounded powx3524 power 2.696128 -26.15501 -> 5.419731E-12 Inexact Rounded powx3525 power 0.4464366 -852.1893 -> 2.957725E+298 Inexact Rounded powx3526 power 0.4772006 -921.4111 -> 1.118105E+296 Inexact Rounded powx3527 power 8.923696 -359.2211 -> 3.501573E-342 Inexact Rounded powx3528 power 0.0018008 -66.91252 -> 4.402718E+183 Inexact Rounded powx3529 power 0.0811964 -92.83278 -> 1.701111E+101 Inexact Rounded powx3530 power 0.0711219 -58.94347 -> 4.644148E+67 Inexact Rounded powx3531 power 7.958121 -50.66123 -> 2.311161E-46 Inexact Rounded powx3532 power 6.106466 -81.83610 -> 4.943285E-65 Inexact Rounded powx3533 power 4.557634 -129.5268 -> 4.737917E-86 Inexact Rounded powx3534 power 0.0027348 -9.180135 -> 3.383524E+23 Inexact Rounded powx3535 power 0.0083924 -46.24016 -> 9.996212E+95 Inexact Rounded powx3536 power 2.138523 -47.25897 -> 2.507009E-16 Inexact Rounded powx3537 power 1.626728 -1573.830 -> 2.668117E-333 Inexact Rounded powx3538 power 0.082615 -164.5842 -> 1.717882E+178 Inexact Rounded powx3539 power 7.636003 -363.6763 -> 8.366174E-322 Inexact Rounded powx3540 power 0.0021481 -138.0065 -> 1.562505E+368 Inexact Rounded -- Invalid operations due to restrictions -- [next two probably skipped by most test harnesses] precision: 100000000 powx4001 power 1 1.1 -> NaN Invalid_context precision: 99999999 powx4002 power 1 1.1 -> NaN Invalid_context precision: 9 maxExponent: 1000000 minExponent: -999999 powx4003 power 1 1.1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999999 powx4004 power 1 1.1 -> 1.00000000 Inexact Rounded maxExponent: 999999 minExponent: -1000000 powx4005 power 1 1.1 -> NaN Invalid_context maxExponent: 999999 minExponent: -999998 powx4006 power 1 1.1 -> 1.00000000 Inexact Rounded -- operand range violations powx4007 power 1 1.1E+999999 -> 1 powx4008 power 1 1.1E+1000000 -> NaN Invalid_operation powx4009 power 1.1E+999999 1.1 -> Infinity Overflow Inexact Rounded powx4010 power 1.1E+1000000 1.1 -> NaN Invalid_operation powx4011 power 1 1.1E-1999997 -> 1.00000000 Inexact Rounded powx4012 power 1 1.1E-1999998 -> NaN Invalid_operation powx4013 power 1.1E-1999997 1.1 -> 0E-1000006 Underflow Inexact Rounded Clamped Subnormal powx4014 power 1.1E-1999998 1.1 -> NaN Invalid_operation -- rounding modes -- power is sensitive precision: 7 maxExponent: 99 minExponent: -99 -- 0.7 ** 3.3 => 0.30819354053418943822 -- 0.7 ** 3.4 => 0.29739477638272533854 -- -1.2 ** 17 => -22.18611106740436992 -- -1.3 ** 17 => -86.50415919381337933 -- 0.5 ** 11 => 0.00048828125 -- 3.15 ** 3 => 31.255875 rounding: up powx4100 power 0.7 3.3 -> 0.3081936 Inexact Rounded powx4101 power 0.7 3.4 -> 0.2973948 Inexact Rounded powx4102 power -1.2 17 -> -22.18612 Inexact Rounded powx4103 power -1.3 17 -> -86.50416 Inexact Rounded powx4104 power 17 81.27115 -> 9.999974E+99 Inexact Rounded powx4105 power 17 81.27116 -> Infinity Overflow Inexact Rounded rounding: down powx4120 power 0.7 3.3 -> 0.3081935 Inexact Rounded powx4121 power 0.7 3.4 -> 0.2973947 Inexact Rounded powx4122 power -1.2 17 -> -22.18611 Inexact Rounded powx4123 power -1.3 17 -> -86.50415 Inexact Rounded powx4124 power 17 81.27115 -> 9.999973E+99 Inexact Rounded powx4125 power 17 81.27116 -> 9.999999E+99 Overflow Inexact Rounded rounding: floor powx4140 power 0.7 3.3 -> 0.3081935 Inexact Rounded powx4141 power 0.7 3.4 -> 0.2973947 Inexact Rounded powx4142 power -1.2 17 -> -22.18612 Inexact Rounded powx4143 power -1.3 17 -> -86.50416 Inexact Rounded powx4144 power 17 81.27115 -> 9.999973E+99 Inexact Rounded powx4145 power 17 81.27116 -> 9.999999E+99 Overflow Inexact Rounded rounding: ceiling powx4160 power 0.7 3.3 -> 0.3081936 Inexact Rounded powx4161 power 0.7 3.4 -> 0.2973948 Inexact Rounded powx4162 power -1.2 17 -> -22.18611 Inexact Rounded powx4163 power -1.3 17 -> -86.50415 Inexact Rounded powx4164 power 17 81.27115 -> 9.999974E+99 Inexact Rounded powx4165 power 17 81.27116 -> Infinity Overflow Inexact Rounded rounding: half_up powx4180 power 0.7 3.3 -> 0.3081935 Inexact Rounded powx4181 power 0.7 3.4 -> 0.2973948 Inexact Rounded powx4182 power -1.2 17 -> -22.18611 Inexact Rounded powx4183 power -1.3 17 -> -86.50416 Inexact Rounded powx4184 power 0.5 11 -> 0.0004882813 Inexact Rounded powx4185 power 3.15 3 -> 31.25588 Inexact Rounded powx4186 power 17 81.27115 -> 9.999974E+99 Inexact Rounded powx4187 power 17 81.27116 -> Infinity Overflow Inexact Rounded rounding: half_even powx4200 power 0.7 3.3 -> 0.3081935 Inexact Rounded powx4201 power 0.7 3.4 -> 0.2973948 Inexact Rounded powx4202 power -1.2 17 -> -22.18611 Inexact Rounded powx4203 power -1.3 17 -> -86.50416 Inexact Rounded powx4204 power 0.5 11 -> 0.0004882812 Inexact Rounded powx4205 power 3.15 3 -> 31.25588 Inexact Rounded powx4206 power 17 81.27115 -> 9.999974E+99 Inexact Rounded powx4207 power 17 81.27116 -> Infinity Overflow Inexact Rounded rounding: half_down powx4220 power 0.7 3.3 -> 0.3081935 Inexact Rounded powx4221 power 0.7 3.4 -> 0.2973948 Inexact Rounded powx4222 power -1.2 17 -> -22.18611 Inexact Rounded powx4223 power -1.3 17 -> -86.50416 Inexact Rounded powx4224 power 0.5 11 -> 0.0004882812 Inexact Rounded powx4225 power 3.15 3 -> 31.25587 Inexact Rounded powx4226 power -3.15 3 -> -31.25587 Inexact Rounded powx4227 power 17 81.27115 -> 9.999974E+99 Inexact Rounded powx4228 power 17 81.27116 -> Infinity Overflow Inexact Rounded -- more rounding tests as per Ilan Nehama's suggestions & analysis -- these are likely to show > 0.5 ulp error for very small powers precision: 7 maxExponent: 96 minExponent: -95 -- For x=nextfp(1)=1.00..001 (where the number of 0s is precision-2) -- power(x,y)=x when the rounding is up (e.g., toward_pos_inf or -- ceil) for any y in (0,1]. rounding: ceiling powx4301 power 1.000001 0 -> 1 -- The next test should be skipped for decNumber powx4302 power 1.000001 1e-101 -> 1.000001 Inexact Rounded -- The next test should be skipped for decNumber powx4303 power 1.000001 1e-95 -> 1.000001 Inexact Rounded powx4304 power 1.000001 1e-10 -> 1.000001 Inexact Rounded powx4305 power 1.000001 0.1 -> 1.000001 Inexact Rounded powx4306 power 1.000001 0.1234567 -> 1.000001 Inexact Rounded powx4307 power 1.000001 0.7 -> 1.000001 Inexact Rounded powx4308 power 1.000001 0.9999999 -> 1.000001 Inexact Rounded powx4309 power 1.000001 1.000000 -> 1.000001 -- power(x,y)=1 when the rounding is down (e.g. toward_zero or -- floor) for any y in [0,1). rounding: floor powx4321 power 1.000001 0 -> 1 powx4322 power 1.000001 1e-101 -> 1.000000 Inexact Rounded powx4323 power 1.000001 1e-95 -> 1.000000 Inexact Rounded powx4324 power 1.000001 1e-10 -> 1.000000 Inexact Rounded powx4325 power 1.000001 0.1 -> 1.000000 Inexact Rounded powx4326 power 1.000001 0.1234567 -> 1.000000 Inexact Rounded powx4327 power 1.000001 0.7 -> 1.000000 Inexact Rounded powx4328 power 1.000001 0.9999999 -> 1.000000 Inexact Rounded powx4329 power 1.000001 1.000000 -> 1.000001 -- For x=prevfp(1)=0.99..99 (where the number of 9s is precision) -- power(x,y)=x when the rounding is down for any y in (0,1]. rounding: floor powx4341 power 0.9999999 0 -> 1 -- The next test should be skipped for decNumber powx4342 power 0.9999999 1e-101 -> 0.9999999 Inexact Rounded -- The next test should be skipped for decNumber powx4343 power 0.9999999 1e-95 -> 0.9999999 Inexact Rounded powx4344 power 0.9999999 1e-10 -> 0.9999999 Inexact Rounded powx4345 power 0.9999999 0.1 -> 0.9999999 Inexact Rounded powx4346 power 0.9999999 0.1234567 -> 0.9999999 Inexact Rounded powx4347 power 0.9999999 0.7 -> 0.9999999 Inexact Rounded powx4348 power 0.9999999 0.9999999 -> 0.9999999 Inexact Rounded powx4349 power 0.9999999 1.000000 -> 0.9999999 -- power(x,y)=1 when the rounding is up for any y in (0,1]. rounding: ceiling powx4361 power 0.9999999 0 -> 1 powx4362 power 0.9999999 1e-101 -> 1.000000 Inexact Rounded powx4363 power 0.9999999 1e-95 -> 1.000000 Inexact Rounded powx4364 power 0.9999999 1e-10 -> 1.000000 Inexact Rounded powx4365 power 0.9999999 0.1 -> 1.000000 Inexact Rounded powx4366 power 0.9999999 0.1234567 -> 1.000000 Inexact Rounded powx4367 power 0.9999999 0.7 -> 1.000000 Inexact Rounded powx4368 power 0.9999999 0.9999999 -> 1.000000 Inexact Rounded powx4369 power 0.9999999 1.000000 -> 0.9999999 -- For x=nextfp(0) -- power(x,y)=0 when the rounding is down for any y larger than 1. rounding: floor powx4382 power 1e-101 0 -> 1 powx4383 power 1e-101 0.9999999 -> 1E-101 Underflow Subnormal Inexact Rounded powx4384 power 1e-101 1.000000 -> 1E-101 Subnormal powx4385 power 1e-101 1.000001 -> 0E-101 Underflow Subnormal Inexact Rounded Clamped powx4386 power 1e-101 2.000000 -> 0E-101 Underflow Subnormal Inexact Rounded Clamped apd-3.2.1/testdata/powersqrt.decTest000066400000000000000000004655651450022325000174730ustar00rootroot00000000000000------------------------------------------------------------------------ -- powersqrt.decTest -- decimal square root, using power -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- These testcases are taken from squareroot.decTest but are -- evaluated using the power operator. The differences in results -- (153 out of 2856) fall into the following categories: -- -- x ** 0.5 (x>0) has no preferred exponent, and is Inexact -- (and hence full precision); almost all differences are -- in this category -- 0.00 ** 0.5 becomes 0 (not 0.0), etc. -- -0 ** 0.5 becomes 0 (never -0) -- Some exact subnormals become inexact and hence underflows extended: 1 precision: 9 rounding: half_even maxExponent: 384 minexponent: -383 -- basics pwsx001 power 1 0.5 -> 1.00000000 Inexact Rounded pwsx002 power -1 0.5 -> NaN Invalid_operation pwsx003 power 1.00 0.5 -> 1.00000000 Inexact Rounded pwsx004 power -1.00 0.5 -> NaN Invalid_operation pwsx005 power 0 0.5 -> 0 pwsx006 power 00.0 0.5 -> 0 pwsx007 power 0.00 0.5 -> 0 pwsx008 power 00.00 0.5 -> 0 pwsx009 power 00.000 0.5 -> 0 pwsx010 power 00.0000 0.5 -> 0 pwsx011 power 00 0.5 -> 0 pwsx012 power -2 0.5 -> NaN Invalid_operation pwsx013 power 2 0.5 -> 1.41421356 Inexact Rounded pwsx014 power -2.00 0.5 -> NaN Invalid_operation pwsx015 power 2.00 0.5 -> 1.41421356 Inexact Rounded pwsx016 power -0 0.5 -> 0 pwsx017 power -0.0 0.5 -> 0 pwsx018 power -00.00 0.5 -> 0 pwsx019 power -00.000 0.5 -> 0 pwsx020 power -0.0000 0.5 -> 0 pwsx021 power -0E+9 0.5 -> 0 pwsx022 power -0E+10 0.5 -> 0 pwsx023 power -0E+11 0.5 -> 0 pwsx024 power -0E+12 0.5 -> 0 pwsx025 power -00 0.5 -> 0 pwsx026 power 0E+5 0.5 -> 0 pwsx027 power 4.0 0.5 -> 2.00000000 Inexact Rounded pwsx028 power 4.00 0.5 -> 2.00000000 Inexact Rounded pwsx030 power +0.1 0.5 -> 0.316227766 Inexact Rounded pwsx031 power -0.1 0.5 -> NaN Invalid_operation pwsx032 power +0.01 0.5 -> 0.100000000 Inexact Rounded pwsx033 power -0.01 0.5 -> NaN Invalid_operation pwsx034 power +0.001 0.5 -> 0.0316227766 Inexact Rounded pwsx035 power -0.001 0.5 -> NaN Invalid_operation pwsx036 power +0.000001 0.5 -> 0.00100000000 Inexact Rounded pwsx037 power -0.000001 0.5 -> NaN Invalid_operation pwsx038 power +0.000000000001 0.5 -> 0.00000100000000 Inexact Rounded pwsx039 power -0.000000000001 0.5 -> NaN Invalid_operation pwsx041 power 1.1 0.5 -> 1.04880885 Inexact Rounded pwsx042 power 1.10 0.5 -> 1.04880885 Inexact Rounded pwsx043 power 1.100 0.5 -> 1.04880885 Inexact Rounded pwsx044 power 1.110 0.5 -> 1.05356538 Inexact Rounded pwsx045 power -1.1 0.5 -> NaN Invalid_operation pwsx046 power -1.10 0.5 -> NaN Invalid_operation pwsx047 power -1.100 0.5 -> NaN Invalid_operation pwsx048 power -1.110 0.5 -> NaN Invalid_operation pwsx049 power 9.9 0.5 -> 3.14642654 Inexact Rounded pwsx050 power 9.90 0.5 -> 3.14642654 Inexact Rounded pwsx051 power 9.900 0.5 -> 3.14642654 Inexact Rounded pwsx052 power 9.990 0.5 -> 3.16069613 Inexact Rounded pwsx053 power -9.9 0.5 -> NaN Invalid_operation pwsx054 power -9.90 0.5 -> NaN Invalid_operation pwsx055 power -9.900 0.5 -> NaN Invalid_operation pwsx056 power -9.990 0.5 -> NaN Invalid_operation pwsx060 power 1 0.5 -> 1.00000000 Inexact Rounded pwsx061 power 1.0 0.5 -> 1.00000000 Inexact Rounded pwsx062 power 1.00 0.5 -> 1.00000000 Inexact Rounded pwsx063 power 10.0 0.5 -> 3.16227766 Inexact Rounded pwsx064 power 10.0 0.5 -> 3.16227766 Inexact Rounded pwsx065 power 10.0 0.5 -> 3.16227766 Inexact Rounded pwsx066 power 10.00 0.5 -> 3.16227766 Inexact Rounded pwsx067 power 100 0.5 -> 10.0000000 Inexact Rounded pwsx068 power 100.0 0.5 -> 10.0000000 Inexact Rounded pwsx069 power 100.00 0.5 -> 10.0000000 Inexact Rounded pwsx070 power 1.1000E+3 0.5 -> 33.1662479 Inexact Rounded pwsx071 power 1.10000E+3 0.5 -> 33.1662479 Inexact Rounded pwsx072 power -10.0 0.5 -> NaN Invalid_operation pwsx073 power -10.00 0.5 -> NaN Invalid_operation pwsx074 power -100.0 0.5 -> NaN Invalid_operation pwsx075 power -100.00 0.5 -> NaN Invalid_operation pwsx076 power -1.1000E+3 0.5 -> NaN Invalid_operation pwsx077 power -1.10000E+3 0.5 -> NaN Invalid_operation -- famous squares pwsx080 power 1 0.5 -> 1.00000000 Inexact Rounded pwsx081 power 4 0.5 -> 2.00000000 Inexact Rounded pwsx082 power 9 0.5 -> 3.00000000 Inexact Rounded pwsx083 power 16 0.5 -> 4.00000000 Inexact Rounded pwsx084 power 25 0.5 -> 5.00000000 Inexact Rounded pwsx085 power 36 0.5 -> 6.00000000 Inexact Rounded pwsx086 power 49 0.5 -> 7.00000000 Inexact Rounded pwsx087 power 64 0.5 -> 8.00000000 Inexact Rounded pwsx088 power 81 0.5 -> 9.00000000 Inexact Rounded pwsx089 power 100 0.5 -> 10.0000000 Inexact Rounded pwsx090 power 121 0.5 -> 11.0000000 Inexact Rounded pwsx091 power 144 0.5 -> 12.0000000 Inexact Rounded pwsx092 power 169 0.5 -> 13.0000000 Inexact Rounded pwsx093 power 256 0.5 -> 16.0000000 Inexact Rounded pwsx094 power 1024 0.5 -> 32.0000000 Inexact Rounded pwsx095 power 4096 0.5 -> 64.0000000 Inexact Rounded pwsx100 power 0.01 0.5 -> 0.100000000 Inexact Rounded pwsx101 power 0.04 0.5 -> 0.200000000 Inexact Rounded pwsx102 power 0.09 0.5 -> 0.300000000 Inexact Rounded pwsx103 power 0.16 0.5 -> 0.400000000 Inexact Rounded pwsx104 power 0.25 0.5 -> 0.500000000 Inexact Rounded pwsx105 power 0.36 0.5 -> 0.600000000 Inexact Rounded pwsx106 power 0.49 0.5 -> 0.700000000 Inexact Rounded pwsx107 power 0.64 0.5 -> 0.800000000 Inexact Rounded pwsx108 power 0.81 0.5 -> 0.900000000 Inexact Rounded pwsx109 power 1.00 0.5 -> 1.00000000 Inexact Rounded pwsx110 power 1.21 0.5 -> 1.10000000 Inexact Rounded pwsx111 power 1.44 0.5 -> 1.20000000 Inexact Rounded pwsx112 power 1.69 0.5 -> 1.30000000 Inexact Rounded pwsx113 power 2.56 0.5 -> 1.60000000 Inexact Rounded pwsx114 power 10.24 0.5 -> 3.20000000 Inexact Rounded pwsx115 power 40.96 0.5 -> 6.40000000 Inexact Rounded -- Precision 1 squareroot tests [exhaustive, plus exponent adjusts] rounding: half_even maxExponent: 999 minexponent: -999 precision: 1 pwsx1201 power 0.1 0.5 -> 0.3 Inexact Rounded pwsx1202 power 0.01 0.5 -> 0.1 Inexact Rounded pwsx1203 power 1.0E-1 0.5 -> 0.3 Inexact Rounded pwsx1204 power 1.00E-2 0.5 -> 0.1 Inexact Rounded pwsx1205 power 1E-3 0.5 -> 0.03 Inexact Rounded pwsx1206 power 1E+1 0.5 -> 3 Inexact Rounded pwsx1207 power 1E+2 0.5 -> 1E+1 Inexact Rounded pwsx1208 power 1E+3 0.5 -> 3E+1 Inexact Rounded pwsx1209 power 0.2 0.5 -> 0.4 Inexact Rounded pwsx1210 power 0.02 0.5 -> 0.1 Inexact Rounded pwsx1211 power 2.0E-1 0.5 -> 0.4 Inexact Rounded pwsx1212 power 2.00E-2 0.5 -> 0.1 Inexact Rounded pwsx1213 power 2E-3 0.5 -> 0.04 Inexact Rounded pwsx1214 power 2E+1 0.5 -> 4 Inexact Rounded pwsx1215 power 2E+2 0.5 -> 1E+1 Inexact Rounded pwsx1216 power 2E+3 0.5 -> 4E+1 Inexact Rounded pwsx1217 power 0.3 0.5 -> 0.5 Inexact Rounded pwsx1218 power 0.03 0.5 -> 0.2 Inexact Rounded pwsx1219 power 3.0E-1 0.5 -> 0.5 Inexact Rounded pwsx1220 power 3.00E-2 0.5 -> 0.2 Inexact Rounded pwsx1221 power 3E-3 0.5 -> 0.05 Inexact Rounded pwsx1222 power 3E+1 0.5 -> 5 Inexact Rounded pwsx1223 power 3E+2 0.5 -> 2E+1 Inexact Rounded pwsx1224 power 3E+3 0.5 -> 5E+1 Inexact Rounded pwsx1225 power 0.4 0.5 -> 0.6 Inexact Rounded pwsx1226 power 0.04 0.5 -> 0.2 Inexact Rounded pwsx1227 power 4.0E-1 0.5 -> 0.6 Inexact Rounded pwsx1228 power 4.00E-2 0.5 -> 0.2 Inexact Rounded pwsx1229 power 4E-3 0.5 -> 0.06 Inexact Rounded pwsx1230 power 4E+1 0.5 -> 6 Inexact Rounded pwsx1231 power 4E+2 0.5 -> 2E+1 Inexact Rounded pwsx1232 power 4E+3 0.5 -> 6E+1 Inexact Rounded pwsx1233 power 0.5 0.5 -> 0.7 Inexact Rounded pwsx1234 power 0.05 0.5 -> 0.2 Inexact Rounded pwsx1235 power 5.0E-1 0.5 -> 0.7 Inexact Rounded pwsx1236 power 5.00E-2 0.5 -> 0.2 Inexact Rounded pwsx1237 power 5E-3 0.5 -> 0.07 Inexact Rounded pwsx1238 power 5E+1 0.5 -> 7 Inexact Rounded pwsx1239 power 5E+2 0.5 -> 2E+1 Inexact Rounded pwsx1240 power 5E+3 0.5 -> 7E+1 Inexact Rounded pwsx1241 power 0.6 0.5 -> 0.8 Inexact Rounded pwsx1242 power 0.06 0.5 -> 0.2 Inexact Rounded pwsx1243 power 6.0E-1 0.5 -> 0.8 Inexact Rounded pwsx1244 power 6.00E-2 0.5 -> 0.2 Inexact Rounded pwsx1245 power 6E-3 0.5 -> 0.08 Inexact Rounded pwsx1246 power 6E+1 0.5 -> 8 Inexact Rounded pwsx1247 power 6E+2 0.5 -> 2E+1 Inexact Rounded pwsx1248 power 6E+3 0.5 -> 8E+1 Inexact Rounded pwsx1249 power 0.7 0.5 -> 0.8 Inexact Rounded pwsx1250 power 0.07 0.5 -> 0.3 Inexact Rounded pwsx1251 power 7.0E-1 0.5 -> 0.8 Inexact Rounded pwsx1252 power 7.00E-2 0.5 -> 0.3 Inexact Rounded pwsx1253 power 7E-3 0.5 -> 0.08 Inexact Rounded pwsx1254 power 7E+1 0.5 -> 8 Inexact Rounded pwsx1255 power 7E+2 0.5 -> 3E+1 Inexact Rounded pwsx1256 power 7E+3 0.5 -> 8E+1 Inexact Rounded pwsx1257 power 0.8 0.5 -> 0.9 Inexact Rounded pwsx1258 power 0.08 0.5 -> 0.3 Inexact Rounded pwsx1259 power 8.0E-1 0.5 -> 0.9 Inexact Rounded pwsx1260 power 8.00E-2 0.5 -> 0.3 Inexact Rounded pwsx1261 power 8E-3 0.5 -> 0.09 Inexact Rounded pwsx1262 power 8E+1 0.5 -> 9 Inexact Rounded pwsx1263 power 8E+2 0.5 -> 3E+1 Inexact Rounded pwsx1264 power 8E+3 0.5 -> 9E+1 Inexact Rounded pwsx1265 power 0.9 0.5 -> 0.9 Inexact Rounded pwsx1266 power 0.09 0.5 -> 0.3 Inexact Rounded pwsx1267 power 9.0E-1 0.5 -> 0.9 Inexact Rounded pwsx1268 power 9.00E-2 0.5 -> 0.3 Inexact Rounded pwsx1269 power 9E-3 0.5 -> 0.09 Inexact Rounded pwsx1270 power 9E+1 0.5 -> 9 Inexact Rounded pwsx1271 power 9E+2 0.5 -> 3E+1 Inexact Rounded pwsx1272 power 9E+3 0.5 -> 9E+1 Inexact Rounded -- Precision 2 squareroot tests [exhaustive, plus exponent adjusts] rounding: half_even maxExponent: 999 minexponent: -999 precision: 2 pwsx2201 power 0.1 0.5 -> 0.32 Inexact Rounded pwsx2202 power 0.01 0.5 -> 0.10 Inexact Rounded pwsx2203 power 1.0E-1 0.5 -> 0.32 Inexact Rounded pwsx2204 power 1.00E-2 0.5 -> 0.10 Inexact Rounded pwsx2205 power 1E-3 0.5 -> 0.032 Inexact Rounded pwsx2206 power 1E+1 0.5 -> 3.2 Inexact Rounded pwsx2207 power 1E+2 0.5 -> 10 Inexact Rounded pwsx2208 power 1E+3 0.5 -> 32 Inexact Rounded pwsx2209 power 0.2 0.5 -> 0.45 Inexact Rounded pwsx2210 power 0.02 0.5 -> 0.14 Inexact Rounded pwsx2211 power 2.0E-1 0.5 -> 0.45 Inexact Rounded pwsx2212 power 2.00E-2 0.5 -> 0.14 Inexact Rounded pwsx2213 power 2E-3 0.5 -> 0.045 Inexact Rounded pwsx2214 power 2E+1 0.5 -> 4.5 Inexact Rounded pwsx2215 power 2E+2 0.5 -> 14 Inexact Rounded pwsx2216 power 2E+3 0.5 -> 45 Inexact Rounded pwsx2217 power 0.3 0.5 -> 0.55 Inexact Rounded pwsx2218 power 0.03 0.5 -> 0.17 Inexact Rounded pwsx2219 power 3.0E-1 0.5 -> 0.55 Inexact Rounded pwsx2220 power 3.00E-2 0.5 -> 0.17 Inexact Rounded pwsx2221 power 3E-3 0.5 -> 0.055 Inexact Rounded pwsx2222 power 3E+1 0.5 -> 5.5 Inexact Rounded pwsx2223 power 3E+2 0.5 -> 17 Inexact Rounded pwsx2224 power 3E+3 0.5 -> 55 Inexact Rounded pwsx2225 power 0.4 0.5 -> 0.63 Inexact Rounded pwsx2226 power 0.04 0.5 -> 0.20 Inexact Rounded pwsx2227 power 4.0E-1 0.5 -> 0.63 Inexact Rounded pwsx2228 power 4.00E-2 0.5 -> 0.20 Inexact Rounded pwsx2229 power 4E-3 0.5 -> 0.063 Inexact Rounded pwsx2230 power 4E+1 0.5 -> 6.3 Inexact Rounded pwsx2231 power 4E+2 0.5 -> 20 Inexact Rounded pwsx2232 power 4E+3 0.5 -> 63 Inexact Rounded pwsx2233 power 0.5 0.5 -> 0.71 Inexact Rounded pwsx2234 power 0.05 0.5 -> 0.22 Inexact Rounded pwsx2235 power 5.0E-1 0.5 -> 0.71 Inexact Rounded pwsx2236 power 5.00E-2 0.5 -> 0.22 Inexact Rounded pwsx2237 power 5E-3 0.5 -> 0.071 Inexact Rounded pwsx2238 power 5E+1 0.5 -> 7.1 Inexact Rounded pwsx2239 power 5E+2 0.5 -> 22 Inexact Rounded pwsx2240 power 5E+3 0.5 -> 71 Inexact Rounded pwsx2241 power 0.6 0.5 -> 0.77 Inexact Rounded pwsx2242 power 0.06 0.5 -> 0.24 Inexact Rounded pwsx2243 power 6.0E-1 0.5 -> 0.77 Inexact Rounded pwsx2244 power 6.00E-2 0.5 -> 0.24 Inexact Rounded pwsx2245 power 6E-3 0.5 -> 0.077 Inexact Rounded pwsx2246 power 6E+1 0.5 -> 7.7 Inexact Rounded pwsx2247 power 6E+2 0.5 -> 24 Inexact Rounded pwsx2248 power 6E+3 0.5 -> 77 Inexact Rounded pwsx2249 power 0.7 0.5 -> 0.84 Inexact Rounded pwsx2250 power 0.07 0.5 -> 0.26 Inexact Rounded pwsx2251 power 7.0E-1 0.5 -> 0.84 Inexact Rounded pwsx2252 power 7.00E-2 0.5 -> 0.26 Inexact Rounded pwsx2253 power 7E-3 0.5 -> 0.084 Inexact Rounded pwsx2254 power 7E+1 0.5 -> 8.4 Inexact Rounded pwsx2255 power 7E+2 0.5 -> 26 Inexact Rounded pwsx2256 power 7E+3 0.5 -> 84 Inexact Rounded pwsx2257 power 0.8 0.5 -> 0.89 Inexact Rounded pwsx2258 power 0.08 0.5 -> 0.28 Inexact Rounded pwsx2259 power 8.0E-1 0.5 -> 0.89 Inexact Rounded pwsx2260 power 8.00E-2 0.5 -> 0.28 Inexact Rounded pwsx2261 power 8E-3 0.5 -> 0.089 Inexact Rounded pwsx2262 power 8E+1 0.5 -> 8.9 Inexact Rounded pwsx2263 power 8E+2 0.5 -> 28 Inexact Rounded pwsx2264 power 8E+3 0.5 -> 89 Inexact Rounded pwsx2265 power 0.9 0.5 -> 0.95 Inexact Rounded pwsx2266 power 0.09 0.5 -> 0.30 Inexact Rounded pwsx2267 power 9.0E-1 0.5 -> 0.95 Inexact Rounded pwsx2268 power 9.00E-2 0.5 -> 0.30 Inexact Rounded pwsx2269 power 9E-3 0.5 -> 0.095 Inexact Rounded pwsx2270 power 9E+1 0.5 -> 9.5 Inexact Rounded pwsx2271 power 9E+2 0.5 -> 30 Inexact Rounded pwsx2272 power 9E+3 0.5 -> 95 Inexact Rounded pwsx2273 power 0.10 0.5 -> 0.32 Inexact Rounded pwsx2274 power 0.010 0.5 -> 0.10 Inexact Rounded pwsx2275 power 10.0E-1 0.5 -> 1.0 Inexact Rounded pwsx2276 power 10.00E-2 0.5 -> 0.32 Inexact Rounded pwsx2277 power 10E-3 0.5 -> 0.10 Inexact Rounded pwsx2278 power 10E+1 0.5 -> 10 Inexact Rounded pwsx2279 power 10E+2 0.5 -> 32 Inexact Rounded pwsx2280 power 10E+3 0.5 -> 1.0E+2 Inexact Rounded pwsx2281 power 0.11 0.5 -> 0.33 Inexact Rounded pwsx2282 power 0.011 0.5 -> 0.10 Inexact Rounded pwsx2283 power 11.0E-1 0.5 -> 1.0 Inexact Rounded pwsx2284 power 11.00E-2 0.5 -> 0.33 Inexact Rounded pwsx2285 power 11E-3 0.5 -> 0.10 Inexact Rounded pwsx2286 power 11E+1 0.5 -> 10 Inexact Rounded pwsx2287 power 11E+2 0.5 -> 33 Inexact Rounded pwsx2288 power 11E+3 0.5 -> 1.0E+2 Inexact Rounded pwsx2289 power 0.12 0.5 -> 0.35 Inexact Rounded pwsx2290 power 0.012 0.5 -> 0.11 Inexact Rounded pwsx2291 power 12.0E-1 0.5 -> 1.1 Inexact Rounded pwsx2292 power 12.00E-2 0.5 -> 0.35 Inexact Rounded pwsx2293 power 12E-3 0.5 -> 0.11 Inexact Rounded pwsx2294 power 12E+1 0.5 -> 11 Inexact Rounded pwsx2295 power 12E+2 0.5 -> 35 Inexact Rounded pwsx2296 power 12E+3 0.5 -> 1.1E+2 Inexact Rounded pwsx2297 power 0.13 0.5 -> 0.36 Inexact Rounded pwsx2298 power 0.013 0.5 -> 0.11 Inexact Rounded pwsx2299 power 13.0E-1 0.5 -> 1.1 Inexact Rounded pwsx2300 power 13.00E-2 0.5 -> 0.36 Inexact Rounded pwsx2301 power 13E-3 0.5 -> 0.11 Inexact Rounded pwsx2302 power 13E+1 0.5 -> 11 Inexact Rounded pwsx2303 power 13E+2 0.5 -> 36 Inexact Rounded pwsx2304 power 13E+3 0.5 -> 1.1E+2 Inexact Rounded pwsx2305 power 0.14 0.5 -> 0.37 Inexact Rounded pwsx2306 power 0.014 0.5 -> 0.12 Inexact Rounded pwsx2307 power 14.0E-1 0.5 -> 1.2 Inexact Rounded pwsx2308 power 14.00E-2 0.5 -> 0.37 Inexact Rounded pwsx2309 power 14E-3 0.5 -> 0.12 Inexact Rounded pwsx2310 power 14E+1 0.5 -> 12 Inexact Rounded pwsx2311 power 14E+2 0.5 -> 37 Inexact Rounded pwsx2312 power 14E+3 0.5 -> 1.2E+2 Inexact Rounded pwsx2313 power 0.15 0.5 -> 0.39 Inexact Rounded pwsx2314 power 0.015 0.5 -> 0.12 Inexact Rounded pwsx2315 power 15.0E-1 0.5 -> 1.2 Inexact Rounded pwsx2316 power 15.00E-2 0.5 -> 0.39 Inexact Rounded pwsx2317 power 15E-3 0.5 -> 0.12 Inexact Rounded pwsx2318 power 15E+1 0.5 -> 12 Inexact Rounded pwsx2319 power 15E+2 0.5 -> 39 Inexact Rounded pwsx2320 power 15E+3 0.5 -> 1.2E+2 Inexact Rounded pwsx2321 power 0.16 0.5 -> 0.40 Inexact Rounded pwsx2322 power 0.016 0.5 -> 0.13 Inexact Rounded pwsx2323 power 16.0E-1 0.5 -> 1.3 Inexact Rounded pwsx2324 power 16.00E-2 0.5 -> 0.40 Inexact Rounded pwsx2325 power 16E-3 0.5 -> 0.13 Inexact Rounded pwsx2326 power 16E+1 0.5 -> 13 Inexact Rounded pwsx2327 power 16E+2 0.5 -> 40 Inexact Rounded pwsx2328 power 16E+3 0.5 -> 1.3E+2 Inexact Rounded pwsx2329 power 0.17 0.5 -> 0.41 Inexact Rounded pwsx2330 power 0.017 0.5 -> 0.13 Inexact Rounded pwsx2331 power 17.0E-1 0.5 -> 1.3 Inexact Rounded pwsx2332 power 17.00E-2 0.5 -> 0.41 Inexact Rounded pwsx2333 power 17E-3 0.5 -> 0.13 Inexact Rounded pwsx2334 power 17E+1 0.5 -> 13 Inexact Rounded pwsx2335 power 17E+2 0.5 -> 41 Inexact Rounded pwsx2336 power 17E+3 0.5 -> 1.3E+2 Inexact Rounded pwsx2337 power 0.18 0.5 -> 0.42 Inexact Rounded pwsx2338 power 0.018 0.5 -> 0.13 Inexact Rounded pwsx2339 power 18.0E-1 0.5 -> 1.3 Inexact Rounded pwsx2340 power 18.00E-2 0.5 -> 0.42 Inexact Rounded pwsx2341 power 18E-3 0.5 -> 0.13 Inexact Rounded pwsx2342 power 18E+1 0.5 -> 13 Inexact Rounded pwsx2343 power 18E+2 0.5 -> 42 Inexact Rounded pwsx2344 power 18E+3 0.5 -> 1.3E+2 Inexact Rounded pwsx2345 power 0.19 0.5 -> 0.44 Inexact Rounded pwsx2346 power 0.019 0.5 -> 0.14 Inexact Rounded pwsx2347 power 19.0E-1 0.5 -> 1.4 Inexact Rounded pwsx2348 power 19.00E-2 0.5 -> 0.44 Inexact Rounded pwsx2349 power 19E-3 0.5 -> 0.14 Inexact Rounded pwsx2350 power 19E+1 0.5 -> 14 Inexact Rounded pwsx2351 power 19E+2 0.5 -> 44 Inexact Rounded pwsx2352 power 19E+3 0.5 -> 1.4E+2 Inexact Rounded pwsx2353 power 0.20 0.5 -> 0.45 Inexact Rounded pwsx2354 power 0.020 0.5 -> 0.14 Inexact Rounded pwsx2355 power 20.0E-1 0.5 -> 1.4 Inexact Rounded pwsx2356 power 20.00E-2 0.5 -> 0.45 Inexact Rounded pwsx2357 power 20E-3 0.5 -> 0.14 Inexact Rounded pwsx2358 power 20E+1 0.5 -> 14 Inexact Rounded pwsx2359 power 20E+2 0.5 -> 45 Inexact Rounded pwsx2360 power 20E+3 0.5 -> 1.4E+2 Inexact Rounded pwsx2361 power 0.21 0.5 -> 0.46 Inexact Rounded pwsx2362 power 0.021 0.5 -> 0.14 Inexact Rounded pwsx2363 power 21.0E-1 0.5 -> 1.4 Inexact Rounded pwsx2364 power 21.00E-2 0.5 -> 0.46 Inexact Rounded pwsx2365 power 21E-3 0.5 -> 0.14 Inexact Rounded pwsx2366 power 21E+1 0.5 -> 14 Inexact Rounded pwsx2367 power 21E+2 0.5 -> 46 Inexact Rounded pwsx2368 power 21E+3 0.5 -> 1.4E+2 Inexact Rounded pwsx2369 power 0.22 0.5 -> 0.47 Inexact Rounded pwsx2370 power 0.022 0.5 -> 0.15 Inexact Rounded pwsx2371 power 22.0E-1 0.5 -> 1.5 Inexact Rounded pwsx2372 power 22.00E-2 0.5 -> 0.47 Inexact Rounded pwsx2373 power 22E-3 0.5 -> 0.15 Inexact Rounded pwsx2374 power 22E+1 0.5 -> 15 Inexact Rounded pwsx2375 power 22E+2 0.5 -> 47 Inexact Rounded pwsx2376 power 22E+3 0.5 -> 1.5E+2 Inexact Rounded pwsx2377 power 0.23 0.5 -> 0.48 Inexact Rounded pwsx2378 power 0.023 0.5 -> 0.15 Inexact Rounded pwsx2379 power 23.0E-1 0.5 -> 1.5 Inexact Rounded pwsx2380 power 23.00E-2 0.5 -> 0.48 Inexact Rounded pwsx2381 power 23E-3 0.5 -> 0.15 Inexact Rounded pwsx2382 power 23E+1 0.5 -> 15 Inexact Rounded pwsx2383 power 23E+2 0.5 -> 48 Inexact Rounded pwsx2384 power 23E+3 0.5 -> 1.5E+2 Inexact Rounded pwsx2385 power 0.24 0.5 -> 0.49 Inexact Rounded pwsx2386 power 0.024 0.5 -> 0.15 Inexact Rounded pwsx2387 power 24.0E-1 0.5 -> 1.5 Inexact Rounded pwsx2388 power 24.00E-2 0.5 -> 0.49 Inexact Rounded pwsx2389 power 24E-3 0.5 -> 0.15 Inexact Rounded pwsx2390 power 24E+1 0.5 -> 15 Inexact Rounded pwsx2391 power 24E+2 0.5 -> 49 Inexact Rounded pwsx2392 power 24E+3 0.5 -> 1.5E+2 Inexact Rounded pwsx2393 power 0.25 0.5 -> 0.50 Inexact Rounded pwsx2394 power 0.025 0.5 -> 0.16 Inexact Rounded pwsx2395 power 25.0E-1 0.5 -> 1.6 Inexact Rounded pwsx2396 power 25.00E-2 0.5 -> 0.50 Inexact Rounded pwsx2397 power 25E-3 0.5 -> 0.16 Inexact Rounded pwsx2398 power 25E+1 0.5 -> 16 Inexact Rounded pwsx2399 power 25E+2 0.5 -> 50 Inexact Rounded pwsx2400 power 25E+3 0.5 -> 1.6E+2 Inexact Rounded pwsx2401 power 0.26 0.5 -> 0.51 Inexact Rounded pwsx2402 power 0.026 0.5 -> 0.16 Inexact Rounded pwsx2403 power 26.0E-1 0.5 -> 1.6 Inexact Rounded pwsx2404 power 26.00E-2 0.5 -> 0.51 Inexact Rounded pwsx2405 power 26E-3 0.5 -> 0.16 Inexact Rounded pwsx2406 power 26E+1 0.5 -> 16 Inexact Rounded pwsx2407 power 26E+2 0.5 -> 51 Inexact Rounded pwsx2408 power 26E+3 0.5 -> 1.6E+2 Inexact Rounded pwsx2409 power 0.27 0.5 -> 0.52 Inexact Rounded pwsx2410 power 0.027 0.5 -> 0.16 Inexact Rounded pwsx2411 power 27.0E-1 0.5 -> 1.6 Inexact Rounded pwsx2412 power 27.00E-2 0.5 -> 0.52 Inexact Rounded pwsx2413 power 27E-3 0.5 -> 0.16 Inexact Rounded pwsx2414 power 27E+1 0.5 -> 16 Inexact Rounded pwsx2415 power 27E+2 0.5 -> 52 Inexact Rounded pwsx2416 power 27E+3 0.5 -> 1.6E+2 Inexact Rounded pwsx2417 power 0.28 0.5 -> 0.53 Inexact Rounded pwsx2418 power 0.028 0.5 -> 0.17 Inexact Rounded pwsx2419 power 28.0E-1 0.5 -> 1.7 Inexact Rounded pwsx2420 power 28.00E-2 0.5 -> 0.53 Inexact Rounded pwsx2421 power 28E-3 0.5 -> 0.17 Inexact Rounded pwsx2422 power 28E+1 0.5 -> 17 Inexact Rounded pwsx2423 power 28E+2 0.5 -> 53 Inexact Rounded pwsx2424 power 28E+3 0.5 -> 1.7E+2 Inexact Rounded pwsx2425 power 0.29 0.5 -> 0.54 Inexact Rounded pwsx2426 power 0.029 0.5 -> 0.17 Inexact Rounded pwsx2427 power 29.0E-1 0.5 -> 1.7 Inexact Rounded pwsx2428 power 29.00E-2 0.5 -> 0.54 Inexact Rounded pwsx2429 power 29E-3 0.5 -> 0.17 Inexact Rounded pwsx2430 power 29E+1 0.5 -> 17 Inexact Rounded pwsx2431 power 29E+2 0.5 -> 54 Inexact Rounded pwsx2432 power 29E+3 0.5 -> 1.7E+2 Inexact Rounded pwsx2433 power 0.30 0.5 -> 0.55 Inexact Rounded pwsx2434 power 0.030 0.5 -> 0.17 Inexact Rounded pwsx2435 power 30.0E-1 0.5 -> 1.7 Inexact Rounded pwsx2436 power 30.00E-2 0.5 -> 0.55 Inexact Rounded pwsx2437 power 30E-3 0.5 -> 0.17 Inexact Rounded pwsx2438 power 30E+1 0.5 -> 17 Inexact Rounded pwsx2439 power 30E+2 0.5 -> 55 Inexact Rounded pwsx2440 power 30E+3 0.5 -> 1.7E+2 Inexact Rounded pwsx2441 power 0.31 0.5 -> 0.56 Inexact Rounded pwsx2442 power 0.031 0.5 -> 0.18 Inexact Rounded pwsx2443 power 31.0E-1 0.5 -> 1.8 Inexact Rounded pwsx2444 power 31.00E-2 0.5 -> 0.56 Inexact Rounded pwsx2445 power 31E-3 0.5 -> 0.18 Inexact Rounded pwsx2446 power 31E+1 0.5 -> 18 Inexact Rounded pwsx2447 power 31E+2 0.5 -> 56 Inexact Rounded pwsx2448 power 31E+3 0.5 -> 1.8E+2 Inexact Rounded pwsx2449 power 0.32 0.5 -> 0.57 Inexact Rounded pwsx2450 power 0.032 0.5 -> 0.18 Inexact Rounded pwsx2451 power 32.0E-1 0.5 -> 1.8 Inexact Rounded pwsx2452 power 32.00E-2 0.5 -> 0.57 Inexact Rounded pwsx2453 power 32E-3 0.5 -> 0.18 Inexact Rounded pwsx2454 power 32E+1 0.5 -> 18 Inexact Rounded pwsx2455 power 32E+2 0.5 -> 57 Inexact Rounded pwsx2456 power 32E+3 0.5 -> 1.8E+2 Inexact Rounded pwsx2457 power 0.33 0.5 -> 0.57 Inexact Rounded pwsx2458 power 0.033 0.5 -> 0.18 Inexact Rounded pwsx2459 power 33.0E-1 0.5 -> 1.8 Inexact Rounded pwsx2460 power 33.00E-2 0.5 -> 0.57 Inexact Rounded pwsx2461 power 33E-3 0.5 -> 0.18 Inexact Rounded pwsx2462 power 33E+1 0.5 -> 18 Inexact Rounded pwsx2463 power 33E+2 0.5 -> 57 Inexact Rounded pwsx2464 power 33E+3 0.5 -> 1.8E+2 Inexact Rounded pwsx2465 power 0.34 0.5 -> 0.58 Inexact Rounded pwsx2466 power 0.034 0.5 -> 0.18 Inexact Rounded pwsx2467 power 34.0E-1 0.5 -> 1.8 Inexact Rounded pwsx2468 power 34.00E-2 0.5 -> 0.58 Inexact Rounded pwsx2469 power 34E-3 0.5 -> 0.18 Inexact Rounded pwsx2470 power 34E+1 0.5 -> 18 Inexact Rounded pwsx2471 power 34E+2 0.5 -> 58 Inexact Rounded pwsx2472 power 34E+3 0.5 -> 1.8E+2 Inexact Rounded pwsx2473 power 0.35 0.5 -> 0.59 Inexact Rounded pwsx2474 power 0.035 0.5 -> 0.19 Inexact Rounded pwsx2475 power 35.0E-1 0.5 -> 1.9 Inexact Rounded pwsx2476 power 35.00E-2 0.5 -> 0.59 Inexact Rounded pwsx2477 power 35E-3 0.5 -> 0.19 Inexact Rounded pwsx2478 power 35E+1 0.5 -> 19 Inexact Rounded pwsx2479 power 35E+2 0.5 -> 59 Inexact Rounded pwsx2480 power 35E+3 0.5 -> 1.9E+2 Inexact Rounded pwsx2481 power 0.36 0.5 -> 0.60 Inexact Rounded pwsx2482 power 0.036 0.5 -> 0.19 Inexact Rounded pwsx2483 power 36.0E-1 0.5 -> 1.9 Inexact Rounded pwsx2484 power 36.00E-2 0.5 -> 0.60 Inexact Rounded pwsx2485 power 36E-3 0.5 -> 0.19 Inexact Rounded pwsx2486 power 36E+1 0.5 -> 19 Inexact Rounded pwsx2487 power 36E+2 0.5 -> 60 Inexact Rounded pwsx2488 power 36E+3 0.5 -> 1.9E+2 Inexact Rounded pwsx2489 power 0.37 0.5 -> 0.61 Inexact Rounded pwsx2490 power 0.037 0.5 -> 0.19 Inexact Rounded pwsx2491 power 37.0E-1 0.5 -> 1.9 Inexact Rounded pwsx2492 power 37.00E-2 0.5 -> 0.61 Inexact Rounded pwsx2493 power 37E-3 0.5 -> 0.19 Inexact Rounded pwsx2494 power 37E+1 0.5 -> 19 Inexact Rounded pwsx2495 power 37E+2 0.5 -> 61 Inexact Rounded pwsx2496 power 37E+3 0.5 -> 1.9E+2 Inexact Rounded pwsx2497 power 0.38 0.5 -> 0.62 Inexact Rounded pwsx2498 power 0.038 0.5 -> 0.19 Inexact Rounded pwsx2499 power 38.0E-1 0.5 -> 1.9 Inexact Rounded pwsx2500 power 38.00E-2 0.5 -> 0.62 Inexact Rounded pwsx2501 power 38E-3 0.5 -> 0.19 Inexact Rounded pwsx2502 power 38E+1 0.5 -> 19 Inexact Rounded pwsx2503 power 38E+2 0.5 -> 62 Inexact Rounded pwsx2504 power 38E+3 0.5 -> 1.9E+2 Inexact Rounded pwsx2505 power 0.39 0.5 -> 0.62 Inexact Rounded pwsx2506 power 0.039 0.5 -> 0.20 Inexact Rounded pwsx2507 power 39.0E-1 0.5 -> 2.0 Inexact Rounded pwsx2508 power 39.00E-2 0.5 -> 0.62 Inexact Rounded pwsx2509 power 39E-3 0.5 -> 0.20 Inexact Rounded pwsx2510 power 39E+1 0.5 -> 20 Inexact Rounded pwsx2511 power 39E+2 0.5 -> 62 Inexact Rounded pwsx2512 power 39E+3 0.5 -> 2.0E+2 Inexact Rounded pwsx2513 power 0.40 0.5 -> 0.63 Inexact Rounded pwsx2514 power 0.040 0.5 -> 0.20 Inexact Rounded pwsx2515 power 40.0E-1 0.5 -> 2.0 Inexact Rounded pwsx2516 power 40.00E-2 0.5 -> 0.63 Inexact Rounded pwsx2517 power 40E-3 0.5 -> 0.20 Inexact Rounded pwsx2518 power 40E+1 0.5 -> 20 Inexact Rounded pwsx2519 power 40E+2 0.5 -> 63 Inexact Rounded pwsx2520 power 40E+3 0.5 -> 2.0E+2 Inexact Rounded pwsx2521 power 0.41 0.5 -> 0.64 Inexact Rounded pwsx2522 power 0.041 0.5 -> 0.20 Inexact Rounded pwsx2523 power 41.0E-1 0.5 -> 2.0 Inexact Rounded pwsx2524 power 41.00E-2 0.5 -> 0.64 Inexact Rounded pwsx2525 power 41E-3 0.5 -> 0.20 Inexact Rounded pwsx2526 power 41E+1 0.5 -> 20 Inexact Rounded pwsx2527 power 41E+2 0.5 -> 64 Inexact Rounded pwsx2528 power 41E+3 0.5 -> 2.0E+2 Inexact Rounded pwsx2529 power 0.42 0.5 -> 0.65 Inexact Rounded pwsx2530 power 0.042 0.5 -> 0.20 Inexact Rounded pwsx2531 power 42.0E-1 0.5 -> 2.0 Inexact Rounded pwsx2532 power 42.00E-2 0.5 -> 0.65 Inexact Rounded pwsx2533 power 42E-3 0.5 -> 0.20 Inexact Rounded pwsx2534 power 42E+1 0.5 -> 20 Inexact Rounded pwsx2535 power 42E+2 0.5 -> 65 Inexact Rounded pwsx2536 power 42E+3 0.5 -> 2.0E+2 Inexact Rounded pwsx2537 power 0.43 0.5 -> 0.66 Inexact Rounded pwsx2538 power 0.043 0.5 -> 0.21 Inexact Rounded pwsx2539 power 43.0E-1 0.5 -> 2.1 Inexact Rounded pwsx2540 power 43.00E-2 0.5 -> 0.66 Inexact Rounded pwsx2541 power 43E-3 0.5 -> 0.21 Inexact Rounded pwsx2542 power 43E+1 0.5 -> 21 Inexact Rounded pwsx2543 power 43E+2 0.5 -> 66 Inexact Rounded pwsx2544 power 43E+3 0.5 -> 2.1E+2 Inexact Rounded pwsx2545 power 0.44 0.5 -> 0.66 Inexact Rounded pwsx2546 power 0.044 0.5 -> 0.21 Inexact Rounded pwsx2547 power 44.0E-1 0.5 -> 2.1 Inexact Rounded pwsx2548 power 44.00E-2 0.5 -> 0.66 Inexact Rounded pwsx2549 power 44E-3 0.5 -> 0.21 Inexact Rounded pwsx2550 power 44E+1 0.5 -> 21 Inexact Rounded pwsx2551 power 44E+2 0.5 -> 66 Inexact Rounded pwsx2552 power 44E+3 0.5 -> 2.1E+2 Inexact Rounded pwsx2553 power 0.45 0.5 -> 0.67 Inexact Rounded pwsx2554 power 0.045 0.5 -> 0.21 Inexact Rounded pwsx2555 power 45.0E-1 0.5 -> 2.1 Inexact Rounded pwsx2556 power 45.00E-2 0.5 -> 0.67 Inexact Rounded pwsx2557 power 45E-3 0.5 -> 0.21 Inexact Rounded pwsx2558 power 45E+1 0.5 -> 21 Inexact Rounded pwsx2559 power 45E+2 0.5 -> 67 Inexact Rounded pwsx2560 power 45E+3 0.5 -> 2.1E+2 Inexact Rounded pwsx2561 power 0.46 0.5 -> 0.68 Inexact Rounded pwsx2562 power 0.046 0.5 -> 0.21 Inexact Rounded pwsx2563 power 46.0E-1 0.5 -> 2.1 Inexact Rounded pwsx2564 power 46.00E-2 0.5 -> 0.68 Inexact Rounded pwsx2565 power 46E-3 0.5 -> 0.21 Inexact Rounded pwsx2566 power 46E+1 0.5 -> 21 Inexact Rounded pwsx2567 power 46E+2 0.5 -> 68 Inexact Rounded pwsx2568 power 46E+3 0.5 -> 2.1E+2 Inexact Rounded pwsx2569 power 0.47 0.5 -> 0.69 Inexact Rounded pwsx2570 power 0.047 0.5 -> 0.22 Inexact Rounded pwsx2571 power 47.0E-1 0.5 -> 2.2 Inexact Rounded pwsx2572 power 47.00E-2 0.5 -> 0.69 Inexact Rounded pwsx2573 power 47E-3 0.5 -> 0.22 Inexact Rounded pwsx2574 power 47E+1 0.5 -> 22 Inexact Rounded pwsx2575 power 47E+2 0.5 -> 69 Inexact Rounded pwsx2576 power 47E+3 0.5 -> 2.2E+2 Inexact Rounded pwsx2577 power 0.48 0.5 -> 0.69 Inexact Rounded pwsx2578 power 0.048 0.5 -> 0.22 Inexact Rounded pwsx2579 power 48.0E-1 0.5 -> 2.2 Inexact Rounded pwsx2580 power 48.00E-2 0.5 -> 0.69 Inexact Rounded pwsx2581 power 48E-3 0.5 -> 0.22 Inexact Rounded pwsx2582 power 48E+1 0.5 -> 22 Inexact Rounded pwsx2583 power 48E+2 0.5 -> 69 Inexact Rounded pwsx2584 power 48E+3 0.5 -> 2.2E+2 Inexact Rounded pwsx2585 power 0.49 0.5 -> 0.70 Inexact Rounded pwsx2586 power 0.049 0.5 -> 0.22 Inexact Rounded pwsx2587 power 49.0E-1 0.5 -> 2.2 Inexact Rounded pwsx2588 power 49.00E-2 0.5 -> 0.70 Inexact Rounded pwsx2589 power 49E-3 0.5 -> 0.22 Inexact Rounded pwsx2590 power 49E+1 0.5 -> 22 Inexact Rounded pwsx2591 power 49E+2 0.5 -> 70 Inexact Rounded pwsx2592 power 49E+3 0.5 -> 2.2E+2 Inexact Rounded pwsx2593 power 0.50 0.5 -> 0.71 Inexact Rounded pwsx2594 power 0.050 0.5 -> 0.22 Inexact Rounded pwsx2595 power 50.0E-1 0.5 -> 2.2 Inexact Rounded pwsx2596 power 50.00E-2 0.5 -> 0.71 Inexact Rounded pwsx2597 power 50E-3 0.5 -> 0.22 Inexact Rounded pwsx2598 power 50E+1 0.5 -> 22 Inexact Rounded pwsx2599 power 50E+2 0.5 -> 71 Inexact Rounded pwsx2600 power 50E+3 0.5 -> 2.2E+2 Inexact Rounded pwsx2601 power 0.51 0.5 -> 0.71 Inexact Rounded pwsx2602 power 0.051 0.5 -> 0.23 Inexact Rounded pwsx2603 power 51.0E-1 0.5 -> 2.3 Inexact Rounded pwsx2604 power 51.00E-2 0.5 -> 0.71 Inexact Rounded pwsx2605 power 51E-3 0.5 -> 0.23 Inexact Rounded pwsx2606 power 51E+1 0.5 -> 23 Inexact Rounded pwsx2607 power 51E+2 0.5 -> 71 Inexact Rounded pwsx2608 power 51E+3 0.5 -> 2.3E+2 Inexact Rounded pwsx2609 power 0.52 0.5 -> 0.72 Inexact Rounded pwsx2610 power 0.052 0.5 -> 0.23 Inexact Rounded pwsx2611 power 52.0E-1 0.5 -> 2.3 Inexact Rounded pwsx2612 power 52.00E-2 0.5 -> 0.72 Inexact Rounded pwsx2613 power 52E-3 0.5 -> 0.23 Inexact Rounded pwsx2614 power 52E+1 0.5 -> 23 Inexact Rounded pwsx2615 power 52E+2 0.5 -> 72 Inexact Rounded pwsx2616 power 52E+3 0.5 -> 2.3E+2 Inexact Rounded pwsx2617 power 0.53 0.5 -> 0.73 Inexact Rounded pwsx2618 power 0.053 0.5 -> 0.23 Inexact Rounded pwsx2619 power 53.0E-1 0.5 -> 2.3 Inexact Rounded pwsx2620 power 53.00E-2 0.5 -> 0.73 Inexact Rounded pwsx2621 power 53E-3 0.5 -> 0.23 Inexact Rounded pwsx2622 power 53E+1 0.5 -> 23 Inexact Rounded pwsx2623 power 53E+2 0.5 -> 73 Inexact Rounded pwsx2624 power 53E+3 0.5 -> 2.3E+2 Inexact Rounded pwsx2625 power 0.54 0.5 -> 0.73 Inexact Rounded pwsx2626 power 0.054 0.5 -> 0.23 Inexact Rounded pwsx2627 power 54.0E-1 0.5 -> 2.3 Inexact Rounded pwsx2628 power 54.00E-2 0.5 -> 0.73 Inexact Rounded pwsx2629 power 54E-3 0.5 -> 0.23 Inexact Rounded pwsx2630 power 54E+1 0.5 -> 23 Inexact Rounded pwsx2631 power 54E+2 0.5 -> 73 Inexact Rounded pwsx2632 power 54E+3 0.5 -> 2.3E+2 Inexact Rounded pwsx2633 power 0.55 0.5 -> 0.74 Inexact Rounded pwsx2634 power 0.055 0.5 -> 0.23 Inexact Rounded pwsx2635 power 55.0E-1 0.5 -> 2.3 Inexact Rounded pwsx2636 power 55.00E-2 0.5 -> 0.74 Inexact Rounded pwsx2637 power 55E-3 0.5 -> 0.23 Inexact Rounded pwsx2638 power 55E+1 0.5 -> 23 Inexact Rounded pwsx2639 power 55E+2 0.5 -> 74 Inexact Rounded pwsx2640 power 55E+3 0.5 -> 2.3E+2 Inexact Rounded pwsx2641 power 0.56 0.5 -> 0.75 Inexact Rounded pwsx2642 power 0.056 0.5 -> 0.24 Inexact Rounded pwsx2643 power 56.0E-1 0.5 -> 2.4 Inexact Rounded pwsx2644 power 56.00E-2 0.5 -> 0.75 Inexact Rounded pwsx2645 power 56E-3 0.5 -> 0.24 Inexact Rounded pwsx2646 power 56E+1 0.5 -> 24 Inexact Rounded pwsx2647 power 56E+2 0.5 -> 75 Inexact Rounded pwsx2648 power 56E+3 0.5 -> 2.4E+2 Inexact Rounded pwsx2649 power 0.57 0.5 -> 0.75 Inexact Rounded pwsx2650 power 0.057 0.5 -> 0.24 Inexact Rounded pwsx2651 power 57.0E-1 0.5 -> 2.4 Inexact Rounded pwsx2652 power 57.00E-2 0.5 -> 0.75 Inexact Rounded pwsx2653 power 57E-3 0.5 -> 0.24 Inexact Rounded pwsx2654 power 57E+1 0.5 -> 24 Inexact Rounded pwsx2655 power 57E+2 0.5 -> 75 Inexact Rounded pwsx2656 power 57E+3 0.5 -> 2.4E+2 Inexact Rounded pwsx2657 power 0.58 0.5 -> 0.76 Inexact Rounded pwsx2658 power 0.058 0.5 -> 0.24 Inexact Rounded pwsx2659 power 58.0E-1 0.5 -> 2.4 Inexact Rounded pwsx2660 power 58.00E-2 0.5 -> 0.76 Inexact Rounded pwsx2661 power 58E-3 0.5 -> 0.24 Inexact Rounded pwsx2662 power 58E+1 0.5 -> 24 Inexact Rounded pwsx2663 power 58E+2 0.5 -> 76 Inexact Rounded pwsx2664 power 58E+3 0.5 -> 2.4E+2 Inexact Rounded pwsx2665 power 0.59 0.5 -> 0.77 Inexact Rounded pwsx2666 power 0.059 0.5 -> 0.24 Inexact Rounded pwsx2667 power 59.0E-1 0.5 -> 2.4 Inexact Rounded pwsx2668 power 59.00E-2 0.5 -> 0.77 Inexact Rounded pwsx2669 power 59E-3 0.5 -> 0.24 Inexact Rounded pwsx2670 power 59E+1 0.5 -> 24 Inexact Rounded pwsx2671 power 59E+2 0.5 -> 77 Inexact Rounded pwsx2672 power 59E+3 0.5 -> 2.4E+2 Inexact Rounded pwsx2673 power 0.60 0.5 -> 0.77 Inexact Rounded pwsx2674 power 0.060 0.5 -> 0.24 Inexact Rounded pwsx2675 power 60.0E-1 0.5 -> 2.4 Inexact Rounded pwsx2676 power 60.00E-2 0.5 -> 0.77 Inexact Rounded pwsx2677 power 60E-3 0.5 -> 0.24 Inexact Rounded pwsx2678 power 60E+1 0.5 -> 24 Inexact Rounded pwsx2679 power 60E+2 0.5 -> 77 Inexact Rounded pwsx2680 power 60E+3 0.5 -> 2.4E+2 Inexact Rounded pwsx2681 power 0.61 0.5 -> 0.78 Inexact Rounded pwsx2682 power 0.061 0.5 -> 0.25 Inexact Rounded pwsx2683 power 61.0E-1 0.5 -> 2.5 Inexact Rounded pwsx2684 power 61.00E-2 0.5 -> 0.78 Inexact Rounded pwsx2685 power 61E-3 0.5 -> 0.25 Inexact Rounded pwsx2686 power 61E+1 0.5 -> 25 Inexact Rounded pwsx2687 power 61E+2 0.5 -> 78 Inexact Rounded pwsx2688 power 61E+3 0.5 -> 2.5E+2 Inexact Rounded pwsx2689 power 0.62 0.5 -> 0.79 Inexact Rounded pwsx2690 power 0.062 0.5 -> 0.25 Inexact Rounded pwsx2691 power 62.0E-1 0.5 -> 2.5 Inexact Rounded pwsx2692 power 62.00E-2 0.5 -> 0.79 Inexact Rounded pwsx2693 power 62E-3 0.5 -> 0.25 Inexact Rounded pwsx2694 power 62E+1 0.5 -> 25 Inexact Rounded pwsx2695 power 62E+2 0.5 -> 79 Inexact Rounded pwsx2696 power 62E+3 0.5 -> 2.5E+2 Inexact Rounded pwsx2697 power 0.63 0.5 -> 0.79 Inexact Rounded pwsx2698 power 0.063 0.5 -> 0.25 Inexact Rounded pwsx2699 power 63.0E-1 0.5 -> 2.5 Inexact Rounded pwsx2700 power 63.00E-2 0.5 -> 0.79 Inexact Rounded pwsx2701 power 63E-3 0.5 -> 0.25 Inexact Rounded pwsx2702 power 63E+1 0.5 -> 25 Inexact Rounded pwsx2703 power 63E+2 0.5 -> 79 Inexact Rounded pwsx2704 power 63E+3 0.5 -> 2.5E+2 Inexact Rounded pwsx2705 power 0.64 0.5 -> 0.80 Inexact Rounded pwsx2706 power 0.064 0.5 -> 0.25 Inexact Rounded pwsx2707 power 64.0E-1 0.5 -> 2.5 Inexact Rounded pwsx2708 power 64.00E-2 0.5 -> 0.80 Inexact Rounded pwsx2709 power 64E-3 0.5 -> 0.25 Inexact Rounded pwsx2710 power 64E+1 0.5 -> 25 Inexact Rounded pwsx2711 power 64E+2 0.5 -> 80 Inexact Rounded pwsx2712 power 64E+3 0.5 -> 2.5E+2 Inexact Rounded pwsx2713 power 0.65 0.5 -> 0.81 Inexact Rounded pwsx2714 power 0.065 0.5 -> 0.25 Inexact Rounded pwsx2715 power 65.0E-1 0.5 -> 2.5 Inexact Rounded pwsx2716 power 65.00E-2 0.5 -> 0.81 Inexact Rounded pwsx2717 power 65E-3 0.5 -> 0.25 Inexact Rounded pwsx2718 power 65E+1 0.5 -> 25 Inexact Rounded pwsx2719 power 65E+2 0.5 -> 81 Inexact Rounded pwsx2720 power 65E+3 0.5 -> 2.5E+2 Inexact Rounded pwsx2721 power 0.66 0.5 -> 0.81 Inexact Rounded pwsx2722 power 0.066 0.5 -> 0.26 Inexact Rounded pwsx2723 power 66.0E-1 0.5 -> 2.6 Inexact Rounded pwsx2724 power 66.00E-2 0.5 -> 0.81 Inexact Rounded pwsx2725 power 66E-3 0.5 -> 0.26 Inexact Rounded pwsx2726 power 66E+1 0.5 -> 26 Inexact Rounded pwsx2727 power 66E+2 0.5 -> 81 Inexact Rounded pwsx2728 power 66E+3 0.5 -> 2.6E+2 Inexact Rounded pwsx2729 power 0.67 0.5 -> 0.82 Inexact Rounded pwsx2730 power 0.067 0.5 -> 0.26 Inexact Rounded pwsx2731 power 67.0E-1 0.5 -> 2.6 Inexact Rounded pwsx2732 power 67.00E-2 0.5 -> 0.82 Inexact Rounded pwsx2733 power 67E-3 0.5 -> 0.26 Inexact Rounded pwsx2734 power 67E+1 0.5 -> 26 Inexact Rounded pwsx2735 power 67E+2 0.5 -> 82 Inexact Rounded pwsx2736 power 67E+3 0.5 -> 2.6E+2 Inexact Rounded pwsx2737 power 0.68 0.5 -> 0.82 Inexact Rounded pwsx2738 power 0.068 0.5 -> 0.26 Inexact Rounded pwsx2739 power 68.0E-1 0.5 -> 2.6 Inexact Rounded pwsx2740 power 68.00E-2 0.5 -> 0.82 Inexact Rounded pwsx2741 power 68E-3 0.5 -> 0.26 Inexact Rounded pwsx2742 power 68E+1 0.5 -> 26 Inexact Rounded pwsx2743 power 68E+2 0.5 -> 82 Inexact Rounded pwsx2744 power 68E+3 0.5 -> 2.6E+2 Inexact Rounded pwsx2745 power 0.69 0.5 -> 0.83 Inexact Rounded pwsx2746 power 0.069 0.5 -> 0.26 Inexact Rounded pwsx2747 power 69.0E-1 0.5 -> 2.6 Inexact Rounded pwsx2748 power 69.00E-2 0.5 -> 0.83 Inexact Rounded pwsx2749 power 69E-3 0.5 -> 0.26 Inexact Rounded pwsx2750 power 69E+1 0.5 -> 26 Inexact Rounded pwsx2751 power 69E+2 0.5 -> 83 Inexact Rounded pwsx2752 power 69E+3 0.5 -> 2.6E+2 Inexact Rounded pwsx2753 power 0.70 0.5 -> 0.84 Inexact Rounded pwsx2754 power 0.070 0.5 -> 0.26 Inexact Rounded pwsx2755 power 70.0E-1 0.5 -> 2.6 Inexact Rounded pwsx2756 power 70.00E-2 0.5 -> 0.84 Inexact Rounded pwsx2757 power 70E-3 0.5 -> 0.26 Inexact Rounded pwsx2758 power 70E+1 0.5 -> 26 Inexact Rounded pwsx2759 power 70E+2 0.5 -> 84 Inexact Rounded pwsx2760 power 70E+3 0.5 -> 2.6E+2 Inexact Rounded pwsx2761 power 0.71 0.5 -> 0.84 Inexact Rounded pwsx2762 power 0.071 0.5 -> 0.27 Inexact Rounded pwsx2763 power 71.0E-1 0.5 -> 2.7 Inexact Rounded pwsx2764 power 71.00E-2 0.5 -> 0.84 Inexact Rounded pwsx2765 power 71E-3 0.5 -> 0.27 Inexact Rounded pwsx2766 power 71E+1 0.5 -> 27 Inexact Rounded pwsx2767 power 71E+2 0.5 -> 84 Inexact Rounded pwsx2768 power 71E+3 0.5 -> 2.7E+2 Inexact Rounded pwsx2769 power 0.72 0.5 -> 0.85 Inexact Rounded pwsx2770 power 0.072 0.5 -> 0.27 Inexact Rounded pwsx2771 power 72.0E-1 0.5 -> 2.7 Inexact Rounded pwsx2772 power 72.00E-2 0.5 -> 0.85 Inexact Rounded pwsx2773 power 72E-3 0.5 -> 0.27 Inexact Rounded pwsx2774 power 72E+1 0.5 -> 27 Inexact Rounded pwsx2775 power 72E+2 0.5 -> 85 Inexact Rounded pwsx2776 power 72E+3 0.5 -> 2.7E+2 Inexact Rounded pwsx2777 power 0.73 0.5 -> 0.85 Inexact Rounded pwsx2778 power 0.073 0.5 -> 0.27 Inexact Rounded pwsx2779 power 73.0E-1 0.5 -> 2.7 Inexact Rounded pwsx2780 power 73.00E-2 0.5 -> 0.85 Inexact Rounded pwsx2781 power 73E-3 0.5 -> 0.27 Inexact Rounded pwsx2782 power 73E+1 0.5 -> 27 Inexact Rounded pwsx2783 power 73E+2 0.5 -> 85 Inexact Rounded pwsx2784 power 73E+3 0.5 -> 2.7E+2 Inexact Rounded pwsx2785 power 0.74 0.5 -> 0.86 Inexact Rounded pwsx2786 power 0.074 0.5 -> 0.27 Inexact Rounded pwsx2787 power 74.0E-1 0.5 -> 2.7 Inexact Rounded pwsx2788 power 74.00E-2 0.5 -> 0.86 Inexact Rounded pwsx2789 power 74E-3 0.5 -> 0.27 Inexact Rounded pwsx2790 power 74E+1 0.5 -> 27 Inexact Rounded pwsx2791 power 74E+2 0.5 -> 86 Inexact Rounded pwsx2792 power 74E+3 0.5 -> 2.7E+2 Inexact Rounded pwsx2793 power 0.75 0.5 -> 0.87 Inexact Rounded pwsx2794 power 0.075 0.5 -> 0.27 Inexact Rounded pwsx2795 power 75.0E-1 0.5 -> 2.7 Inexact Rounded pwsx2796 power 75.00E-2 0.5 -> 0.87 Inexact Rounded pwsx2797 power 75E-3 0.5 -> 0.27 Inexact Rounded pwsx2798 power 75E+1 0.5 -> 27 Inexact Rounded pwsx2799 power 75E+2 0.5 -> 87 Inexact Rounded pwsx2800 power 75E+3 0.5 -> 2.7E+2 Inexact Rounded pwsx2801 power 0.76 0.5 -> 0.87 Inexact Rounded pwsx2802 power 0.076 0.5 -> 0.28 Inexact Rounded pwsx2803 power 76.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2804 power 76.00E-2 0.5 -> 0.87 Inexact Rounded pwsx2805 power 76E-3 0.5 -> 0.28 Inexact Rounded pwsx2806 power 76E+1 0.5 -> 28 Inexact Rounded pwsx2807 power 76E+2 0.5 -> 87 Inexact Rounded pwsx2808 power 76E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2809 power 0.77 0.5 -> 0.88 Inexact Rounded pwsx2810 power 0.077 0.5 -> 0.28 Inexact Rounded pwsx2811 power 77.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2812 power 77.00E-2 0.5 -> 0.88 Inexact Rounded pwsx2813 power 77E-3 0.5 -> 0.28 Inexact Rounded pwsx2814 power 77E+1 0.5 -> 28 Inexact Rounded pwsx2815 power 77E+2 0.5 -> 88 Inexact Rounded pwsx2816 power 77E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2817 power 0.78 0.5 -> 0.88 Inexact Rounded pwsx2818 power 0.078 0.5 -> 0.28 Inexact Rounded pwsx2819 power 78.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2820 power 78.00E-2 0.5 -> 0.88 Inexact Rounded pwsx2821 power 78E-3 0.5 -> 0.28 Inexact Rounded pwsx2822 power 78E+1 0.5 -> 28 Inexact Rounded pwsx2823 power 78E+2 0.5 -> 88 Inexact Rounded pwsx2824 power 78E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2825 power 0.79 0.5 -> 0.89 Inexact Rounded pwsx2826 power 0.079 0.5 -> 0.28 Inexact Rounded pwsx2827 power 79.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2828 power 79.00E-2 0.5 -> 0.89 Inexact Rounded pwsx2829 power 79E-3 0.5 -> 0.28 Inexact Rounded pwsx2830 power 79E+1 0.5 -> 28 Inexact Rounded pwsx2831 power 79E+2 0.5 -> 89 Inexact Rounded pwsx2832 power 79E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2833 power 0.80 0.5 -> 0.89 Inexact Rounded pwsx2834 power 0.080 0.5 -> 0.28 Inexact Rounded pwsx2835 power 80.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2836 power 80.00E-2 0.5 -> 0.89 Inexact Rounded pwsx2837 power 80E-3 0.5 -> 0.28 Inexact Rounded pwsx2838 power 80E+1 0.5 -> 28 Inexact Rounded pwsx2839 power 80E+2 0.5 -> 89 Inexact Rounded pwsx2840 power 80E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2841 power 0.81 0.5 -> 0.90 Inexact Rounded pwsx2842 power 0.081 0.5 -> 0.28 Inexact Rounded pwsx2843 power 81.0E-1 0.5 -> 2.8 Inexact Rounded pwsx2844 power 81.00E-2 0.5 -> 0.90 Inexact Rounded pwsx2845 power 81E-3 0.5 -> 0.28 Inexact Rounded pwsx2846 power 81E+1 0.5 -> 28 Inexact Rounded pwsx2847 power 81E+2 0.5 -> 90 Inexact Rounded pwsx2848 power 81E+3 0.5 -> 2.8E+2 Inexact Rounded pwsx2849 power 0.82 0.5 -> 0.91 Inexact Rounded pwsx2850 power 0.082 0.5 -> 0.29 Inexact Rounded pwsx2851 power 82.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2852 power 82.00E-2 0.5 -> 0.91 Inexact Rounded pwsx2853 power 82E-3 0.5 -> 0.29 Inexact Rounded pwsx2854 power 82E+1 0.5 -> 29 Inexact Rounded pwsx2855 power 82E+2 0.5 -> 91 Inexact Rounded pwsx2856 power 82E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2857 power 0.83 0.5 -> 0.91 Inexact Rounded pwsx2858 power 0.083 0.5 -> 0.29 Inexact Rounded pwsx2859 power 83.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2860 power 83.00E-2 0.5 -> 0.91 Inexact Rounded pwsx2861 power 83E-3 0.5 -> 0.29 Inexact Rounded pwsx2862 power 83E+1 0.5 -> 29 Inexact Rounded pwsx2863 power 83E+2 0.5 -> 91 Inexact Rounded pwsx2864 power 83E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2865 power 0.84 0.5 -> 0.92 Inexact Rounded pwsx2866 power 0.084 0.5 -> 0.29 Inexact Rounded pwsx2867 power 84.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2868 power 84.00E-2 0.5 -> 0.92 Inexact Rounded pwsx2869 power 84E-3 0.5 -> 0.29 Inexact Rounded pwsx2870 power 84E+1 0.5 -> 29 Inexact Rounded pwsx2871 power 84E+2 0.5 -> 92 Inexact Rounded pwsx2872 power 84E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2873 power 0.85 0.5 -> 0.92 Inexact Rounded pwsx2874 power 0.085 0.5 -> 0.29 Inexact Rounded pwsx2875 power 85.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2876 power 85.00E-2 0.5 -> 0.92 Inexact Rounded pwsx2877 power 85E-3 0.5 -> 0.29 Inexact Rounded pwsx2878 power 85E+1 0.5 -> 29 Inexact Rounded pwsx2879 power 85E+2 0.5 -> 92 Inexact Rounded pwsx2880 power 85E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2881 power 0.86 0.5 -> 0.93 Inexact Rounded pwsx2882 power 0.086 0.5 -> 0.29 Inexact Rounded pwsx2883 power 86.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2884 power 86.00E-2 0.5 -> 0.93 Inexact Rounded pwsx2885 power 86E-3 0.5 -> 0.29 Inexact Rounded pwsx2886 power 86E+1 0.5 -> 29 Inexact Rounded pwsx2887 power 86E+2 0.5 -> 93 Inexact Rounded pwsx2888 power 86E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2889 power 0.87 0.5 -> 0.93 Inexact Rounded pwsx2890 power 0.087 0.5 -> 0.29 Inexact Rounded pwsx2891 power 87.0E-1 0.5 -> 2.9 Inexact Rounded pwsx2892 power 87.00E-2 0.5 -> 0.93 Inexact Rounded pwsx2893 power 87E-3 0.5 -> 0.29 Inexact Rounded pwsx2894 power 87E+1 0.5 -> 29 Inexact Rounded pwsx2895 power 87E+2 0.5 -> 93 Inexact Rounded pwsx2896 power 87E+3 0.5 -> 2.9E+2 Inexact Rounded pwsx2897 power 0.88 0.5 -> 0.94 Inexact Rounded pwsx2898 power 0.088 0.5 -> 0.30 Inexact Rounded pwsx2899 power 88.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2900 power 88.00E-2 0.5 -> 0.94 Inexact Rounded pwsx2901 power 88E-3 0.5 -> 0.30 Inexact Rounded pwsx2902 power 88E+1 0.5 -> 30 Inexact Rounded pwsx2903 power 88E+2 0.5 -> 94 Inexact Rounded pwsx2904 power 88E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2905 power 0.89 0.5 -> 0.94 Inexact Rounded pwsx2906 power 0.089 0.5 -> 0.30 Inexact Rounded pwsx2907 power 89.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2908 power 89.00E-2 0.5 -> 0.94 Inexact Rounded pwsx2909 power 89E-3 0.5 -> 0.30 Inexact Rounded pwsx2910 power 89E+1 0.5 -> 30 Inexact Rounded pwsx2911 power 89E+2 0.5 -> 94 Inexact Rounded pwsx2912 power 89E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2913 power 0.90 0.5 -> 0.95 Inexact Rounded pwsx2914 power 0.090 0.5 -> 0.30 Inexact Rounded pwsx2915 power 90.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2916 power 90.00E-2 0.5 -> 0.95 Inexact Rounded pwsx2917 power 90E-3 0.5 -> 0.30 Inexact Rounded pwsx2918 power 90E+1 0.5 -> 30 Inexact Rounded pwsx2919 power 90E+2 0.5 -> 95 Inexact Rounded pwsx2920 power 90E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2921 power 0.91 0.5 -> 0.95 Inexact Rounded pwsx2922 power 0.091 0.5 -> 0.30 Inexact Rounded pwsx2923 power 91.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2924 power 91.00E-2 0.5 -> 0.95 Inexact Rounded pwsx2925 power 91E-3 0.5 -> 0.30 Inexact Rounded pwsx2926 power 91E+1 0.5 -> 30 Inexact Rounded pwsx2927 power 91E+2 0.5 -> 95 Inexact Rounded pwsx2928 power 91E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2929 power 0.92 0.5 -> 0.96 Inexact Rounded pwsx2930 power 0.092 0.5 -> 0.30 Inexact Rounded pwsx2931 power 92.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2932 power 92.00E-2 0.5 -> 0.96 Inexact Rounded pwsx2933 power 92E-3 0.5 -> 0.30 Inexact Rounded pwsx2934 power 92E+1 0.5 -> 30 Inexact Rounded pwsx2935 power 92E+2 0.5 -> 96 Inexact Rounded pwsx2936 power 92E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2937 power 0.93 0.5 -> 0.96 Inexact Rounded pwsx2938 power 0.093 0.5 -> 0.30 Inexact Rounded pwsx2939 power 93.0E-1 0.5 -> 3.0 Inexact Rounded pwsx2940 power 93.00E-2 0.5 -> 0.96 Inexact Rounded pwsx2941 power 93E-3 0.5 -> 0.30 Inexact Rounded pwsx2942 power 93E+1 0.5 -> 30 Inexact Rounded pwsx2943 power 93E+2 0.5 -> 96 Inexact Rounded pwsx2944 power 93E+3 0.5 -> 3.0E+2 Inexact Rounded pwsx2945 power 0.94 0.5 -> 0.97 Inexact Rounded pwsx2946 power 0.094 0.5 -> 0.31 Inexact Rounded pwsx2947 power 94.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2948 power 94.00E-2 0.5 -> 0.97 Inexact Rounded pwsx2949 power 94E-3 0.5 -> 0.31 Inexact Rounded pwsx2950 power 94E+1 0.5 -> 31 Inexact Rounded pwsx2951 power 94E+2 0.5 -> 97 Inexact Rounded pwsx2952 power 94E+3 0.5 -> 3.1E+2 Inexact Rounded pwsx2953 power 0.95 0.5 -> 0.97 Inexact Rounded pwsx2954 power 0.095 0.5 -> 0.31 Inexact Rounded pwsx2955 power 95.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2956 power 95.00E-2 0.5 -> 0.97 Inexact Rounded pwsx2957 power 95E-3 0.5 -> 0.31 Inexact Rounded pwsx2958 power 95E+1 0.5 -> 31 Inexact Rounded pwsx2959 power 95E+2 0.5 -> 97 Inexact Rounded pwsx2960 power 95E+3 0.5 -> 3.1E+2 Inexact Rounded pwsx2961 power 0.96 0.5 -> 0.98 Inexact Rounded pwsx2962 power 0.096 0.5 -> 0.31 Inexact Rounded pwsx2963 power 96.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2964 power 96.00E-2 0.5 -> 0.98 Inexact Rounded pwsx2965 power 96E-3 0.5 -> 0.31 Inexact Rounded pwsx2966 power 96E+1 0.5 -> 31 Inexact Rounded pwsx2967 power 96E+2 0.5 -> 98 Inexact Rounded pwsx2968 power 96E+3 0.5 -> 3.1E+2 Inexact Rounded pwsx2969 power 0.97 0.5 -> 0.98 Inexact Rounded pwsx2970 power 0.097 0.5 -> 0.31 Inexact Rounded pwsx2971 power 97.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2972 power 97.00E-2 0.5 -> 0.98 Inexact Rounded pwsx2973 power 97E-3 0.5 -> 0.31 Inexact Rounded pwsx2974 power 97E+1 0.5 -> 31 Inexact Rounded pwsx2975 power 97E+2 0.5 -> 98 Inexact Rounded pwsx2976 power 97E+3 0.5 -> 3.1E+2 Inexact Rounded pwsx2977 power 0.98 0.5 -> 0.99 Inexact Rounded pwsx2978 power 0.098 0.5 -> 0.31 Inexact Rounded pwsx2979 power 98.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2980 power 98.00E-2 0.5 -> 0.99 Inexact Rounded pwsx2981 power 98E-3 0.5 -> 0.31 Inexact Rounded pwsx2982 power 98E+1 0.5 -> 31 Inexact Rounded pwsx2983 power 98E+2 0.5 -> 99 Inexact Rounded pwsx2984 power 98E+3 0.5 -> 3.1E+2 Inexact Rounded pwsx2985 power 0.99 0.5 -> 0.99 Inexact Rounded pwsx2986 power 0.099 0.5 -> 0.31 Inexact Rounded pwsx2987 power 99.0E-1 0.5 -> 3.1 Inexact Rounded pwsx2988 power 99.00E-2 0.5 -> 0.99 Inexact Rounded pwsx2989 power 99E-3 0.5 -> 0.31 Inexact Rounded pwsx2990 power 99E+1 0.5 -> 31 Inexact Rounded pwsx2991 power 99E+2 0.5 -> 99 Inexact Rounded pwsx2992 power 99E+3 0.5 -> 3.1E+2 Inexact Rounded -- Precision 3 squareroot tests [exhaustive, f and f/10] rounding: half_even maxExponent: 999 minexponent: -999 precision: 3 pwsx3001 power 0.1 0.5 -> 0.316 Inexact Rounded pwsx3002 power 0.01 0.5 -> 0.100 Inexact Rounded pwsx3003 power 0.2 0.5 -> 0.447 Inexact Rounded pwsx3004 power 0.02 0.5 -> 0.141 Inexact Rounded pwsx3005 power 0.3 0.5 -> 0.548 Inexact Rounded pwsx3006 power 0.03 0.5 -> 0.173 Inexact Rounded pwsx3007 power 0.4 0.5 -> 0.632 Inexact Rounded pwsx3008 power 0.04 0.5 -> 0.200 Inexact Rounded pwsx3009 power 0.5 0.5 -> 0.707 Inexact Rounded pwsx3010 power 0.05 0.5 -> 0.224 Inexact Rounded pwsx3011 power 0.6 0.5 -> 0.775 Inexact Rounded pwsx3012 power 0.06 0.5 -> 0.245 Inexact Rounded pwsx3013 power 0.7 0.5 -> 0.837 Inexact Rounded pwsx3014 power 0.07 0.5 -> 0.265 Inexact Rounded pwsx3015 power 0.8 0.5 -> 0.894 Inexact Rounded pwsx3016 power 0.08 0.5 -> 0.283 Inexact Rounded pwsx3017 power 0.9 0.5 -> 0.949 Inexact Rounded pwsx3018 power 0.09 0.5 -> 0.300 Inexact Rounded pwsx3019 power 0.11 0.5 -> 0.332 Inexact Rounded pwsx3020 power 0.011 0.5 -> 0.105 Inexact Rounded pwsx3021 power 0.12 0.5 -> 0.346 Inexact Rounded pwsx3022 power 0.012 0.5 -> 0.110 Inexact Rounded pwsx3023 power 0.13 0.5 -> 0.361 Inexact Rounded pwsx3024 power 0.013 0.5 -> 0.114 Inexact Rounded pwsx3025 power 0.14 0.5 -> 0.374 Inexact Rounded pwsx3026 power 0.014 0.5 -> 0.118 Inexact Rounded pwsx3027 power 0.15 0.5 -> 0.387 Inexact Rounded pwsx3028 power 0.015 0.5 -> 0.122 Inexact Rounded pwsx3029 power 0.16 0.5 -> 0.400 Inexact Rounded pwsx3030 power 0.016 0.5 -> 0.126 Inexact Rounded pwsx3031 power 0.17 0.5 -> 0.412 Inexact Rounded pwsx3032 power 0.017 0.5 -> 0.130 Inexact Rounded pwsx3033 power 0.18 0.5 -> 0.424 Inexact Rounded pwsx3034 power 0.018 0.5 -> 0.134 Inexact Rounded pwsx3035 power 0.19 0.5 -> 0.436 Inexact Rounded pwsx3036 power 0.019 0.5 -> 0.138 Inexact Rounded pwsx3037 power 0.21 0.5 -> 0.458 Inexact Rounded pwsx3038 power 0.021 0.5 -> 0.145 Inexact Rounded pwsx3039 power 0.22 0.5 -> 0.469 Inexact Rounded pwsx3040 power 0.022 0.5 -> 0.148 Inexact Rounded pwsx3041 power 0.23 0.5 -> 0.480 Inexact Rounded pwsx3042 power 0.023 0.5 -> 0.152 Inexact Rounded pwsx3043 power 0.24 0.5 -> 0.490 Inexact Rounded pwsx3044 power 0.024 0.5 -> 0.155 Inexact Rounded pwsx3045 power 0.25 0.5 -> 0.500 Inexact Rounded pwsx3046 power 0.025 0.5 -> 0.158 Inexact Rounded pwsx3047 power 0.26 0.5 -> 0.510 Inexact Rounded pwsx3048 power 0.026 0.5 -> 0.161 Inexact Rounded pwsx3049 power 0.27 0.5 -> 0.520 Inexact Rounded pwsx3050 power 0.027 0.5 -> 0.164 Inexact Rounded pwsx3051 power 0.28 0.5 -> 0.529 Inexact Rounded pwsx3052 power 0.028 0.5 -> 0.167 Inexact Rounded pwsx3053 power 0.29 0.5 -> 0.539 Inexact Rounded pwsx3054 power 0.029 0.5 -> 0.170 Inexact Rounded pwsx3055 power 0.31 0.5 -> 0.557 Inexact Rounded pwsx3056 power 0.031 0.5 -> 0.176 Inexact Rounded pwsx3057 power 0.32 0.5 -> 0.566 Inexact Rounded pwsx3058 power 0.032 0.5 -> 0.179 Inexact Rounded pwsx3059 power 0.33 0.5 -> 0.574 Inexact Rounded pwsx3060 power 0.033 0.5 -> 0.182 Inexact Rounded pwsx3061 power 0.34 0.5 -> 0.583 Inexact Rounded pwsx3062 power 0.034 0.5 -> 0.184 Inexact Rounded pwsx3063 power 0.35 0.5 -> 0.592 Inexact Rounded pwsx3064 power 0.035 0.5 -> 0.187 Inexact Rounded pwsx3065 power 0.36 0.5 -> 0.600 Inexact Rounded pwsx3066 power 0.036 0.5 -> 0.190 Inexact Rounded pwsx3067 power 0.37 0.5 -> 0.608 Inexact Rounded pwsx3068 power 0.037 0.5 -> 0.192 Inexact Rounded pwsx3069 power 0.38 0.5 -> 0.616 Inexact Rounded pwsx3070 power 0.038 0.5 -> 0.195 Inexact Rounded pwsx3071 power 0.39 0.5 -> 0.624 Inexact Rounded pwsx3072 power 0.039 0.5 -> 0.197 Inexact Rounded pwsx3073 power 0.41 0.5 -> 0.640 Inexact Rounded pwsx3074 power 0.041 0.5 -> 0.202 Inexact Rounded pwsx3075 power 0.42 0.5 -> 0.648 Inexact Rounded pwsx3076 power 0.042 0.5 -> 0.205 Inexact Rounded pwsx3077 power 0.43 0.5 -> 0.656 Inexact Rounded pwsx3078 power 0.043 0.5 -> 0.207 Inexact Rounded pwsx3079 power 0.44 0.5 -> 0.663 Inexact Rounded pwsx3080 power 0.044 0.5 -> 0.210 Inexact Rounded pwsx3081 power 0.45 0.5 -> 0.671 Inexact Rounded pwsx3082 power 0.045 0.5 -> 0.212 Inexact Rounded pwsx3083 power 0.46 0.5 -> 0.678 Inexact Rounded pwsx3084 power 0.046 0.5 -> 0.214 Inexact Rounded pwsx3085 power 0.47 0.5 -> 0.686 Inexact Rounded pwsx3086 power 0.047 0.5 -> 0.217 Inexact Rounded pwsx3087 power 0.48 0.5 -> 0.693 Inexact Rounded pwsx3088 power 0.048 0.5 -> 0.219 Inexact Rounded pwsx3089 power 0.49 0.5 -> 0.700 Inexact Rounded pwsx3090 power 0.049 0.5 -> 0.221 Inexact Rounded pwsx3091 power 0.51 0.5 -> 0.714 Inexact Rounded pwsx3092 power 0.051 0.5 -> 0.226 Inexact Rounded pwsx3093 power 0.52 0.5 -> 0.721 Inexact Rounded pwsx3094 power 0.052 0.5 -> 0.228 Inexact Rounded pwsx3095 power 0.53 0.5 -> 0.728 Inexact Rounded pwsx3096 power 0.053 0.5 -> 0.230 Inexact Rounded pwsx3097 power 0.54 0.5 -> 0.735 Inexact Rounded pwsx3098 power 0.054 0.5 -> 0.232 Inexact Rounded pwsx3099 power 0.55 0.5 -> 0.742 Inexact Rounded pwsx3100 power 0.055 0.5 -> 0.235 Inexact Rounded pwsx3101 power 0.56 0.5 -> 0.748 Inexact Rounded pwsx3102 power 0.056 0.5 -> 0.237 Inexact Rounded pwsx3103 power 0.57 0.5 -> 0.755 Inexact Rounded pwsx3104 power 0.057 0.5 -> 0.239 Inexact Rounded pwsx3105 power 0.58 0.5 -> 0.762 Inexact Rounded pwsx3106 power 0.058 0.5 -> 0.241 Inexact Rounded pwsx3107 power 0.59 0.5 -> 0.768 Inexact Rounded pwsx3108 power 0.059 0.5 -> 0.243 Inexact Rounded pwsx3109 power 0.61 0.5 -> 0.781 Inexact Rounded pwsx3110 power 0.061 0.5 -> 0.247 Inexact Rounded pwsx3111 power 0.62 0.5 -> 0.787 Inexact Rounded pwsx3112 power 0.062 0.5 -> 0.249 Inexact Rounded pwsx3113 power 0.63 0.5 -> 0.794 Inexact Rounded pwsx3114 power 0.063 0.5 -> 0.251 Inexact Rounded pwsx3115 power 0.64 0.5 -> 0.800 Inexact Rounded pwsx3116 power 0.064 0.5 -> 0.253 Inexact Rounded pwsx3117 power 0.65 0.5 -> 0.806 Inexact Rounded pwsx3118 power 0.065 0.5 -> 0.255 Inexact Rounded pwsx3119 power 0.66 0.5 -> 0.812 Inexact Rounded pwsx3120 power 0.066 0.5 -> 0.257 Inexact Rounded pwsx3121 power 0.67 0.5 -> 0.819 Inexact Rounded pwsx3122 power 0.067 0.5 -> 0.259 Inexact Rounded pwsx3123 power 0.68 0.5 -> 0.825 Inexact Rounded pwsx3124 power 0.068 0.5 -> 0.261 Inexact Rounded pwsx3125 power 0.69 0.5 -> 0.831 Inexact Rounded pwsx3126 power 0.069 0.5 -> 0.263 Inexact Rounded pwsx3127 power 0.71 0.5 -> 0.843 Inexact Rounded pwsx3128 power 0.071 0.5 -> 0.266 Inexact Rounded pwsx3129 power 0.72 0.5 -> 0.849 Inexact Rounded pwsx3130 power 0.072 0.5 -> 0.268 Inexact Rounded pwsx3131 power 0.73 0.5 -> 0.854 Inexact Rounded pwsx3132 power 0.073 0.5 -> 0.270 Inexact Rounded pwsx3133 power 0.74 0.5 -> 0.860 Inexact Rounded pwsx3134 power 0.074 0.5 -> 0.272 Inexact Rounded pwsx3135 power 0.75 0.5 -> 0.866 Inexact Rounded pwsx3136 power 0.075 0.5 -> 0.274 Inexact Rounded pwsx3137 power 0.76 0.5 -> 0.872 Inexact Rounded pwsx3138 power 0.076 0.5 -> 0.276 Inexact Rounded pwsx3139 power 0.77 0.5 -> 0.877 Inexact Rounded pwsx3140 power 0.077 0.5 -> 0.277 Inexact Rounded pwsx3141 power 0.78 0.5 -> 0.883 Inexact Rounded pwsx3142 power 0.078 0.5 -> 0.279 Inexact Rounded pwsx3143 power 0.79 0.5 -> 0.889 Inexact Rounded pwsx3144 power 0.079 0.5 -> 0.281 Inexact Rounded pwsx3145 power 0.81 0.5 -> 0.900 Inexact Rounded pwsx3146 power 0.081 0.5 -> 0.285 Inexact Rounded pwsx3147 power 0.82 0.5 -> 0.906 Inexact Rounded pwsx3148 power 0.082 0.5 -> 0.286 Inexact Rounded pwsx3149 power 0.83 0.5 -> 0.911 Inexact Rounded pwsx3150 power 0.083 0.5 -> 0.288 Inexact Rounded pwsx3151 power 0.84 0.5 -> 0.917 Inexact Rounded pwsx3152 power 0.084 0.5 -> 0.290 Inexact Rounded pwsx3153 power 0.85 0.5 -> 0.922 Inexact Rounded pwsx3154 power 0.085 0.5 -> 0.292 Inexact Rounded pwsx3155 power 0.86 0.5 -> 0.927 Inexact Rounded pwsx3156 power 0.086 0.5 -> 0.293 Inexact Rounded pwsx3157 power 0.87 0.5 -> 0.933 Inexact Rounded pwsx3158 power 0.087 0.5 -> 0.295 Inexact Rounded pwsx3159 power 0.88 0.5 -> 0.938 Inexact Rounded pwsx3160 power 0.088 0.5 -> 0.297 Inexact Rounded pwsx3161 power 0.89 0.5 -> 0.943 Inexact Rounded pwsx3162 power 0.089 0.5 -> 0.298 Inexact Rounded pwsx3163 power 0.91 0.5 -> 0.954 Inexact Rounded pwsx3164 power 0.091 0.5 -> 0.302 Inexact Rounded pwsx3165 power 0.92 0.5 -> 0.959 Inexact Rounded pwsx3166 power 0.092 0.5 -> 0.303 Inexact Rounded pwsx3167 power 0.93 0.5 -> 0.964 Inexact Rounded pwsx3168 power 0.093 0.5 -> 0.305 Inexact Rounded pwsx3169 power 0.94 0.5 -> 0.970 Inexact Rounded pwsx3170 power 0.094 0.5 -> 0.307 Inexact Rounded pwsx3171 power 0.95 0.5 -> 0.975 Inexact Rounded pwsx3172 power 0.095 0.5 -> 0.308 Inexact Rounded pwsx3173 power 0.96 0.5 -> 0.980 Inexact Rounded pwsx3174 power 0.096 0.5 -> 0.310 Inexact Rounded pwsx3175 power 0.97 0.5 -> 0.985 Inexact Rounded pwsx3176 power 0.097 0.5 -> 0.311 Inexact Rounded pwsx3177 power 0.98 0.5 -> 0.990 Inexact Rounded pwsx3178 power 0.098 0.5 -> 0.313 Inexact Rounded pwsx3179 power 0.99 0.5 -> 0.995 Inexact Rounded pwsx3180 power 0.099 0.5 -> 0.315 Inexact Rounded pwsx3181 power 0.101 0.5 -> 0.318 Inexact Rounded pwsx3182 power 0.0101 0.5 -> 0.100 Inexact Rounded pwsx3183 power 0.102 0.5 -> 0.319 Inexact Rounded pwsx3184 power 0.0102 0.5 -> 0.101 Inexact Rounded pwsx3185 power 0.103 0.5 -> 0.321 Inexact Rounded pwsx3186 power 0.0103 0.5 -> 0.101 Inexact Rounded pwsx3187 power 0.104 0.5 -> 0.322 Inexact Rounded pwsx3188 power 0.0104 0.5 -> 0.102 Inexact Rounded pwsx3189 power 0.105 0.5 -> 0.324 Inexact Rounded pwsx3190 power 0.0105 0.5 -> 0.102 Inexact Rounded pwsx3191 power 0.106 0.5 -> 0.326 Inexact Rounded pwsx3192 power 0.0106 0.5 -> 0.103 Inexact Rounded pwsx3193 power 0.107 0.5 -> 0.327 Inexact Rounded pwsx3194 power 0.0107 0.5 -> 0.103 Inexact Rounded pwsx3195 power 0.108 0.5 -> 0.329 Inexact Rounded pwsx3196 power 0.0108 0.5 -> 0.104 Inexact Rounded pwsx3197 power 0.109 0.5 -> 0.330 Inexact Rounded pwsx3198 power 0.0109 0.5 -> 0.104 Inexact Rounded pwsx3199 power 0.111 0.5 -> 0.333 Inexact Rounded pwsx3200 power 0.0111 0.5 -> 0.105 Inexact Rounded pwsx3201 power 0.112 0.5 -> 0.335 Inexact Rounded pwsx3202 power 0.0112 0.5 -> 0.106 Inexact Rounded pwsx3203 power 0.113 0.5 -> 0.336 Inexact Rounded pwsx3204 power 0.0113 0.5 -> 0.106 Inexact Rounded pwsx3205 power 0.114 0.5 -> 0.338 Inexact Rounded pwsx3206 power 0.0114 0.5 -> 0.107 Inexact Rounded pwsx3207 power 0.115 0.5 -> 0.339 Inexact Rounded pwsx3208 power 0.0115 0.5 -> 0.107 Inexact Rounded pwsx3209 power 0.116 0.5 -> 0.341 Inexact Rounded pwsx3210 power 0.0116 0.5 -> 0.108 Inexact Rounded pwsx3211 power 0.117 0.5 -> 0.342 Inexact Rounded pwsx3212 power 0.0117 0.5 -> 0.108 Inexact Rounded pwsx3213 power 0.118 0.5 -> 0.344 Inexact Rounded pwsx3214 power 0.0118 0.5 -> 0.109 Inexact Rounded pwsx3215 power 0.119 0.5 -> 0.345 Inexact Rounded pwsx3216 power 0.0119 0.5 -> 0.109 Inexact Rounded pwsx3217 power 0.121 0.5 -> 0.348 Inexact Rounded pwsx3218 power 0.0121 0.5 -> 0.110 Inexact Rounded pwsx3219 power 0.122 0.5 -> 0.349 Inexact Rounded pwsx3220 power 0.0122 0.5 -> 0.110 Inexact Rounded pwsx3221 power 0.123 0.5 -> 0.351 Inexact Rounded pwsx3222 power 0.0123 0.5 -> 0.111 Inexact Rounded pwsx3223 power 0.124 0.5 -> 0.352 Inexact Rounded pwsx3224 power 0.0124 0.5 -> 0.111 Inexact Rounded pwsx3225 power 0.125 0.5 -> 0.354 Inexact Rounded pwsx3226 power 0.0125 0.5 -> 0.112 Inexact Rounded pwsx3227 power 0.126 0.5 -> 0.355 Inexact Rounded pwsx3228 power 0.0126 0.5 -> 0.112 Inexact Rounded pwsx3229 power 0.127 0.5 -> 0.356 Inexact Rounded pwsx3230 power 0.0127 0.5 -> 0.113 Inexact Rounded pwsx3231 power 0.128 0.5 -> 0.358 Inexact Rounded pwsx3232 power 0.0128 0.5 -> 0.113 Inexact Rounded pwsx3233 power 0.129 0.5 -> 0.359 Inexact Rounded pwsx3234 power 0.0129 0.5 -> 0.114 Inexact Rounded pwsx3235 power 0.131 0.5 -> 0.362 Inexact Rounded pwsx3236 power 0.0131 0.5 -> 0.114 Inexact Rounded pwsx3237 power 0.132 0.5 -> 0.363 Inexact Rounded pwsx3238 power 0.0132 0.5 -> 0.115 Inexact Rounded pwsx3239 power 0.133 0.5 -> 0.365 Inexact Rounded pwsx3240 power 0.0133 0.5 -> 0.115 Inexact Rounded pwsx3241 power 0.134 0.5 -> 0.366 Inexact Rounded pwsx3242 power 0.0134 0.5 -> 0.116 Inexact Rounded pwsx3243 power 0.135 0.5 -> 0.367 Inexact Rounded pwsx3244 power 0.0135 0.5 -> 0.116 Inexact Rounded pwsx3245 power 0.136 0.5 -> 0.369 Inexact Rounded pwsx3246 power 0.0136 0.5 -> 0.117 Inexact Rounded pwsx3247 power 0.137 0.5 -> 0.370 Inexact Rounded pwsx3248 power 0.0137 0.5 -> 0.117 Inexact Rounded pwsx3249 power 0.138 0.5 -> 0.371 Inexact Rounded pwsx3250 power 0.0138 0.5 -> 0.117 Inexact Rounded pwsx3251 power 0.139 0.5 -> 0.373 Inexact Rounded pwsx3252 power 0.0139 0.5 -> 0.118 Inexact Rounded pwsx3253 power 0.141 0.5 -> 0.375 Inexact Rounded pwsx3254 power 0.0141 0.5 -> 0.119 Inexact Rounded pwsx3255 power 0.142 0.5 -> 0.377 Inexact Rounded pwsx3256 power 0.0142 0.5 -> 0.119 Inexact Rounded pwsx3257 power 0.143 0.5 -> 0.378 Inexact Rounded pwsx3258 power 0.0143 0.5 -> 0.120 Inexact Rounded pwsx3259 power 0.144 0.5 -> 0.379 Inexact Rounded pwsx3260 power 0.0144 0.5 -> 0.120 Inexact Rounded pwsx3261 power 0.145 0.5 -> 0.381 Inexact Rounded pwsx3262 power 0.0145 0.5 -> 0.120 Inexact Rounded pwsx3263 power 0.146 0.5 -> 0.382 Inexact Rounded pwsx3264 power 0.0146 0.5 -> 0.121 Inexact Rounded pwsx3265 power 0.147 0.5 -> 0.383 Inexact Rounded pwsx3266 power 0.0147 0.5 -> 0.121 Inexact Rounded pwsx3267 power 0.148 0.5 -> 0.385 Inexact Rounded pwsx3268 power 0.0148 0.5 -> 0.122 Inexact Rounded pwsx3269 power 0.149 0.5 -> 0.386 Inexact Rounded pwsx3270 power 0.0149 0.5 -> 0.122 Inexact Rounded pwsx3271 power 0.151 0.5 -> 0.389 Inexact Rounded pwsx3272 power 0.0151 0.5 -> 0.123 Inexact Rounded pwsx3273 power 0.152 0.5 -> 0.390 Inexact Rounded pwsx3274 power 0.0152 0.5 -> 0.123 Inexact Rounded pwsx3275 power 0.153 0.5 -> 0.391 Inexact Rounded pwsx3276 power 0.0153 0.5 -> 0.124 Inexact Rounded pwsx3277 power 0.154 0.5 -> 0.392 Inexact Rounded pwsx3278 power 0.0154 0.5 -> 0.124 Inexact Rounded pwsx3279 power 0.155 0.5 -> 0.394 Inexact Rounded pwsx3280 power 0.0155 0.5 -> 0.124 Inexact Rounded pwsx3281 power 0.156 0.5 -> 0.395 Inexact Rounded pwsx3282 power 0.0156 0.5 -> 0.125 Inexact Rounded pwsx3283 power 0.157 0.5 -> 0.396 Inexact Rounded pwsx3284 power 0.0157 0.5 -> 0.125 Inexact Rounded pwsx3285 power 0.158 0.5 -> 0.397 Inexact Rounded pwsx3286 power 0.0158 0.5 -> 0.126 Inexact Rounded pwsx3287 power 0.159 0.5 -> 0.399 Inexact Rounded pwsx3288 power 0.0159 0.5 -> 0.126 Inexact Rounded pwsx3289 power 0.161 0.5 -> 0.401 Inexact Rounded pwsx3290 power 0.0161 0.5 -> 0.127 Inexact Rounded pwsx3291 power 0.162 0.5 -> 0.402 Inexact Rounded pwsx3292 power 0.0162 0.5 -> 0.127 Inexact Rounded pwsx3293 power 0.163 0.5 -> 0.404 Inexact Rounded pwsx3294 power 0.0163 0.5 -> 0.128 Inexact Rounded pwsx3295 power 0.164 0.5 -> 0.405 Inexact Rounded pwsx3296 power 0.0164 0.5 -> 0.128 Inexact Rounded pwsx3297 power 0.165 0.5 -> 0.406 Inexact Rounded pwsx3298 power 0.0165 0.5 -> 0.128 Inexact Rounded pwsx3299 power 0.166 0.5 -> 0.407 Inexact Rounded pwsx3300 power 0.0166 0.5 -> 0.129 Inexact Rounded pwsx3301 power 0.167 0.5 -> 0.409 Inexact Rounded pwsx3302 power 0.0167 0.5 -> 0.129 Inexact Rounded pwsx3303 power 0.168 0.5 -> 0.410 Inexact Rounded pwsx3304 power 0.0168 0.5 -> 0.130 Inexact Rounded pwsx3305 power 0.169 0.5 -> 0.411 Inexact Rounded pwsx3306 power 0.0169 0.5 -> 0.130 Inexact Rounded pwsx3307 power 0.171 0.5 -> 0.414 Inexact Rounded pwsx3308 power 0.0171 0.5 -> 0.131 Inexact Rounded pwsx3309 power 0.172 0.5 -> 0.415 Inexact Rounded pwsx3310 power 0.0172 0.5 -> 0.131 Inexact Rounded pwsx3311 power 0.173 0.5 -> 0.416 Inexact Rounded pwsx3312 power 0.0173 0.5 -> 0.132 Inexact Rounded pwsx3313 power 0.174 0.5 -> 0.417 Inexact Rounded pwsx3314 power 0.0174 0.5 -> 0.132 Inexact Rounded pwsx3315 power 0.175 0.5 -> 0.418 Inexact Rounded pwsx3316 power 0.0175 0.5 -> 0.132 Inexact Rounded pwsx3317 power 0.176 0.5 -> 0.420 Inexact Rounded pwsx3318 power 0.0176 0.5 -> 0.133 Inexact Rounded pwsx3319 power 0.177 0.5 -> 0.421 Inexact Rounded pwsx3320 power 0.0177 0.5 -> 0.133 Inexact Rounded pwsx3321 power 0.178 0.5 -> 0.422 Inexact Rounded pwsx3322 power 0.0178 0.5 -> 0.133 Inexact Rounded pwsx3323 power 0.179 0.5 -> 0.423 Inexact Rounded pwsx3324 power 0.0179 0.5 -> 0.134 Inexact Rounded pwsx3325 power 0.181 0.5 -> 0.425 Inexact Rounded pwsx3326 power 0.0181 0.5 -> 0.135 Inexact Rounded pwsx3327 power 0.182 0.5 -> 0.427 Inexact Rounded pwsx3328 power 0.0182 0.5 -> 0.135 Inexact Rounded pwsx3329 power 0.183 0.5 -> 0.428 Inexact Rounded pwsx3330 power 0.0183 0.5 -> 0.135 Inexact Rounded pwsx3331 power 0.184 0.5 -> 0.429 Inexact Rounded pwsx3332 power 0.0184 0.5 -> 0.136 Inexact Rounded pwsx3333 power 0.185 0.5 -> 0.430 Inexact Rounded pwsx3334 power 0.0185 0.5 -> 0.136 Inexact Rounded pwsx3335 power 0.186 0.5 -> 0.431 Inexact Rounded pwsx3336 power 0.0186 0.5 -> 0.136 Inexact Rounded pwsx3337 power 0.187 0.5 -> 0.432 Inexact Rounded pwsx3338 power 0.0187 0.5 -> 0.137 Inexact Rounded pwsx3339 power 0.188 0.5 -> 0.434 Inexact Rounded pwsx3340 power 0.0188 0.5 -> 0.137 Inexact Rounded pwsx3341 power 0.189 0.5 -> 0.435 Inexact Rounded pwsx3342 power 0.0189 0.5 -> 0.137 Inexact Rounded pwsx3343 power 0.191 0.5 -> 0.437 Inexact Rounded pwsx3344 power 0.0191 0.5 -> 0.138 Inexact Rounded pwsx3345 power 0.192 0.5 -> 0.438 Inexact Rounded pwsx3346 power 0.0192 0.5 -> 0.139 Inexact Rounded pwsx3347 power 0.193 0.5 -> 0.439 Inexact Rounded pwsx3348 power 0.0193 0.5 -> 0.139 Inexact Rounded pwsx3349 power 0.194 0.5 -> 0.440 Inexact Rounded pwsx3350 power 0.0194 0.5 -> 0.139 Inexact Rounded pwsx3351 power 0.195 0.5 -> 0.442 Inexact Rounded pwsx3352 power 0.0195 0.5 -> 0.140 Inexact Rounded pwsx3353 power 0.196 0.5 -> 0.443 Inexact Rounded pwsx3354 power 0.0196 0.5 -> 0.140 Inexact Rounded pwsx3355 power 0.197 0.5 -> 0.444 Inexact Rounded pwsx3356 power 0.0197 0.5 -> 0.140 Inexact Rounded pwsx3357 power 0.198 0.5 -> 0.445 Inexact Rounded pwsx3358 power 0.0198 0.5 -> 0.141 Inexact Rounded pwsx3359 power 0.199 0.5 -> 0.446 Inexact Rounded pwsx3360 power 0.0199 0.5 -> 0.141 Inexact Rounded pwsx3361 power 0.201 0.5 -> 0.448 Inexact Rounded pwsx3362 power 0.0201 0.5 -> 0.142 Inexact Rounded pwsx3363 power 0.202 0.5 -> 0.449 Inexact Rounded pwsx3364 power 0.0202 0.5 -> 0.142 Inexact Rounded pwsx3365 power 0.203 0.5 -> 0.451 Inexact Rounded pwsx3366 power 0.0203 0.5 -> 0.142 Inexact Rounded pwsx3367 power 0.204 0.5 -> 0.452 Inexact Rounded pwsx3368 power 0.0204 0.5 -> 0.143 Inexact Rounded pwsx3369 power 0.205 0.5 -> 0.453 Inexact Rounded pwsx3370 power 0.0205 0.5 -> 0.143 Inexact Rounded pwsx3371 power 0.206 0.5 -> 0.454 Inexact Rounded pwsx3372 power 0.0206 0.5 -> 0.144 Inexact Rounded pwsx3373 power 0.207 0.5 -> 0.455 Inexact Rounded pwsx3374 power 0.0207 0.5 -> 0.144 Inexact Rounded pwsx3375 power 0.208 0.5 -> 0.456 Inexact Rounded pwsx3376 power 0.0208 0.5 -> 0.144 Inexact Rounded pwsx3377 power 0.209 0.5 -> 0.457 Inexact Rounded pwsx3378 power 0.0209 0.5 -> 0.145 Inexact Rounded pwsx3379 power 0.211 0.5 -> 0.459 Inexact Rounded pwsx3380 power 0.0211 0.5 -> 0.145 Inexact Rounded pwsx3381 power 0.212 0.5 -> 0.460 Inexact Rounded pwsx3382 power 0.0212 0.5 -> 0.146 Inexact Rounded pwsx3383 power 0.213 0.5 -> 0.462 Inexact Rounded pwsx3384 power 0.0213 0.5 -> 0.146 Inexact Rounded pwsx3385 power 0.214 0.5 -> 0.463 Inexact Rounded pwsx3386 power 0.0214 0.5 -> 0.146 Inexact Rounded pwsx3387 power 0.215 0.5 -> 0.464 Inexact Rounded pwsx3388 power 0.0215 0.5 -> 0.147 Inexact Rounded pwsx3389 power 0.216 0.5 -> 0.465 Inexact Rounded pwsx3390 power 0.0216 0.5 -> 0.147 Inexact Rounded pwsx3391 power 0.217 0.5 -> 0.466 Inexact Rounded pwsx3392 power 0.0217 0.5 -> 0.147 Inexact Rounded pwsx3393 power 0.218 0.5 -> 0.467 Inexact Rounded pwsx3394 power 0.0218 0.5 -> 0.148 Inexact Rounded pwsx3395 power 0.219 0.5 -> 0.468 Inexact Rounded pwsx3396 power 0.0219 0.5 -> 0.148 Inexact Rounded pwsx3397 power 0.221 0.5 -> 0.470 Inexact Rounded pwsx3398 power 0.0221 0.5 -> 0.149 Inexact Rounded pwsx3399 power 0.222 0.5 -> 0.471 Inexact Rounded pwsx3400 power 0.0222 0.5 -> 0.149 Inexact Rounded pwsx3401 power 0.223 0.5 -> 0.472 Inexact Rounded pwsx3402 power 0.0223 0.5 -> 0.149 Inexact Rounded pwsx3403 power 0.224 0.5 -> 0.473 Inexact Rounded pwsx3404 power 0.0224 0.5 -> 0.150 Inexact Rounded pwsx3405 power 0.225 0.5 -> 0.474 Inexact Rounded pwsx3406 power 0.0225 0.5 -> 0.150 Inexact Rounded pwsx3407 power 0.226 0.5 -> 0.475 Inexact Rounded pwsx3408 power 0.0226 0.5 -> 0.150 Inexact Rounded pwsx3409 power 0.227 0.5 -> 0.476 Inexact Rounded pwsx3410 power 0.0227 0.5 -> 0.151 Inexact Rounded pwsx3411 power 0.228 0.5 -> 0.477 Inexact Rounded pwsx3412 power 0.0228 0.5 -> 0.151 Inexact Rounded pwsx3413 power 0.229 0.5 -> 0.479 Inexact Rounded pwsx3414 power 0.0229 0.5 -> 0.151 Inexact Rounded pwsx3415 power 0.231 0.5 -> 0.481 Inexact Rounded pwsx3416 power 0.0231 0.5 -> 0.152 Inexact Rounded pwsx3417 power 0.232 0.5 -> 0.482 Inexact Rounded pwsx3418 power 0.0232 0.5 -> 0.152 Inexact Rounded pwsx3419 power 0.233 0.5 -> 0.483 Inexact Rounded pwsx3420 power 0.0233 0.5 -> 0.153 Inexact Rounded pwsx3421 power 0.234 0.5 -> 0.484 Inexact Rounded pwsx3422 power 0.0234 0.5 -> 0.153 Inexact Rounded pwsx3423 power 0.235 0.5 -> 0.485 Inexact Rounded pwsx3424 power 0.0235 0.5 -> 0.153 Inexact Rounded pwsx3425 power 0.236 0.5 -> 0.486 Inexact Rounded pwsx3426 power 0.0236 0.5 -> 0.154 Inexact Rounded pwsx3427 power 0.237 0.5 -> 0.487 Inexact Rounded pwsx3428 power 0.0237 0.5 -> 0.154 Inexact Rounded pwsx3429 power 0.238 0.5 -> 0.488 Inexact Rounded pwsx3430 power 0.0238 0.5 -> 0.154 Inexact Rounded pwsx3431 power 0.239 0.5 -> 0.489 Inexact Rounded pwsx3432 power 0.0239 0.5 -> 0.155 Inexact Rounded pwsx3433 power 0.241 0.5 -> 0.491 Inexact Rounded pwsx3434 power 0.0241 0.5 -> 0.155 Inexact Rounded pwsx3435 power 0.242 0.5 -> 0.492 Inexact Rounded pwsx3436 power 0.0242 0.5 -> 0.156 Inexact Rounded pwsx3437 power 0.243 0.5 -> 0.493 Inexact Rounded pwsx3438 power 0.0243 0.5 -> 0.156 Inexact Rounded pwsx3439 power 0.244 0.5 -> 0.494 Inexact Rounded pwsx3440 power 0.0244 0.5 -> 0.156 Inexact Rounded pwsx3441 power 0.245 0.5 -> 0.495 Inexact Rounded pwsx3442 power 0.0245 0.5 -> 0.157 Inexact Rounded pwsx3443 power 0.246 0.5 -> 0.496 Inexact Rounded pwsx3444 power 0.0246 0.5 -> 0.157 Inexact Rounded pwsx3445 power 0.247 0.5 -> 0.497 Inexact Rounded pwsx3446 power 0.0247 0.5 -> 0.157 Inexact Rounded pwsx3447 power 0.248 0.5 -> 0.498 Inexact Rounded pwsx3448 power 0.0248 0.5 -> 0.157 Inexact Rounded pwsx3449 power 0.249 0.5 -> 0.499 Inexact Rounded pwsx3450 power 0.0249 0.5 -> 0.158 Inexact Rounded pwsx3451 power 0.251 0.5 -> 0.501 Inexact Rounded pwsx3452 power 0.0251 0.5 -> 0.158 Inexact Rounded pwsx3453 power 0.252 0.5 -> 0.502 Inexact Rounded pwsx3454 power 0.0252 0.5 -> 0.159 Inexact Rounded pwsx3455 power 0.253 0.5 -> 0.503 Inexact Rounded pwsx3456 power 0.0253 0.5 -> 0.159 Inexact Rounded pwsx3457 power 0.254 0.5 -> 0.504 Inexact Rounded pwsx3458 power 0.0254 0.5 -> 0.159 Inexact Rounded pwsx3459 power 0.255 0.5 -> 0.505 Inexact Rounded pwsx3460 power 0.0255 0.5 -> 0.160 Inexact Rounded pwsx3461 power 0.256 0.5 -> 0.506 Inexact Rounded pwsx3462 power 0.0256 0.5 -> 0.160 Inexact Rounded pwsx3463 power 0.257 0.5 -> 0.507 Inexact Rounded pwsx3464 power 0.0257 0.5 -> 0.160 Inexact Rounded pwsx3465 power 0.258 0.5 -> 0.508 Inexact Rounded pwsx3466 power 0.0258 0.5 -> 0.161 Inexact Rounded pwsx3467 power 0.259 0.5 -> 0.509 Inexact Rounded pwsx3468 power 0.0259 0.5 -> 0.161 Inexact Rounded pwsx3469 power 0.261 0.5 -> 0.511 Inexact Rounded pwsx3470 power 0.0261 0.5 -> 0.162 Inexact Rounded pwsx3471 power 0.262 0.5 -> 0.512 Inexact Rounded pwsx3472 power 0.0262 0.5 -> 0.162 Inexact Rounded pwsx3473 power 0.263 0.5 -> 0.513 Inexact Rounded pwsx3474 power 0.0263 0.5 -> 0.162 Inexact Rounded pwsx3475 power 0.264 0.5 -> 0.514 Inexact Rounded pwsx3476 power 0.0264 0.5 -> 0.162 Inexact Rounded pwsx3477 power 0.265 0.5 -> 0.515 Inexact Rounded pwsx3478 power 0.0265 0.5 -> 0.163 Inexact Rounded pwsx3479 power 0.266 0.5 -> 0.516 Inexact Rounded pwsx3480 power 0.0266 0.5 -> 0.163 Inexact Rounded pwsx3481 power 0.267 0.5 -> 0.517 Inexact Rounded pwsx3482 power 0.0267 0.5 -> 0.163 Inexact Rounded pwsx3483 power 0.268 0.5 -> 0.518 Inexact Rounded pwsx3484 power 0.0268 0.5 -> 0.164 Inexact Rounded pwsx3485 power 0.269 0.5 -> 0.519 Inexact Rounded pwsx3486 power 0.0269 0.5 -> 0.164 Inexact Rounded pwsx3487 power 0.271 0.5 -> 0.521 Inexact Rounded pwsx3488 power 0.0271 0.5 -> 0.165 Inexact Rounded pwsx3489 power 0.272 0.5 -> 0.522 Inexact Rounded pwsx3490 power 0.0272 0.5 -> 0.165 Inexact Rounded pwsx3491 power 0.273 0.5 -> 0.522 Inexact Rounded pwsx3492 power 0.0273 0.5 -> 0.165 Inexact Rounded pwsx3493 power 0.274 0.5 -> 0.523 Inexact Rounded pwsx3494 power 0.0274 0.5 -> 0.166 Inexact Rounded pwsx3495 power 0.275 0.5 -> 0.524 Inexact Rounded pwsx3496 power 0.0275 0.5 -> 0.166 Inexact Rounded pwsx3497 power 0.276 0.5 -> 0.525 Inexact Rounded pwsx3498 power 0.0276 0.5 -> 0.166 Inexact Rounded pwsx3499 power 0.277 0.5 -> 0.526 Inexact Rounded pwsx3500 power 0.0277 0.5 -> 0.166 Inexact Rounded pwsx3501 power 0.278 0.5 -> 0.527 Inexact Rounded pwsx3502 power 0.0278 0.5 -> 0.167 Inexact Rounded pwsx3503 power 0.279 0.5 -> 0.528 Inexact Rounded pwsx3504 power 0.0279 0.5 -> 0.167 Inexact Rounded pwsx3505 power 0.281 0.5 -> 0.530 Inexact Rounded pwsx3506 power 0.0281 0.5 -> 0.168 Inexact Rounded pwsx3507 power 0.282 0.5 -> 0.531 Inexact Rounded pwsx3508 power 0.0282 0.5 -> 0.168 Inexact Rounded pwsx3509 power 0.283 0.5 -> 0.532 Inexact Rounded pwsx3510 power 0.0283 0.5 -> 0.168 Inexact Rounded pwsx3511 power 0.284 0.5 -> 0.533 Inexact Rounded pwsx3512 power 0.0284 0.5 -> 0.169 Inexact Rounded pwsx3513 power 0.285 0.5 -> 0.534 Inexact Rounded pwsx3514 power 0.0285 0.5 -> 0.169 Inexact Rounded pwsx3515 power 0.286 0.5 -> 0.535 Inexact Rounded pwsx3516 power 0.0286 0.5 -> 0.169 Inexact Rounded pwsx3517 power 0.287 0.5 -> 0.536 Inexact Rounded pwsx3518 power 0.0287 0.5 -> 0.169 Inexact Rounded pwsx3519 power 0.288 0.5 -> 0.537 Inexact Rounded pwsx3520 power 0.0288 0.5 -> 0.170 Inexact Rounded pwsx3521 power 0.289 0.5 -> 0.538 Inexact Rounded pwsx3522 power 0.0289 0.5 -> 0.170 Inexact Rounded pwsx3523 power 0.291 0.5 -> 0.539 Inexact Rounded pwsx3524 power 0.0291 0.5 -> 0.171 Inexact Rounded pwsx3525 power 0.292 0.5 -> 0.540 Inexact Rounded pwsx3526 power 0.0292 0.5 -> 0.171 Inexact Rounded pwsx3527 power 0.293 0.5 -> 0.541 Inexact Rounded pwsx3528 power 0.0293 0.5 -> 0.171 Inexact Rounded pwsx3529 power 0.294 0.5 -> 0.542 Inexact Rounded pwsx3530 power 0.0294 0.5 -> 0.171 Inexact Rounded pwsx3531 power 0.295 0.5 -> 0.543 Inexact Rounded pwsx3532 power 0.0295 0.5 -> 0.172 Inexact Rounded pwsx3533 power 0.296 0.5 -> 0.544 Inexact Rounded pwsx3534 power 0.0296 0.5 -> 0.172 Inexact Rounded pwsx3535 power 0.297 0.5 -> 0.545 Inexact Rounded pwsx3536 power 0.0297 0.5 -> 0.172 Inexact Rounded pwsx3537 power 0.298 0.5 -> 0.546 Inexact Rounded pwsx3538 power 0.0298 0.5 -> 0.173 Inexact Rounded pwsx3539 power 0.299 0.5 -> 0.547 Inexact Rounded pwsx3540 power 0.0299 0.5 -> 0.173 Inexact Rounded pwsx3541 power 0.301 0.5 -> 0.549 Inexact Rounded pwsx3542 power 0.0301 0.5 -> 0.173 Inexact Rounded pwsx3543 power 0.302 0.5 -> 0.550 Inexact Rounded pwsx3544 power 0.0302 0.5 -> 0.174 Inexact Rounded pwsx3545 power 0.303 0.5 -> 0.550 Inexact Rounded pwsx3546 power 0.0303 0.5 -> 0.174 Inexact Rounded pwsx3547 power 0.304 0.5 -> 0.551 Inexact Rounded pwsx3548 power 0.0304 0.5 -> 0.174 Inexact Rounded pwsx3549 power 0.305 0.5 -> 0.552 Inexact Rounded pwsx3550 power 0.0305 0.5 -> 0.175 Inexact Rounded pwsx3551 power 0.306 0.5 -> 0.553 Inexact Rounded pwsx3552 power 0.0306 0.5 -> 0.175 Inexact Rounded pwsx3553 power 0.307 0.5 -> 0.554 Inexact Rounded pwsx3554 power 0.0307 0.5 -> 0.175 Inexact Rounded pwsx3555 power 0.308 0.5 -> 0.555 Inexact Rounded pwsx3556 power 0.0308 0.5 -> 0.175 Inexact Rounded pwsx3557 power 0.309 0.5 -> 0.556 Inexact Rounded pwsx3558 power 0.0309 0.5 -> 0.176 Inexact Rounded pwsx3559 power 0.311 0.5 -> 0.558 Inexact Rounded pwsx3560 power 0.0311 0.5 -> 0.176 Inexact Rounded pwsx3561 power 0.312 0.5 -> 0.559 Inexact Rounded pwsx3562 power 0.0312 0.5 -> 0.177 Inexact Rounded pwsx3563 power 0.313 0.5 -> 0.559 Inexact Rounded pwsx3564 power 0.0313 0.5 -> 0.177 Inexact Rounded pwsx3565 power 0.314 0.5 -> 0.560 Inexact Rounded pwsx3566 power 0.0314 0.5 -> 0.177 Inexact Rounded pwsx3567 power 0.315 0.5 -> 0.561 Inexact Rounded pwsx3568 power 0.0315 0.5 -> 0.177 Inexact Rounded pwsx3569 power 0.316 0.5 -> 0.562 Inexact Rounded pwsx3570 power 0.0316 0.5 -> 0.178 Inexact Rounded pwsx3571 power 0.317 0.5 -> 0.563 Inexact Rounded pwsx3572 power 0.0317 0.5 -> 0.178 Inexact Rounded pwsx3573 power 0.318 0.5 -> 0.564 Inexact Rounded pwsx3574 power 0.0318 0.5 -> 0.178 Inexact Rounded pwsx3575 power 0.319 0.5 -> 0.565 Inexact Rounded pwsx3576 power 0.0319 0.5 -> 0.179 Inexact Rounded pwsx3577 power 0.321 0.5 -> 0.567 Inexact Rounded pwsx3578 power 0.0321 0.5 -> 0.179 Inexact Rounded pwsx3579 power 0.322 0.5 -> 0.567 Inexact Rounded pwsx3580 power 0.0322 0.5 -> 0.179 Inexact Rounded pwsx3581 power 0.323 0.5 -> 0.568 Inexact Rounded pwsx3582 power 0.0323 0.5 -> 0.180 Inexact Rounded pwsx3583 power 0.324 0.5 -> 0.569 Inexact Rounded pwsx3584 power 0.0324 0.5 -> 0.180 Inexact Rounded pwsx3585 power 0.325 0.5 -> 0.570 Inexact Rounded pwsx3586 power 0.0325 0.5 -> 0.180 Inexact Rounded pwsx3587 power 0.326 0.5 -> 0.571 Inexact Rounded pwsx3588 power 0.0326 0.5 -> 0.181 Inexact Rounded pwsx3589 power 0.327 0.5 -> 0.572 Inexact Rounded pwsx3590 power 0.0327 0.5 -> 0.181 Inexact Rounded pwsx3591 power 0.328 0.5 -> 0.573 Inexact Rounded pwsx3592 power 0.0328 0.5 -> 0.181 Inexact Rounded pwsx3593 power 0.329 0.5 -> 0.574 Inexact Rounded pwsx3594 power 0.0329 0.5 -> 0.181 Inexact Rounded pwsx3595 power 0.331 0.5 -> 0.575 Inexact Rounded pwsx3596 power 0.0331 0.5 -> 0.182 Inexact Rounded pwsx3597 power 0.332 0.5 -> 0.576 Inexact Rounded pwsx3598 power 0.0332 0.5 -> 0.182 Inexact Rounded pwsx3599 power 0.333 0.5 -> 0.577 Inexact Rounded pwsx3600 power 0.0333 0.5 -> 0.182 Inexact Rounded pwsx3601 power 0.334 0.5 -> 0.578 Inexact Rounded pwsx3602 power 0.0334 0.5 -> 0.183 Inexact Rounded pwsx3603 power 0.335 0.5 -> 0.579 Inexact Rounded pwsx3604 power 0.0335 0.5 -> 0.183 Inexact Rounded pwsx3605 power 0.336 0.5 -> 0.580 Inexact Rounded pwsx3606 power 0.0336 0.5 -> 0.183 Inexact Rounded pwsx3607 power 0.337 0.5 -> 0.581 Inexact Rounded pwsx3608 power 0.0337 0.5 -> 0.184 Inexact Rounded pwsx3609 power 0.338 0.5 -> 0.581 Inexact Rounded pwsx3610 power 0.0338 0.5 -> 0.184 Inexact Rounded pwsx3611 power 0.339 0.5 -> 0.582 Inexact Rounded pwsx3612 power 0.0339 0.5 -> 0.184 Inexact Rounded pwsx3613 power 0.341 0.5 -> 0.584 Inexact Rounded pwsx3614 power 0.0341 0.5 -> 0.185 Inexact Rounded pwsx3615 power 0.342 0.5 -> 0.585 Inexact Rounded pwsx3616 power 0.0342 0.5 -> 0.185 Inexact Rounded pwsx3617 power 0.343 0.5 -> 0.586 Inexact Rounded pwsx3618 power 0.0343 0.5 -> 0.185 Inexact Rounded pwsx3619 power 0.344 0.5 -> 0.587 Inexact Rounded pwsx3620 power 0.0344 0.5 -> 0.185 Inexact Rounded pwsx3621 power 0.345 0.5 -> 0.587 Inexact Rounded pwsx3622 power 0.0345 0.5 -> 0.186 Inexact Rounded pwsx3623 power 0.346 0.5 -> 0.588 Inexact Rounded pwsx3624 power 0.0346 0.5 -> 0.186 Inexact Rounded pwsx3625 power 0.347 0.5 -> 0.589 Inexact Rounded pwsx3626 power 0.0347 0.5 -> 0.186 Inexact Rounded pwsx3627 power 0.348 0.5 -> 0.590 Inexact Rounded pwsx3628 power 0.0348 0.5 -> 0.187 Inexact Rounded pwsx3629 power 0.349 0.5 -> 0.591 Inexact Rounded pwsx3630 power 0.0349 0.5 -> 0.187 Inexact Rounded pwsx3631 power 0.351 0.5 -> 0.592 Inexact Rounded pwsx3632 power 0.0351 0.5 -> 0.187 Inexact Rounded pwsx3633 power 0.352 0.5 -> 0.593 Inexact Rounded pwsx3634 power 0.0352 0.5 -> 0.188 Inexact Rounded pwsx3635 power 0.353 0.5 -> 0.594 Inexact Rounded pwsx3636 power 0.0353 0.5 -> 0.188 Inexact Rounded pwsx3637 power 0.354 0.5 -> 0.595 Inexact Rounded pwsx3638 power 0.0354 0.5 -> 0.188 Inexact Rounded pwsx3639 power 0.355 0.5 -> 0.596 Inexact Rounded pwsx3640 power 0.0355 0.5 -> 0.188 Inexact Rounded pwsx3641 power 0.356 0.5 -> 0.597 Inexact Rounded pwsx3642 power 0.0356 0.5 -> 0.189 Inexact Rounded pwsx3643 power 0.357 0.5 -> 0.597 Inexact Rounded pwsx3644 power 0.0357 0.5 -> 0.189 Inexact Rounded pwsx3645 power 0.358 0.5 -> 0.598 Inexact Rounded pwsx3646 power 0.0358 0.5 -> 0.189 Inexact Rounded pwsx3647 power 0.359 0.5 -> 0.599 Inexact Rounded pwsx3648 power 0.0359 0.5 -> 0.189 Inexact Rounded pwsx3649 power 0.361 0.5 -> 0.601 Inexact Rounded pwsx3650 power 0.0361 0.5 -> 0.190 Inexact Rounded pwsx3651 power 0.362 0.5 -> 0.602 Inexact Rounded pwsx3652 power 0.0362 0.5 -> 0.190 Inexact Rounded pwsx3653 power 0.363 0.5 -> 0.602 Inexact Rounded pwsx3654 power 0.0363 0.5 -> 0.191 Inexact Rounded pwsx3655 power 0.364 0.5 -> 0.603 Inexact Rounded pwsx3656 power 0.0364 0.5 -> 0.191 Inexact Rounded pwsx3657 power 0.365 0.5 -> 0.604 Inexact Rounded pwsx3658 power 0.0365 0.5 -> 0.191 Inexact Rounded pwsx3659 power 0.366 0.5 -> 0.605 Inexact Rounded pwsx3660 power 0.0366 0.5 -> 0.191 Inexact Rounded pwsx3661 power 0.367 0.5 -> 0.606 Inexact Rounded pwsx3662 power 0.0367 0.5 -> 0.192 Inexact Rounded pwsx3663 power 0.368 0.5 -> 0.607 Inexact Rounded pwsx3664 power 0.0368 0.5 -> 0.192 Inexact Rounded pwsx3665 power 0.369 0.5 -> 0.607 Inexact Rounded pwsx3666 power 0.0369 0.5 -> 0.192 Inexact Rounded pwsx3667 power 0.371 0.5 -> 0.609 Inexact Rounded pwsx3668 power 0.0371 0.5 -> 0.193 Inexact Rounded pwsx3669 power 0.372 0.5 -> 0.610 Inexact Rounded pwsx3670 power 0.0372 0.5 -> 0.193 Inexact Rounded pwsx3671 power 0.373 0.5 -> 0.611 Inexact Rounded pwsx3672 power 0.0373 0.5 -> 0.193 Inexact Rounded pwsx3673 power 0.374 0.5 -> 0.612 Inexact Rounded pwsx3674 power 0.0374 0.5 -> 0.193 Inexact Rounded pwsx3675 power 0.375 0.5 -> 0.612 Inexact Rounded pwsx3676 power 0.0375 0.5 -> 0.194 Inexact Rounded pwsx3677 power 0.376 0.5 -> 0.613 Inexact Rounded pwsx3678 power 0.0376 0.5 -> 0.194 Inexact Rounded pwsx3679 power 0.377 0.5 -> 0.614 Inexact Rounded pwsx3680 power 0.0377 0.5 -> 0.194 Inexact Rounded pwsx3681 power 0.378 0.5 -> 0.615 Inexact Rounded pwsx3682 power 0.0378 0.5 -> 0.194 Inexact Rounded pwsx3683 power 0.379 0.5 -> 0.616 Inexact Rounded pwsx3684 power 0.0379 0.5 -> 0.195 Inexact Rounded pwsx3685 power 0.381 0.5 -> 0.617 Inexact Rounded pwsx3686 power 0.0381 0.5 -> 0.195 Inexact Rounded pwsx3687 power 0.382 0.5 -> 0.618 Inexact Rounded pwsx3688 power 0.0382 0.5 -> 0.195 Inexact Rounded pwsx3689 power 0.383 0.5 -> 0.619 Inexact Rounded pwsx3690 power 0.0383 0.5 -> 0.196 Inexact Rounded pwsx3691 power 0.384 0.5 -> 0.620 Inexact Rounded pwsx3692 power 0.0384 0.5 -> 0.196 Inexact Rounded pwsx3693 power 0.385 0.5 -> 0.620 Inexact Rounded pwsx3694 power 0.0385 0.5 -> 0.196 Inexact Rounded pwsx3695 power 0.386 0.5 -> 0.621 Inexact Rounded pwsx3696 power 0.0386 0.5 -> 0.196 Inexact Rounded pwsx3697 power 0.387 0.5 -> 0.622 Inexact Rounded pwsx3698 power 0.0387 0.5 -> 0.197 Inexact Rounded pwsx3699 power 0.388 0.5 -> 0.623 Inexact Rounded pwsx3700 power 0.0388 0.5 -> 0.197 Inexact Rounded pwsx3701 power 0.389 0.5 -> 0.624 Inexact Rounded pwsx3702 power 0.0389 0.5 -> 0.197 Inexact Rounded pwsx3703 power 0.391 0.5 -> 0.625 Inexact Rounded pwsx3704 power 0.0391 0.5 -> 0.198 Inexact Rounded pwsx3705 power 0.392 0.5 -> 0.626 Inexact Rounded pwsx3706 power 0.0392 0.5 -> 0.198 Inexact Rounded pwsx3707 power 0.393 0.5 -> 0.627 Inexact Rounded pwsx3708 power 0.0393 0.5 -> 0.198 Inexact Rounded pwsx3709 power 0.394 0.5 -> 0.628 Inexact Rounded pwsx3710 power 0.0394 0.5 -> 0.198 Inexact Rounded pwsx3711 power 0.395 0.5 -> 0.628 Inexact Rounded pwsx3712 power 0.0395 0.5 -> 0.199 Inexact Rounded pwsx3713 power 0.396 0.5 -> 0.629 Inexact Rounded pwsx3714 power 0.0396 0.5 -> 0.199 Inexact Rounded pwsx3715 power 0.397 0.5 -> 0.630 Inexact Rounded pwsx3716 power 0.0397 0.5 -> 0.199 Inexact Rounded pwsx3717 power 0.398 0.5 -> 0.631 Inexact Rounded pwsx3718 power 0.0398 0.5 -> 0.199 Inexact Rounded pwsx3719 power 0.399 0.5 -> 0.632 Inexact Rounded pwsx3720 power 0.0399 0.5 -> 0.200 Inexact Rounded pwsx3721 power 0.401 0.5 -> 0.633 Inexact Rounded pwsx3722 power 0.0401 0.5 -> 0.200 Inexact Rounded pwsx3723 power 0.402 0.5 -> 0.634 Inexact Rounded pwsx3724 power 0.0402 0.5 -> 0.200 Inexact Rounded pwsx3725 power 0.403 0.5 -> 0.635 Inexact Rounded pwsx3726 power 0.0403 0.5 -> 0.201 Inexact Rounded pwsx3727 power 0.404 0.5 -> 0.636 Inexact Rounded pwsx3728 power 0.0404 0.5 -> 0.201 Inexact Rounded pwsx3729 power 0.405 0.5 -> 0.636 Inexact Rounded pwsx3730 power 0.0405 0.5 -> 0.201 Inexact Rounded pwsx3731 power 0.406 0.5 -> 0.637 Inexact Rounded pwsx3732 power 0.0406 0.5 -> 0.201 Inexact Rounded pwsx3733 power 0.407 0.5 -> 0.638 Inexact Rounded pwsx3734 power 0.0407 0.5 -> 0.202 Inexact Rounded pwsx3735 power 0.408 0.5 -> 0.639 Inexact Rounded pwsx3736 power 0.0408 0.5 -> 0.202 Inexact Rounded pwsx3737 power 0.409 0.5 -> 0.640 Inexact Rounded pwsx3738 power 0.0409 0.5 -> 0.202 Inexact Rounded pwsx3739 power 0.411 0.5 -> 0.641 Inexact Rounded pwsx3740 power 0.0411 0.5 -> 0.203 Inexact Rounded pwsx3741 power 0.412 0.5 -> 0.642 Inexact Rounded pwsx3742 power 0.0412 0.5 -> 0.203 Inexact Rounded pwsx3743 power 0.413 0.5 -> 0.643 Inexact Rounded pwsx3744 power 0.0413 0.5 -> 0.203 Inexact Rounded pwsx3745 power 0.414 0.5 -> 0.643 Inexact Rounded pwsx3746 power 0.0414 0.5 -> 0.203 Inexact Rounded pwsx3747 power 0.415 0.5 -> 0.644 Inexact Rounded pwsx3748 power 0.0415 0.5 -> 0.204 Inexact Rounded pwsx3749 power 0.416 0.5 -> 0.645 Inexact Rounded pwsx3750 power 0.0416 0.5 -> 0.204 Inexact Rounded pwsx3751 power 0.417 0.5 -> 0.646 Inexact Rounded pwsx3752 power 0.0417 0.5 -> 0.204 Inexact Rounded pwsx3753 power 0.418 0.5 -> 0.647 Inexact Rounded pwsx3754 power 0.0418 0.5 -> 0.204 Inexact Rounded pwsx3755 power 0.419 0.5 -> 0.647 Inexact Rounded pwsx3756 power 0.0419 0.5 -> 0.205 Inexact Rounded pwsx3757 power 0.421 0.5 -> 0.649 Inexact Rounded pwsx3758 power 0.0421 0.5 -> 0.205 Inexact Rounded pwsx3759 power 0.422 0.5 -> 0.650 Inexact Rounded pwsx3760 power 0.0422 0.5 -> 0.205 Inexact Rounded pwsx3761 power 0.423 0.5 -> 0.650 Inexact Rounded pwsx3762 power 0.0423 0.5 -> 0.206 Inexact Rounded pwsx3763 power 0.424 0.5 -> 0.651 Inexact Rounded pwsx3764 power 0.0424 0.5 -> 0.206 Inexact Rounded pwsx3765 power 0.425 0.5 -> 0.652 Inexact Rounded pwsx3766 power 0.0425 0.5 -> 0.206 Inexact Rounded pwsx3767 power 0.426 0.5 -> 0.653 Inexact Rounded pwsx3768 power 0.0426 0.5 -> 0.206 Inexact Rounded pwsx3769 power 0.427 0.5 -> 0.653 Inexact Rounded pwsx3770 power 0.0427 0.5 -> 0.207 Inexact Rounded pwsx3771 power 0.428 0.5 -> 0.654 Inexact Rounded pwsx3772 power 0.0428 0.5 -> 0.207 Inexact Rounded pwsx3773 power 0.429 0.5 -> 0.655 Inexact Rounded pwsx3774 power 0.0429 0.5 -> 0.207 Inexact Rounded pwsx3775 power 0.431 0.5 -> 0.657 Inexact Rounded pwsx3776 power 0.0431 0.5 -> 0.208 Inexact Rounded pwsx3777 power 0.432 0.5 -> 0.657 Inexact Rounded pwsx3778 power 0.0432 0.5 -> 0.208 Inexact Rounded pwsx3779 power 0.433 0.5 -> 0.658 Inexact Rounded pwsx3780 power 0.0433 0.5 -> 0.208 Inexact Rounded pwsx3781 power 0.434 0.5 -> 0.659 Inexact Rounded pwsx3782 power 0.0434 0.5 -> 0.208 Inexact Rounded pwsx3783 power 0.435 0.5 -> 0.660 Inexact Rounded pwsx3784 power 0.0435 0.5 -> 0.209 Inexact Rounded pwsx3785 power 0.436 0.5 -> 0.660 Inexact Rounded pwsx3786 power 0.0436 0.5 -> 0.209 Inexact Rounded pwsx3787 power 0.437 0.5 -> 0.661 Inexact Rounded pwsx3788 power 0.0437 0.5 -> 0.209 Inexact Rounded pwsx3789 power 0.438 0.5 -> 0.662 Inexact Rounded pwsx3790 power 0.0438 0.5 -> 0.209 Inexact Rounded pwsx3791 power 0.439 0.5 -> 0.663 Inexact Rounded pwsx3792 power 0.0439 0.5 -> 0.210 Inexact Rounded pwsx3793 power 0.441 0.5 -> 0.664 Inexact Rounded pwsx3794 power 0.0441 0.5 -> 0.210 Inexact Rounded pwsx3795 power 0.442 0.5 -> 0.665 Inexact Rounded pwsx3796 power 0.0442 0.5 -> 0.210 Inexact Rounded pwsx3797 power 0.443 0.5 -> 0.666 Inexact Rounded pwsx3798 power 0.0443 0.5 -> 0.210 Inexact Rounded pwsx3799 power 0.444 0.5 -> 0.666 Inexact Rounded pwsx3800 power 0.0444 0.5 -> 0.211 Inexact Rounded pwsx3801 power 0.445 0.5 -> 0.667 Inexact Rounded pwsx3802 power 0.0445 0.5 -> 0.211 Inexact Rounded pwsx3803 power 0.446 0.5 -> 0.668 Inexact Rounded pwsx3804 power 0.0446 0.5 -> 0.211 Inexact Rounded pwsx3805 power 0.447 0.5 -> 0.669 Inexact Rounded pwsx3806 power 0.0447 0.5 -> 0.211 Inexact Rounded pwsx3807 power 0.448 0.5 -> 0.669 Inexact Rounded pwsx3808 power 0.0448 0.5 -> 0.212 Inexact Rounded pwsx3809 power 0.449 0.5 -> 0.670 Inexact Rounded pwsx3810 power 0.0449 0.5 -> 0.212 Inexact Rounded pwsx3811 power 0.451 0.5 -> 0.672 Inexact Rounded pwsx3812 power 0.0451 0.5 -> 0.212 Inexact Rounded pwsx3813 power 0.452 0.5 -> 0.672 Inexact Rounded pwsx3814 power 0.0452 0.5 -> 0.213 Inexact Rounded pwsx3815 power 0.453 0.5 -> 0.673 Inexact Rounded pwsx3816 power 0.0453 0.5 -> 0.213 Inexact Rounded pwsx3817 power 0.454 0.5 -> 0.674 Inexact Rounded pwsx3818 power 0.0454 0.5 -> 0.213 Inexact Rounded pwsx3819 power 0.455 0.5 -> 0.675 Inexact Rounded pwsx3820 power 0.0455 0.5 -> 0.213 Inexact Rounded pwsx3821 power 0.456 0.5 -> 0.675 Inexact Rounded pwsx3822 power 0.0456 0.5 -> 0.214 Inexact Rounded pwsx3823 power 0.457 0.5 -> 0.676 Inexact Rounded pwsx3824 power 0.0457 0.5 -> 0.214 Inexact Rounded pwsx3825 power 0.458 0.5 -> 0.677 Inexact Rounded pwsx3826 power 0.0458 0.5 -> 0.214 Inexact Rounded pwsx3827 power 0.459 0.5 -> 0.677 Inexact Rounded pwsx3828 power 0.0459 0.5 -> 0.214 Inexact Rounded pwsx3829 power 0.461 0.5 -> 0.679 Inexact Rounded pwsx3830 power 0.0461 0.5 -> 0.215 Inexact Rounded pwsx3831 power 0.462 0.5 -> 0.680 Inexact Rounded pwsx3832 power 0.0462 0.5 -> 0.215 Inexact Rounded pwsx3833 power 0.463 0.5 -> 0.680 Inexact Rounded pwsx3834 power 0.0463 0.5 -> 0.215 Inexact Rounded pwsx3835 power 0.464 0.5 -> 0.681 Inexact Rounded pwsx3836 power 0.0464 0.5 -> 0.215 Inexact Rounded pwsx3837 power 0.465 0.5 -> 0.682 Inexact Rounded pwsx3838 power 0.0465 0.5 -> 0.216 Inexact Rounded pwsx3839 power 0.466 0.5 -> 0.683 Inexact Rounded pwsx3840 power 0.0466 0.5 -> 0.216 Inexact Rounded pwsx3841 power 0.467 0.5 -> 0.683 Inexact Rounded pwsx3842 power 0.0467 0.5 -> 0.216 Inexact Rounded pwsx3843 power 0.468 0.5 -> 0.684 Inexact Rounded pwsx3844 power 0.0468 0.5 -> 0.216 Inexact Rounded pwsx3845 power 0.469 0.5 -> 0.685 Inexact Rounded pwsx3846 power 0.0469 0.5 -> 0.217 Inexact Rounded pwsx3847 power 0.471 0.5 -> 0.686 Inexact Rounded pwsx3848 power 0.0471 0.5 -> 0.217 Inexact Rounded pwsx3849 power 0.472 0.5 -> 0.687 Inexact Rounded pwsx3850 power 0.0472 0.5 -> 0.217 Inexact Rounded pwsx3851 power 0.473 0.5 -> 0.688 Inexact Rounded pwsx3852 power 0.0473 0.5 -> 0.217 Inexact Rounded pwsx3853 power 0.474 0.5 -> 0.688 Inexact Rounded pwsx3854 power 0.0474 0.5 -> 0.218 Inexact Rounded pwsx3855 power 0.475 0.5 -> 0.689 Inexact Rounded pwsx3856 power 0.0475 0.5 -> 0.218 Inexact Rounded pwsx3857 power 0.476 0.5 -> 0.690 Inexact Rounded pwsx3858 power 0.0476 0.5 -> 0.218 Inexact Rounded pwsx3859 power 0.477 0.5 -> 0.691 Inexact Rounded pwsx3860 power 0.0477 0.5 -> 0.218 Inexact Rounded pwsx3861 power 0.478 0.5 -> 0.691 Inexact Rounded pwsx3862 power 0.0478 0.5 -> 0.219 Inexact Rounded pwsx3863 power 0.479 0.5 -> 0.692 Inexact Rounded pwsx3864 power 0.0479 0.5 -> 0.219 Inexact Rounded pwsx3865 power 0.481 0.5 -> 0.694 Inexact Rounded pwsx3866 power 0.0481 0.5 -> 0.219 Inexact Rounded pwsx3867 power 0.482 0.5 -> 0.694 Inexact Rounded pwsx3868 power 0.0482 0.5 -> 0.220 Inexact Rounded pwsx3869 power 0.483 0.5 -> 0.695 Inexact Rounded pwsx3870 power 0.0483 0.5 -> 0.220 Inexact Rounded pwsx3871 power 0.484 0.5 -> 0.696 Inexact Rounded pwsx3872 power 0.0484 0.5 -> 0.220 Inexact Rounded pwsx3873 power 0.485 0.5 -> 0.696 Inexact Rounded pwsx3874 power 0.0485 0.5 -> 0.220 Inexact Rounded pwsx3875 power 0.486 0.5 -> 0.697 Inexact Rounded pwsx3876 power 0.0486 0.5 -> 0.220 Inexact Rounded pwsx3877 power 0.487 0.5 -> 0.698 Inexact Rounded pwsx3878 power 0.0487 0.5 -> 0.221 Inexact Rounded pwsx3879 power 0.488 0.5 -> 0.699 Inexact Rounded pwsx3880 power 0.0488 0.5 -> 0.221 Inexact Rounded pwsx3881 power 0.489 0.5 -> 0.699 Inexact Rounded pwsx3882 power 0.0489 0.5 -> 0.221 Inexact Rounded pwsx3883 power 0.491 0.5 -> 0.701 Inexact Rounded pwsx3884 power 0.0491 0.5 -> 0.222 Inexact Rounded pwsx3885 power 0.492 0.5 -> 0.701 Inexact Rounded pwsx3886 power 0.0492 0.5 -> 0.222 Inexact Rounded pwsx3887 power 0.493 0.5 -> 0.702 Inexact Rounded pwsx3888 power 0.0493 0.5 -> 0.222 Inexact Rounded pwsx3889 power 0.494 0.5 -> 0.703 Inexact Rounded pwsx3890 power 0.0494 0.5 -> 0.222 Inexact Rounded pwsx3891 power 0.495 0.5 -> 0.704 Inexact Rounded pwsx3892 power 0.0495 0.5 -> 0.222 Inexact Rounded pwsx3893 power 0.496 0.5 -> 0.704 Inexact Rounded pwsx3894 power 0.0496 0.5 -> 0.223 Inexact Rounded pwsx3895 power 0.497 0.5 -> 0.705 Inexact Rounded pwsx3896 power 0.0497 0.5 -> 0.223 Inexact Rounded pwsx3897 power 0.498 0.5 -> 0.706 Inexact Rounded pwsx3898 power 0.0498 0.5 -> 0.223 Inexact Rounded pwsx3899 power 0.499 0.5 -> 0.706 Inexact Rounded pwsx3900 power 0.0499 0.5 -> 0.223 Inexact Rounded pwsx3901 power 0.501 0.5 -> 0.708 Inexact Rounded pwsx3902 power 0.0501 0.5 -> 0.224 Inexact Rounded pwsx3903 power 0.502 0.5 -> 0.709 Inexact Rounded pwsx3904 power 0.0502 0.5 -> 0.224 Inexact Rounded pwsx3905 power 0.503 0.5 -> 0.709 Inexact Rounded pwsx3906 power 0.0503 0.5 -> 0.224 Inexact Rounded pwsx3907 power 0.504 0.5 -> 0.710 Inexact Rounded pwsx3908 power 0.0504 0.5 -> 0.224 Inexact Rounded pwsx3909 power 0.505 0.5 -> 0.711 Inexact Rounded pwsx3910 power 0.0505 0.5 -> 0.225 Inexact Rounded pwsx3911 power 0.506 0.5 -> 0.711 Inexact Rounded pwsx3912 power 0.0506 0.5 -> 0.225 Inexact Rounded pwsx3913 power 0.507 0.5 -> 0.712 Inexact Rounded pwsx3914 power 0.0507 0.5 -> 0.225 Inexact Rounded pwsx3915 power 0.508 0.5 -> 0.713 Inexact Rounded pwsx3916 power 0.0508 0.5 -> 0.225 Inexact Rounded pwsx3917 power 0.509 0.5 -> 0.713 Inexact Rounded pwsx3918 power 0.0509 0.5 -> 0.226 Inexact Rounded pwsx3919 power 0.511 0.5 -> 0.715 Inexact Rounded pwsx3920 power 0.0511 0.5 -> 0.226 Inexact Rounded pwsx3921 power 0.512 0.5 -> 0.716 Inexact Rounded pwsx3922 power 0.0512 0.5 -> 0.226 Inexact Rounded pwsx3923 power 0.513 0.5 -> 0.716 Inexact Rounded pwsx3924 power 0.0513 0.5 -> 0.226 Inexact Rounded pwsx3925 power 0.514 0.5 -> 0.717 Inexact Rounded pwsx3926 power 0.0514 0.5 -> 0.227 Inexact Rounded pwsx3927 power 0.515 0.5 -> 0.718 Inexact Rounded pwsx3928 power 0.0515 0.5 -> 0.227 Inexact Rounded pwsx3929 power 0.516 0.5 -> 0.718 Inexact Rounded pwsx3930 power 0.0516 0.5 -> 0.227 Inexact Rounded pwsx3931 power 0.517 0.5 -> 0.719 Inexact Rounded pwsx3932 power 0.0517 0.5 -> 0.227 Inexact Rounded pwsx3933 power 0.518 0.5 -> 0.720 Inexact Rounded pwsx3934 power 0.0518 0.5 -> 0.228 Inexact Rounded pwsx3935 power 0.519 0.5 -> 0.720 Inexact Rounded pwsx3936 power 0.0519 0.5 -> 0.228 Inexact Rounded pwsx3937 power 0.521 0.5 -> 0.722 Inexact Rounded pwsx3938 power 0.0521 0.5 -> 0.228 Inexact Rounded pwsx3939 power 0.522 0.5 -> 0.722 Inexact Rounded pwsx3940 power 0.0522 0.5 -> 0.228 Inexact Rounded pwsx3941 power 0.523 0.5 -> 0.723 Inexact Rounded pwsx3942 power 0.0523 0.5 -> 0.229 Inexact Rounded pwsx3943 power 0.524 0.5 -> 0.724 Inexact Rounded pwsx3944 power 0.0524 0.5 -> 0.229 Inexact Rounded pwsx3945 power 0.525 0.5 -> 0.725 Inexact Rounded pwsx3946 power 0.0525 0.5 -> 0.229 Inexact Rounded pwsx3947 power 0.526 0.5 -> 0.725 Inexact Rounded pwsx3948 power 0.0526 0.5 -> 0.229 Inexact Rounded pwsx3949 power 0.527 0.5 -> 0.726 Inexact Rounded pwsx3950 power 0.0527 0.5 -> 0.230 Inexact Rounded pwsx3951 power 0.528 0.5 -> 0.727 Inexact Rounded pwsx3952 power 0.0528 0.5 -> 0.230 Inexact Rounded pwsx3953 power 0.529 0.5 -> 0.727 Inexact Rounded pwsx3954 power 0.0529 0.5 -> 0.230 Inexact Rounded pwsx3955 power 0.531 0.5 -> 0.729 Inexact Rounded pwsx3956 power 0.0531 0.5 -> 0.230 Inexact Rounded pwsx3957 power 0.532 0.5 -> 0.729 Inexact Rounded pwsx3958 power 0.0532 0.5 -> 0.231 Inexact Rounded pwsx3959 power 0.533 0.5 -> 0.730 Inexact Rounded pwsx3960 power 0.0533 0.5 -> 0.231 Inexact Rounded pwsx3961 power 0.534 0.5 -> 0.731 Inexact Rounded pwsx3962 power 0.0534 0.5 -> 0.231 Inexact Rounded pwsx3963 power 0.535 0.5 -> 0.731 Inexact Rounded pwsx3964 power 0.0535 0.5 -> 0.231 Inexact Rounded pwsx3965 power 0.536 0.5 -> 0.732 Inexact Rounded pwsx3966 power 0.0536 0.5 -> 0.232 Inexact Rounded pwsx3967 power 0.537 0.5 -> 0.733 Inexact Rounded pwsx3968 power 0.0537 0.5 -> 0.232 Inexact Rounded pwsx3969 power 0.538 0.5 -> 0.733 Inexact Rounded pwsx3970 power 0.0538 0.5 -> 0.232 Inexact Rounded pwsx3971 power 0.539 0.5 -> 0.734 Inexact Rounded pwsx3972 power 0.0539 0.5 -> 0.232 Inexact Rounded pwsx3973 power 0.541 0.5 -> 0.736 Inexact Rounded pwsx3974 power 0.0541 0.5 -> 0.233 Inexact Rounded pwsx3975 power 0.542 0.5 -> 0.736 Inexact Rounded pwsx3976 power 0.0542 0.5 -> 0.233 Inexact Rounded pwsx3977 power 0.543 0.5 -> 0.737 Inexact Rounded pwsx3978 power 0.0543 0.5 -> 0.233 Inexact Rounded pwsx3979 power 0.544 0.5 -> 0.738 Inexact Rounded pwsx3980 power 0.0544 0.5 -> 0.233 Inexact Rounded pwsx3981 power 0.545 0.5 -> 0.738 Inexact Rounded pwsx3982 power 0.0545 0.5 -> 0.233 Inexact Rounded pwsx3983 power 0.546 0.5 -> 0.739 Inexact Rounded pwsx3984 power 0.0546 0.5 -> 0.234 Inexact Rounded pwsx3985 power 0.547 0.5 -> 0.740 Inexact Rounded pwsx3986 power 0.0547 0.5 -> 0.234 Inexact Rounded pwsx3987 power 0.548 0.5 -> 0.740 Inexact Rounded pwsx3988 power 0.0548 0.5 -> 0.234 Inexact Rounded pwsx3989 power 0.549 0.5 -> 0.741 Inexact Rounded pwsx3990 power 0.0549 0.5 -> 0.234 Inexact Rounded pwsx3991 power 0.551 0.5 -> 0.742 Inexact Rounded pwsx3992 power 0.0551 0.5 -> 0.235 Inexact Rounded pwsx3993 power 0.552 0.5 -> 0.743 Inexact Rounded pwsx3994 power 0.0552 0.5 -> 0.235 Inexact Rounded pwsx3995 power 0.553 0.5 -> 0.744 Inexact Rounded pwsx3996 power 0.0553 0.5 -> 0.235 Inexact Rounded pwsx3997 power 0.554 0.5 -> 0.744 Inexact Rounded pwsx3998 power 0.0554 0.5 -> 0.235 Inexact Rounded pwsx3999 power 0.555 0.5 -> 0.745 Inexact Rounded pwsx4000 power 0.0555 0.5 -> 0.236 Inexact Rounded pwsx4001 power 0.556 0.5 -> 0.746 Inexact Rounded pwsx4002 power 0.0556 0.5 -> 0.236 Inexact Rounded pwsx4003 power 0.557 0.5 -> 0.746 Inexact Rounded pwsx4004 power 0.0557 0.5 -> 0.236 Inexact Rounded pwsx4005 power 0.558 0.5 -> 0.747 Inexact Rounded pwsx4006 power 0.0558 0.5 -> 0.236 Inexact Rounded pwsx4007 power 0.559 0.5 -> 0.748 Inexact Rounded pwsx4008 power 0.0559 0.5 -> 0.236 Inexact Rounded pwsx4009 power 0.561 0.5 -> 0.749 Inexact Rounded pwsx4010 power 0.0561 0.5 -> 0.237 Inexact Rounded pwsx4011 power 0.562 0.5 -> 0.750 Inexact Rounded pwsx4012 power 0.0562 0.5 -> 0.237 Inexact Rounded pwsx4013 power 0.563 0.5 -> 0.750 Inexact Rounded pwsx4014 power 0.0563 0.5 -> 0.237 Inexact Rounded pwsx4015 power 0.564 0.5 -> 0.751 Inexact Rounded pwsx4016 power 0.0564 0.5 -> 0.237 Inexact Rounded pwsx4017 power 0.565 0.5 -> 0.752 Inexact Rounded pwsx4018 power 0.0565 0.5 -> 0.238 Inexact Rounded pwsx4019 power 0.566 0.5 -> 0.752 Inexact Rounded pwsx4020 power 0.0566 0.5 -> 0.238 Inexact Rounded pwsx4021 power 0.567 0.5 -> 0.753 Inexact Rounded pwsx4022 power 0.0567 0.5 -> 0.238 Inexact Rounded pwsx4023 power 0.568 0.5 -> 0.754 Inexact Rounded pwsx4024 power 0.0568 0.5 -> 0.238 Inexact Rounded pwsx4025 power 0.569 0.5 -> 0.754 Inexact Rounded pwsx4026 power 0.0569 0.5 -> 0.239 Inexact Rounded pwsx4027 power 0.571 0.5 -> 0.756 Inexact Rounded pwsx4028 power 0.0571 0.5 -> 0.239 Inexact Rounded pwsx4029 power 0.572 0.5 -> 0.756 Inexact Rounded pwsx4030 power 0.0572 0.5 -> 0.239 Inexact Rounded pwsx4031 power 0.573 0.5 -> 0.757 Inexact Rounded pwsx4032 power 0.0573 0.5 -> 0.239 Inexact Rounded pwsx4033 power 0.574 0.5 -> 0.758 Inexact Rounded pwsx4034 power 0.0574 0.5 -> 0.240 Inexact Rounded pwsx4035 power 0.575 0.5 -> 0.758 Inexact Rounded pwsx4036 power 0.0575 0.5 -> 0.240 Inexact Rounded pwsx4037 power 0.576 0.5 -> 0.759 Inexact Rounded pwsx4038 power 0.0576 0.5 -> 0.240 Inexact Rounded pwsx4039 power 0.577 0.5 -> 0.760 Inexact Rounded pwsx4040 power 0.0577 0.5 -> 0.240 Inexact Rounded pwsx4041 power 0.578 0.5 -> 0.760 Inexact Rounded pwsx4042 power 0.0578 0.5 -> 0.240 Inexact Rounded pwsx4043 power 0.579 0.5 -> 0.761 Inexact Rounded pwsx4044 power 0.0579 0.5 -> 0.241 Inexact Rounded pwsx4045 power 0.581 0.5 -> 0.762 Inexact Rounded pwsx4046 power 0.0581 0.5 -> 0.241 Inexact Rounded pwsx4047 power 0.582 0.5 -> 0.763 Inexact Rounded pwsx4048 power 0.0582 0.5 -> 0.241 Inexact Rounded pwsx4049 power 0.583 0.5 -> 0.764 Inexact Rounded pwsx4050 power 0.0583 0.5 -> 0.241 Inexact Rounded pwsx4051 power 0.584 0.5 -> 0.764 Inexact Rounded pwsx4052 power 0.0584 0.5 -> 0.242 Inexact Rounded pwsx4053 power 0.585 0.5 -> 0.765 Inexact Rounded pwsx4054 power 0.0585 0.5 -> 0.242 Inexact Rounded pwsx4055 power 0.586 0.5 -> 0.766 Inexact Rounded pwsx4056 power 0.0586 0.5 -> 0.242 Inexact Rounded pwsx4057 power 0.587 0.5 -> 0.766 Inexact Rounded pwsx4058 power 0.0587 0.5 -> 0.242 Inexact Rounded pwsx4059 power 0.588 0.5 -> 0.767 Inexact Rounded pwsx4060 power 0.0588 0.5 -> 0.242 Inexact Rounded pwsx4061 power 0.589 0.5 -> 0.767 Inexact Rounded pwsx4062 power 0.0589 0.5 -> 0.243 Inexact Rounded pwsx4063 power 0.591 0.5 -> 0.769 Inexact Rounded pwsx4064 power 0.0591 0.5 -> 0.243 Inexact Rounded pwsx4065 power 0.592 0.5 -> 0.769 Inexact Rounded pwsx4066 power 0.0592 0.5 -> 0.243 Inexact Rounded pwsx4067 power 0.593 0.5 -> 0.770 Inexact Rounded pwsx4068 power 0.0593 0.5 -> 0.244 Inexact Rounded pwsx4069 power 0.594 0.5 -> 0.771 Inexact Rounded pwsx4070 power 0.0594 0.5 -> 0.244 Inexact Rounded pwsx4071 power 0.595 0.5 -> 0.771 Inexact Rounded pwsx4072 power 0.0595 0.5 -> 0.244 Inexact Rounded pwsx4073 power 0.596 0.5 -> 0.772 Inexact Rounded pwsx4074 power 0.0596 0.5 -> 0.244 Inexact Rounded pwsx4075 power 0.597 0.5 -> 0.773 Inexact Rounded pwsx4076 power 0.0597 0.5 -> 0.244 Inexact Rounded pwsx4077 power 0.598 0.5 -> 0.773 Inexact Rounded pwsx4078 power 0.0598 0.5 -> 0.245 Inexact Rounded pwsx4079 power 0.599 0.5 -> 0.774 Inexact Rounded pwsx4080 power 0.0599 0.5 -> 0.245 Inexact Rounded pwsx4081 power 0.601 0.5 -> 0.775 Inexact Rounded pwsx4082 power 0.0601 0.5 -> 0.245 Inexact Rounded pwsx4083 power 0.602 0.5 -> 0.776 Inexact Rounded pwsx4084 power 0.0602 0.5 -> 0.245 Inexact Rounded pwsx4085 power 0.603 0.5 -> 0.777 Inexact Rounded pwsx4086 power 0.0603 0.5 -> 0.246 Inexact Rounded pwsx4087 power 0.604 0.5 -> 0.777 Inexact Rounded pwsx4088 power 0.0604 0.5 -> 0.246 Inexact Rounded pwsx4089 power 0.605 0.5 -> 0.778 Inexact Rounded pwsx4090 power 0.0605 0.5 -> 0.246 Inexact Rounded pwsx4091 power 0.606 0.5 -> 0.778 Inexact Rounded pwsx4092 power 0.0606 0.5 -> 0.246 Inexact Rounded pwsx4093 power 0.607 0.5 -> 0.779 Inexact Rounded pwsx4094 power 0.0607 0.5 -> 0.246 Inexact Rounded pwsx4095 power 0.608 0.5 -> 0.780 Inexact Rounded pwsx4096 power 0.0608 0.5 -> 0.247 Inexact Rounded pwsx4097 power 0.609 0.5 -> 0.780 Inexact Rounded pwsx4098 power 0.0609 0.5 -> 0.247 Inexact Rounded pwsx4099 power 0.611 0.5 -> 0.782 Inexact Rounded pwsx4100 power 0.0611 0.5 -> 0.247 Inexact Rounded pwsx4101 power 0.612 0.5 -> 0.782 Inexact Rounded pwsx4102 power 0.0612 0.5 -> 0.247 Inexact Rounded pwsx4103 power 0.613 0.5 -> 0.783 Inexact Rounded pwsx4104 power 0.0613 0.5 -> 0.248 Inexact Rounded pwsx4105 power 0.614 0.5 -> 0.784 Inexact Rounded pwsx4106 power 0.0614 0.5 -> 0.248 Inexact Rounded pwsx4107 power 0.615 0.5 -> 0.784 Inexact Rounded pwsx4108 power 0.0615 0.5 -> 0.248 Inexact Rounded pwsx4109 power 0.616 0.5 -> 0.785 Inexact Rounded pwsx4110 power 0.0616 0.5 -> 0.248 Inexact Rounded pwsx4111 power 0.617 0.5 -> 0.785 Inexact Rounded pwsx4112 power 0.0617 0.5 -> 0.248 Inexact Rounded pwsx4113 power 0.618 0.5 -> 0.786 Inexact Rounded pwsx4114 power 0.0618 0.5 -> 0.249 Inexact Rounded pwsx4115 power 0.619 0.5 -> 0.787 Inexact Rounded pwsx4116 power 0.0619 0.5 -> 0.249 Inexact Rounded pwsx4117 power 0.621 0.5 -> 0.788 Inexact Rounded pwsx4118 power 0.0621 0.5 -> 0.249 Inexact Rounded pwsx4119 power 0.622 0.5 -> 0.789 Inexact Rounded pwsx4120 power 0.0622 0.5 -> 0.249 Inexact Rounded pwsx4121 power 0.623 0.5 -> 0.789 Inexact Rounded pwsx4122 power 0.0623 0.5 -> 0.250 Inexact Rounded pwsx4123 power 0.624 0.5 -> 0.790 Inexact Rounded pwsx4124 power 0.0624 0.5 -> 0.250 Inexact Rounded pwsx4125 power 0.625 0.5 -> 0.791 Inexact Rounded pwsx4126 power 0.0625 0.5 -> 0.250 Inexact Rounded pwsx4127 power 0.626 0.5 -> 0.791 Inexact Rounded pwsx4128 power 0.0626 0.5 -> 0.250 Inexact Rounded pwsx4129 power 0.627 0.5 -> 0.792 Inexact Rounded pwsx4130 power 0.0627 0.5 -> 0.250 Inexact Rounded pwsx4131 power 0.628 0.5 -> 0.792 Inexact Rounded pwsx4132 power 0.0628 0.5 -> 0.251 Inexact Rounded pwsx4133 power 0.629 0.5 -> 0.793 Inexact Rounded pwsx4134 power 0.0629 0.5 -> 0.251 Inexact Rounded pwsx4135 power 0.631 0.5 -> 0.794 Inexact Rounded pwsx4136 power 0.0631 0.5 -> 0.251 Inexact Rounded pwsx4137 power 0.632 0.5 -> 0.795 Inexact Rounded pwsx4138 power 0.0632 0.5 -> 0.251 Inexact Rounded pwsx4139 power 0.633 0.5 -> 0.796 Inexact Rounded pwsx4140 power 0.0633 0.5 -> 0.252 Inexact Rounded pwsx4141 power 0.634 0.5 -> 0.796 Inexact Rounded pwsx4142 power 0.0634 0.5 -> 0.252 Inexact Rounded pwsx4143 power 0.635 0.5 -> 0.797 Inexact Rounded pwsx4144 power 0.0635 0.5 -> 0.252 Inexact Rounded pwsx4145 power 0.636 0.5 -> 0.797 Inexact Rounded pwsx4146 power 0.0636 0.5 -> 0.252 Inexact Rounded pwsx4147 power 0.637 0.5 -> 0.798 Inexact Rounded pwsx4148 power 0.0637 0.5 -> 0.252 Inexact Rounded pwsx4149 power 0.638 0.5 -> 0.799 Inexact Rounded pwsx4150 power 0.0638 0.5 -> 0.253 Inexact Rounded pwsx4151 power 0.639 0.5 -> 0.799 Inexact Rounded pwsx4152 power 0.0639 0.5 -> 0.253 Inexact Rounded pwsx4153 power 0.641 0.5 -> 0.801 Inexact Rounded pwsx4154 power 0.0641 0.5 -> 0.253 Inexact Rounded pwsx4155 power 0.642 0.5 -> 0.801 Inexact Rounded pwsx4156 power 0.0642 0.5 -> 0.253 Inexact Rounded pwsx4157 power 0.643 0.5 -> 0.802 Inexact Rounded pwsx4158 power 0.0643 0.5 -> 0.254 Inexact Rounded pwsx4159 power 0.644 0.5 -> 0.802 Inexact Rounded pwsx4160 power 0.0644 0.5 -> 0.254 Inexact Rounded pwsx4161 power 0.645 0.5 -> 0.803 Inexact Rounded pwsx4162 power 0.0645 0.5 -> 0.254 Inexact Rounded pwsx4163 power 0.646 0.5 -> 0.804 Inexact Rounded pwsx4164 power 0.0646 0.5 -> 0.254 Inexact Rounded pwsx4165 power 0.647 0.5 -> 0.804 Inexact Rounded pwsx4166 power 0.0647 0.5 -> 0.254 Inexact Rounded pwsx4167 power 0.648 0.5 -> 0.805 Inexact Rounded pwsx4168 power 0.0648 0.5 -> 0.255 Inexact Rounded pwsx4169 power 0.649 0.5 -> 0.806 Inexact Rounded pwsx4170 power 0.0649 0.5 -> 0.255 Inexact Rounded pwsx4171 power 0.651 0.5 -> 0.807 Inexact Rounded pwsx4172 power 0.0651 0.5 -> 0.255 Inexact Rounded pwsx4173 power 0.652 0.5 -> 0.807 Inexact Rounded pwsx4174 power 0.0652 0.5 -> 0.255 Inexact Rounded pwsx4175 power 0.653 0.5 -> 0.808 Inexact Rounded pwsx4176 power 0.0653 0.5 -> 0.256 Inexact Rounded pwsx4177 power 0.654 0.5 -> 0.809 Inexact Rounded pwsx4178 power 0.0654 0.5 -> 0.256 Inexact Rounded pwsx4179 power 0.655 0.5 -> 0.809 Inexact Rounded pwsx4180 power 0.0655 0.5 -> 0.256 Inexact Rounded pwsx4181 power 0.656 0.5 -> 0.810 Inexact Rounded pwsx4182 power 0.0656 0.5 -> 0.256 Inexact Rounded pwsx4183 power 0.657 0.5 -> 0.811 Inexact Rounded pwsx4184 power 0.0657 0.5 -> 0.256 Inexact Rounded pwsx4185 power 0.658 0.5 -> 0.811 Inexact Rounded pwsx4186 power 0.0658 0.5 -> 0.257 Inexact Rounded pwsx4187 power 0.659 0.5 -> 0.812 Inexact Rounded pwsx4188 power 0.0659 0.5 -> 0.257 Inexact Rounded pwsx4189 power 0.661 0.5 -> 0.813 Inexact Rounded pwsx4190 power 0.0661 0.5 -> 0.257 Inexact Rounded pwsx4191 power 0.662 0.5 -> 0.814 Inexact Rounded pwsx4192 power 0.0662 0.5 -> 0.257 Inexact Rounded pwsx4193 power 0.663 0.5 -> 0.814 Inexact Rounded pwsx4194 power 0.0663 0.5 -> 0.257 Inexact Rounded pwsx4195 power 0.664 0.5 -> 0.815 Inexact Rounded pwsx4196 power 0.0664 0.5 -> 0.258 Inexact Rounded pwsx4197 power 0.665 0.5 -> 0.815 Inexact Rounded pwsx4198 power 0.0665 0.5 -> 0.258 Inexact Rounded pwsx4199 power 0.666 0.5 -> 0.816 Inexact Rounded pwsx4200 power 0.0666 0.5 -> 0.258 Inexact Rounded pwsx4201 power 0.667 0.5 -> 0.817 Inexact Rounded pwsx4202 power 0.0667 0.5 -> 0.258 Inexact Rounded pwsx4203 power 0.668 0.5 -> 0.817 Inexact Rounded pwsx4204 power 0.0668 0.5 -> 0.258 Inexact Rounded pwsx4205 power 0.669 0.5 -> 0.818 Inexact Rounded pwsx4206 power 0.0669 0.5 -> 0.259 Inexact Rounded pwsx4207 power 0.671 0.5 -> 0.819 Inexact Rounded pwsx4208 power 0.0671 0.5 -> 0.259 Inexact Rounded pwsx4209 power 0.672 0.5 -> 0.820 Inexact Rounded pwsx4210 power 0.0672 0.5 -> 0.259 Inexact Rounded pwsx4211 power 0.673 0.5 -> 0.820 Inexact Rounded pwsx4212 power 0.0673 0.5 -> 0.259 Inexact Rounded pwsx4213 power 0.674 0.5 -> 0.821 Inexact Rounded pwsx4214 power 0.0674 0.5 -> 0.260 Inexact Rounded pwsx4215 power 0.675 0.5 -> 0.822 Inexact Rounded pwsx4216 power 0.0675 0.5 -> 0.260 Inexact Rounded pwsx4217 power 0.676 0.5 -> 0.822 Inexact Rounded pwsx4218 power 0.0676 0.5 -> 0.260 Inexact Rounded pwsx4219 power 0.677 0.5 -> 0.823 Inexact Rounded pwsx4220 power 0.0677 0.5 -> 0.260 Inexact Rounded pwsx4221 power 0.678 0.5 -> 0.823 Inexact Rounded pwsx4222 power 0.0678 0.5 -> 0.260 Inexact Rounded pwsx4223 power 0.679 0.5 -> 0.824 Inexact Rounded pwsx4224 power 0.0679 0.5 -> 0.261 Inexact Rounded pwsx4225 power 0.681 0.5 -> 0.825 Inexact Rounded pwsx4226 power 0.0681 0.5 -> 0.261 Inexact Rounded pwsx4227 power 0.682 0.5 -> 0.826 Inexact Rounded pwsx4228 power 0.0682 0.5 -> 0.261 Inexact Rounded pwsx4229 power 0.683 0.5 -> 0.826 Inexact Rounded pwsx4230 power 0.0683 0.5 -> 0.261 Inexact Rounded pwsx4231 power 0.684 0.5 -> 0.827 Inexact Rounded pwsx4232 power 0.0684 0.5 -> 0.262 Inexact Rounded pwsx4233 power 0.685 0.5 -> 0.828 Inexact Rounded pwsx4234 power 0.0685 0.5 -> 0.262 Inexact Rounded pwsx4235 power 0.686 0.5 -> 0.828 Inexact Rounded pwsx4236 power 0.0686 0.5 -> 0.262 Inexact Rounded pwsx4237 power 0.687 0.5 -> 0.829 Inexact Rounded pwsx4238 power 0.0687 0.5 -> 0.262 Inexact Rounded pwsx4239 power 0.688 0.5 -> 0.829 Inexact Rounded pwsx4240 power 0.0688 0.5 -> 0.262 Inexact Rounded pwsx4241 power 0.689 0.5 -> 0.830 Inexact Rounded pwsx4242 power 0.0689 0.5 -> 0.262 Inexact Rounded pwsx4243 power 0.691 0.5 -> 0.831 Inexact Rounded pwsx4244 power 0.0691 0.5 -> 0.263 Inexact Rounded pwsx4245 power 0.692 0.5 -> 0.832 Inexact Rounded pwsx4246 power 0.0692 0.5 -> 0.263 Inexact Rounded pwsx4247 power 0.693 0.5 -> 0.832 Inexact Rounded pwsx4248 power 0.0693 0.5 -> 0.263 Inexact Rounded pwsx4249 power 0.694 0.5 -> 0.833 Inexact Rounded pwsx4250 power 0.0694 0.5 -> 0.263 Inexact Rounded pwsx4251 power 0.695 0.5 -> 0.834 Inexact Rounded pwsx4252 power 0.0695 0.5 -> 0.264 Inexact Rounded pwsx4253 power 0.696 0.5 -> 0.834 Inexact Rounded pwsx4254 power 0.0696 0.5 -> 0.264 Inexact Rounded pwsx4255 power 0.697 0.5 -> 0.835 Inexact Rounded pwsx4256 power 0.0697 0.5 -> 0.264 Inexact Rounded pwsx4257 power 0.698 0.5 -> 0.835 Inexact Rounded pwsx4258 power 0.0698 0.5 -> 0.264 Inexact Rounded pwsx4259 power 0.699 0.5 -> 0.836 Inexact Rounded pwsx4260 power 0.0699 0.5 -> 0.264 Inexact Rounded pwsx4261 power 0.701 0.5 -> 0.837 Inexact Rounded pwsx4262 power 0.0701 0.5 -> 0.265 Inexact Rounded pwsx4263 power 0.702 0.5 -> 0.838 Inexact Rounded pwsx4264 power 0.0702 0.5 -> 0.265 Inexact Rounded pwsx4265 power 0.703 0.5 -> 0.838 Inexact Rounded pwsx4266 power 0.0703 0.5 -> 0.265 Inexact Rounded pwsx4267 power 0.704 0.5 -> 0.839 Inexact Rounded pwsx4268 power 0.0704 0.5 -> 0.265 Inexact Rounded pwsx4269 power 0.705 0.5 -> 0.840 Inexact Rounded pwsx4270 power 0.0705 0.5 -> 0.266 Inexact Rounded pwsx4271 power 0.706 0.5 -> 0.840 Inexact Rounded pwsx4272 power 0.0706 0.5 -> 0.266 Inexact Rounded pwsx4273 power 0.707 0.5 -> 0.841 Inexact Rounded pwsx4274 power 0.0707 0.5 -> 0.266 Inexact Rounded pwsx4275 power 0.708 0.5 -> 0.841 Inexact Rounded pwsx4276 power 0.0708 0.5 -> 0.266 Inexact Rounded pwsx4277 power 0.709 0.5 -> 0.842 Inexact Rounded pwsx4278 power 0.0709 0.5 -> 0.266 Inexact Rounded pwsx4279 power 0.711 0.5 -> 0.843 Inexact Rounded pwsx4280 power 0.0711 0.5 -> 0.267 Inexact Rounded pwsx4281 power 0.712 0.5 -> 0.844 Inexact Rounded pwsx4282 power 0.0712 0.5 -> 0.267 Inexact Rounded pwsx4283 power 0.713 0.5 -> 0.844 Inexact Rounded pwsx4284 power 0.0713 0.5 -> 0.267 Inexact Rounded pwsx4285 power 0.714 0.5 -> 0.845 Inexact Rounded pwsx4286 power 0.0714 0.5 -> 0.267 Inexact Rounded pwsx4287 power 0.715 0.5 -> 0.846 Inexact Rounded pwsx4288 power 0.0715 0.5 -> 0.267 Inexact Rounded pwsx4289 power 0.716 0.5 -> 0.846 Inexact Rounded pwsx4290 power 0.0716 0.5 -> 0.268 Inexact Rounded pwsx4291 power 0.717 0.5 -> 0.847 Inexact Rounded pwsx4292 power 0.0717 0.5 -> 0.268 Inexact Rounded pwsx4293 power 0.718 0.5 -> 0.847 Inexact Rounded pwsx4294 power 0.0718 0.5 -> 0.268 Inexact Rounded pwsx4295 power 0.719 0.5 -> 0.848 Inexact Rounded pwsx4296 power 0.0719 0.5 -> 0.268 Inexact Rounded pwsx4297 power 0.721 0.5 -> 0.849 Inexact Rounded pwsx4298 power 0.0721 0.5 -> 0.269 Inexact Rounded pwsx4299 power 0.722 0.5 -> 0.850 Inexact Rounded pwsx4300 power 0.0722 0.5 -> 0.269 Inexact Rounded pwsx4301 power 0.723 0.5 -> 0.850 Inexact Rounded pwsx4302 power 0.0723 0.5 -> 0.269 Inexact Rounded pwsx4303 power 0.724 0.5 -> 0.851 Inexact Rounded pwsx4304 power 0.0724 0.5 -> 0.269 Inexact Rounded pwsx4305 power 0.725 0.5 -> 0.851 Inexact Rounded pwsx4306 power 0.0725 0.5 -> 0.269 Inexact Rounded pwsx4307 power 0.726 0.5 -> 0.852 Inexact Rounded pwsx4308 power 0.0726 0.5 -> 0.269 Inexact Rounded pwsx4309 power 0.727 0.5 -> 0.853 Inexact Rounded pwsx4310 power 0.0727 0.5 -> 0.270 Inexact Rounded pwsx4311 power 0.728 0.5 -> 0.853 Inexact Rounded pwsx4312 power 0.0728 0.5 -> 0.270 Inexact Rounded pwsx4313 power 0.729 0.5 -> 0.854 Inexact Rounded pwsx4314 power 0.0729 0.5 -> 0.270 Inexact Rounded pwsx4315 power 0.731 0.5 -> 0.855 Inexact Rounded pwsx4316 power 0.0731 0.5 -> 0.270 Inexact Rounded pwsx4317 power 0.732 0.5 -> 0.856 Inexact Rounded pwsx4318 power 0.0732 0.5 -> 0.271 Inexact Rounded pwsx4319 power 0.733 0.5 -> 0.856 Inexact Rounded pwsx4320 power 0.0733 0.5 -> 0.271 Inexact Rounded pwsx4321 power 0.734 0.5 -> 0.857 Inexact Rounded pwsx4322 power 0.0734 0.5 -> 0.271 Inexact Rounded pwsx4323 power 0.735 0.5 -> 0.857 Inexact Rounded pwsx4324 power 0.0735 0.5 -> 0.271 Inexact Rounded pwsx4325 power 0.736 0.5 -> 0.858 Inexact Rounded pwsx4326 power 0.0736 0.5 -> 0.271 Inexact Rounded pwsx4327 power 0.737 0.5 -> 0.858 Inexact Rounded pwsx4328 power 0.0737 0.5 -> 0.271 Inexact Rounded pwsx4329 power 0.738 0.5 -> 0.859 Inexact Rounded pwsx4330 power 0.0738 0.5 -> 0.272 Inexact Rounded pwsx4331 power 0.739 0.5 -> 0.860 Inexact Rounded pwsx4332 power 0.0739 0.5 -> 0.272 Inexact Rounded pwsx4333 power 0.741 0.5 -> 0.861 Inexact Rounded pwsx4334 power 0.0741 0.5 -> 0.272 Inexact Rounded pwsx4335 power 0.742 0.5 -> 0.861 Inexact Rounded pwsx4336 power 0.0742 0.5 -> 0.272 Inexact Rounded pwsx4337 power 0.743 0.5 -> 0.862 Inexact Rounded pwsx4338 power 0.0743 0.5 -> 0.273 Inexact Rounded pwsx4339 power 0.744 0.5 -> 0.863 Inexact Rounded pwsx4340 power 0.0744 0.5 -> 0.273 Inexact Rounded pwsx4341 power 0.745 0.5 -> 0.863 Inexact Rounded pwsx4342 power 0.0745 0.5 -> 0.273 Inexact Rounded pwsx4343 power 0.746 0.5 -> 0.864 Inexact Rounded pwsx4344 power 0.0746 0.5 -> 0.273 Inexact Rounded pwsx4345 power 0.747 0.5 -> 0.864 Inexact Rounded pwsx4346 power 0.0747 0.5 -> 0.273 Inexact Rounded pwsx4347 power 0.748 0.5 -> 0.865 Inexact Rounded pwsx4348 power 0.0748 0.5 -> 0.273 Inexact Rounded pwsx4349 power 0.749 0.5 -> 0.865 Inexact Rounded pwsx4350 power 0.0749 0.5 -> 0.274 Inexact Rounded pwsx4351 power 0.751 0.5 -> 0.867 Inexact Rounded pwsx4352 power 0.0751 0.5 -> 0.274 Inexact Rounded pwsx4353 power 0.752 0.5 -> 0.867 Inexact Rounded pwsx4354 power 0.0752 0.5 -> 0.274 Inexact Rounded pwsx4355 power 0.753 0.5 -> 0.868 Inexact Rounded pwsx4356 power 0.0753 0.5 -> 0.274 Inexact Rounded pwsx4357 power 0.754 0.5 -> 0.868 Inexact Rounded pwsx4358 power 0.0754 0.5 -> 0.275 Inexact Rounded pwsx4359 power 0.755 0.5 -> 0.869 Inexact Rounded pwsx4360 power 0.0755 0.5 -> 0.275 Inexact Rounded pwsx4361 power 0.756 0.5 -> 0.869 Inexact Rounded pwsx4362 power 0.0756 0.5 -> 0.275 Inexact Rounded pwsx4363 power 0.757 0.5 -> 0.870 Inexact Rounded pwsx4364 power 0.0757 0.5 -> 0.275 Inexact Rounded pwsx4365 power 0.758 0.5 -> 0.871 Inexact Rounded pwsx4366 power 0.0758 0.5 -> 0.275 Inexact Rounded pwsx4367 power 0.759 0.5 -> 0.871 Inexact Rounded pwsx4368 power 0.0759 0.5 -> 0.275 Inexact Rounded pwsx4369 power 0.761 0.5 -> 0.872 Inexact Rounded pwsx4370 power 0.0761 0.5 -> 0.276 Inexact Rounded pwsx4371 power 0.762 0.5 -> 0.873 Inexact Rounded pwsx4372 power 0.0762 0.5 -> 0.276 Inexact Rounded pwsx4373 power 0.763 0.5 -> 0.873 Inexact Rounded pwsx4374 power 0.0763 0.5 -> 0.276 Inexact Rounded pwsx4375 power 0.764 0.5 -> 0.874 Inexact Rounded pwsx4376 power 0.0764 0.5 -> 0.276 Inexact Rounded pwsx4377 power 0.765 0.5 -> 0.875 Inexact Rounded pwsx4378 power 0.0765 0.5 -> 0.277 Inexact Rounded pwsx4379 power 0.766 0.5 -> 0.875 Inexact Rounded pwsx4380 power 0.0766 0.5 -> 0.277 Inexact Rounded pwsx4381 power 0.767 0.5 -> 0.876 Inexact Rounded pwsx4382 power 0.0767 0.5 -> 0.277 Inexact Rounded pwsx4383 power 0.768 0.5 -> 0.876 Inexact Rounded pwsx4384 power 0.0768 0.5 -> 0.277 Inexact Rounded pwsx4385 power 0.769 0.5 -> 0.877 Inexact Rounded pwsx4386 power 0.0769 0.5 -> 0.277 Inexact Rounded pwsx4387 power 0.771 0.5 -> 0.878 Inexact Rounded pwsx4388 power 0.0771 0.5 -> 0.278 Inexact Rounded pwsx4389 power 0.772 0.5 -> 0.879 Inexact Rounded pwsx4390 power 0.0772 0.5 -> 0.278 Inexact Rounded pwsx4391 power 0.773 0.5 -> 0.879 Inexact Rounded pwsx4392 power 0.0773 0.5 -> 0.278 Inexact Rounded pwsx4393 power 0.774 0.5 -> 0.880 Inexact Rounded pwsx4394 power 0.0774 0.5 -> 0.278 Inexact Rounded pwsx4395 power 0.775 0.5 -> 0.880 Inexact Rounded pwsx4396 power 0.0775 0.5 -> 0.278 Inexact Rounded pwsx4397 power 0.776 0.5 -> 0.881 Inexact Rounded pwsx4398 power 0.0776 0.5 -> 0.279 Inexact Rounded pwsx4399 power 0.777 0.5 -> 0.881 Inexact Rounded pwsx4400 power 0.0777 0.5 -> 0.279 Inexact Rounded pwsx4401 power 0.778 0.5 -> 0.882 Inexact Rounded pwsx4402 power 0.0778 0.5 -> 0.279 Inexact Rounded pwsx4403 power 0.779 0.5 -> 0.883 Inexact Rounded pwsx4404 power 0.0779 0.5 -> 0.279 Inexact Rounded pwsx4405 power 0.781 0.5 -> 0.884 Inexact Rounded pwsx4406 power 0.0781 0.5 -> 0.279 Inexact Rounded pwsx4407 power 0.782 0.5 -> 0.884 Inexact Rounded pwsx4408 power 0.0782 0.5 -> 0.280 Inexact Rounded pwsx4409 power 0.783 0.5 -> 0.885 Inexact Rounded pwsx4410 power 0.0783 0.5 -> 0.280 Inexact Rounded pwsx4411 power 0.784 0.5 -> 0.885 Inexact Rounded pwsx4412 power 0.0784 0.5 -> 0.280 Inexact Rounded pwsx4413 power 0.785 0.5 -> 0.886 Inexact Rounded pwsx4414 power 0.0785 0.5 -> 0.280 Inexact Rounded pwsx4415 power 0.786 0.5 -> 0.887 Inexact Rounded pwsx4416 power 0.0786 0.5 -> 0.280 Inexact Rounded pwsx4417 power 0.787 0.5 -> 0.887 Inexact Rounded pwsx4418 power 0.0787 0.5 -> 0.281 Inexact Rounded pwsx4419 power 0.788 0.5 -> 0.888 Inexact Rounded pwsx4420 power 0.0788 0.5 -> 0.281 Inexact Rounded pwsx4421 power 0.789 0.5 -> 0.888 Inexact Rounded pwsx4422 power 0.0789 0.5 -> 0.281 Inexact Rounded pwsx4423 power 0.791 0.5 -> 0.889 Inexact Rounded pwsx4424 power 0.0791 0.5 -> 0.281 Inexact Rounded pwsx4425 power 0.792 0.5 -> 0.890 Inexact Rounded pwsx4426 power 0.0792 0.5 -> 0.281 Inexact Rounded pwsx4427 power 0.793 0.5 -> 0.891 Inexact Rounded pwsx4428 power 0.0793 0.5 -> 0.282 Inexact Rounded pwsx4429 power 0.794 0.5 -> 0.891 Inexact Rounded pwsx4430 power 0.0794 0.5 -> 0.282 Inexact Rounded pwsx4431 power 0.795 0.5 -> 0.892 Inexact Rounded pwsx4432 power 0.0795 0.5 -> 0.282 Inexact Rounded pwsx4433 power 0.796 0.5 -> 0.892 Inexact Rounded pwsx4434 power 0.0796 0.5 -> 0.282 Inexact Rounded pwsx4435 power 0.797 0.5 -> 0.893 Inexact Rounded pwsx4436 power 0.0797 0.5 -> 0.282 Inexact Rounded pwsx4437 power 0.798 0.5 -> 0.893 Inexact Rounded pwsx4438 power 0.0798 0.5 -> 0.282 Inexact Rounded pwsx4439 power 0.799 0.5 -> 0.894 Inexact Rounded pwsx4440 power 0.0799 0.5 -> 0.283 Inexact Rounded pwsx4441 power 0.801 0.5 -> 0.895 Inexact Rounded pwsx4442 power 0.0801 0.5 -> 0.283 Inexact Rounded pwsx4443 power 0.802 0.5 -> 0.896 Inexact Rounded pwsx4444 power 0.0802 0.5 -> 0.283 Inexact Rounded pwsx4445 power 0.803 0.5 -> 0.896 Inexact Rounded pwsx4446 power 0.0803 0.5 -> 0.283 Inexact Rounded pwsx4447 power 0.804 0.5 -> 0.897 Inexact Rounded pwsx4448 power 0.0804 0.5 -> 0.284 Inexact Rounded pwsx4449 power 0.805 0.5 -> 0.897 Inexact Rounded pwsx4450 power 0.0805 0.5 -> 0.284 Inexact Rounded pwsx4451 power 0.806 0.5 -> 0.898 Inexact Rounded pwsx4452 power 0.0806 0.5 -> 0.284 Inexact Rounded pwsx4453 power 0.807 0.5 -> 0.898 Inexact Rounded pwsx4454 power 0.0807 0.5 -> 0.284 Inexact Rounded pwsx4455 power 0.808 0.5 -> 0.899 Inexact Rounded pwsx4456 power 0.0808 0.5 -> 0.284 Inexact Rounded pwsx4457 power 0.809 0.5 -> 0.899 Inexact Rounded pwsx4458 power 0.0809 0.5 -> 0.284 Inexact Rounded pwsx4459 power 0.811 0.5 -> 0.901 Inexact Rounded pwsx4460 power 0.0811 0.5 -> 0.285 Inexact Rounded pwsx4461 power 0.812 0.5 -> 0.901 Inexact Rounded pwsx4462 power 0.0812 0.5 -> 0.285 Inexact Rounded pwsx4463 power 0.813 0.5 -> 0.902 Inexact Rounded pwsx4464 power 0.0813 0.5 -> 0.285 Inexact Rounded pwsx4465 power 0.814 0.5 -> 0.902 Inexact Rounded pwsx4466 power 0.0814 0.5 -> 0.285 Inexact Rounded pwsx4467 power 0.815 0.5 -> 0.903 Inexact Rounded pwsx4468 power 0.0815 0.5 -> 0.285 Inexact Rounded pwsx4469 power 0.816 0.5 -> 0.903 Inexact Rounded pwsx4470 power 0.0816 0.5 -> 0.286 Inexact Rounded pwsx4471 power 0.817 0.5 -> 0.904 Inexact Rounded pwsx4472 power 0.0817 0.5 -> 0.286 Inexact Rounded pwsx4473 power 0.818 0.5 -> 0.904 Inexact Rounded pwsx4474 power 0.0818 0.5 -> 0.286 Inexact Rounded pwsx4475 power 0.819 0.5 -> 0.905 Inexact Rounded pwsx4476 power 0.0819 0.5 -> 0.286 Inexact Rounded pwsx4477 power 0.821 0.5 -> 0.906 Inexact Rounded pwsx4478 power 0.0821 0.5 -> 0.287 Inexact Rounded pwsx4479 power 0.822 0.5 -> 0.907 Inexact Rounded pwsx4480 power 0.0822 0.5 -> 0.287 Inexact Rounded pwsx4481 power 0.823 0.5 -> 0.907 Inexact Rounded pwsx4482 power 0.0823 0.5 -> 0.287 Inexact Rounded pwsx4483 power 0.824 0.5 -> 0.908 Inexact Rounded pwsx4484 power 0.0824 0.5 -> 0.287 Inexact Rounded pwsx4485 power 0.825 0.5 -> 0.908 Inexact Rounded pwsx4486 power 0.0825 0.5 -> 0.287 Inexact Rounded pwsx4487 power 0.826 0.5 -> 0.909 Inexact Rounded pwsx4488 power 0.0826 0.5 -> 0.287 Inexact Rounded pwsx4489 power 0.827 0.5 -> 0.909 Inexact Rounded pwsx4490 power 0.0827 0.5 -> 0.288 Inexact Rounded pwsx4491 power 0.828 0.5 -> 0.910 Inexact Rounded pwsx4492 power 0.0828 0.5 -> 0.288 Inexact Rounded pwsx4493 power 0.829 0.5 -> 0.910 Inexact Rounded pwsx4494 power 0.0829 0.5 -> 0.288 Inexact Rounded pwsx4495 power 0.831 0.5 -> 0.912 Inexact Rounded pwsx4496 power 0.0831 0.5 -> 0.288 Inexact Rounded pwsx4497 power 0.832 0.5 -> 0.912 Inexact Rounded pwsx4498 power 0.0832 0.5 -> 0.288 Inexact Rounded pwsx4499 power 0.833 0.5 -> 0.913 Inexact Rounded pwsx4500 power 0.0833 0.5 -> 0.289 Inexact Rounded pwsx4501 power 0.834 0.5 -> 0.913 Inexact Rounded pwsx4502 power 0.0834 0.5 -> 0.289 Inexact Rounded pwsx4503 power 0.835 0.5 -> 0.914 Inexact Rounded pwsx4504 power 0.0835 0.5 -> 0.289 Inexact Rounded pwsx4505 power 0.836 0.5 -> 0.914 Inexact Rounded pwsx4506 power 0.0836 0.5 -> 0.289 Inexact Rounded pwsx4507 power 0.837 0.5 -> 0.915 Inexact Rounded pwsx4508 power 0.0837 0.5 -> 0.289 Inexact Rounded pwsx4509 power 0.838 0.5 -> 0.915 Inexact Rounded pwsx4510 power 0.0838 0.5 -> 0.289 Inexact Rounded pwsx4511 power 0.839 0.5 -> 0.916 Inexact Rounded pwsx4512 power 0.0839 0.5 -> 0.290 Inexact Rounded pwsx4513 power 0.841 0.5 -> 0.917 Inexact Rounded pwsx4514 power 0.0841 0.5 -> 0.290 Inexact Rounded pwsx4515 power 0.842 0.5 -> 0.918 Inexact Rounded pwsx4516 power 0.0842 0.5 -> 0.290 Inexact Rounded pwsx4517 power 0.843 0.5 -> 0.918 Inexact Rounded pwsx4518 power 0.0843 0.5 -> 0.290 Inexact Rounded pwsx4519 power 0.844 0.5 -> 0.919 Inexact Rounded pwsx4520 power 0.0844 0.5 -> 0.291 Inexact Rounded pwsx4521 power 0.845 0.5 -> 0.919 Inexact Rounded pwsx4522 power 0.0845 0.5 -> 0.291 Inexact Rounded pwsx4523 power 0.846 0.5 -> 0.920 Inexact Rounded pwsx4524 power 0.0846 0.5 -> 0.291 Inexact Rounded pwsx4525 power 0.847 0.5 -> 0.920 Inexact Rounded pwsx4526 power 0.0847 0.5 -> 0.291 Inexact Rounded pwsx4527 power 0.848 0.5 -> 0.921 Inexact Rounded pwsx4528 power 0.0848 0.5 -> 0.291 Inexact Rounded pwsx4529 power 0.849 0.5 -> 0.921 Inexact Rounded pwsx4530 power 0.0849 0.5 -> 0.291 Inexact Rounded pwsx4531 power 0.851 0.5 -> 0.922 Inexact Rounded pwsx4532 power 0.0851 0.5 -> 0.292 Inexact Rounded pwsx4533 power 0.852 0.5 -> 0.923 Inexact Rounded pwsx4534 power 0.0852 0.5 -> 0.292 Inexact Rounded pwsx4535 power 0.853 0.5 -> 0.924 Inexact Rounded pwsx4536 power 0.0853 0.5 -> 0.292 Inexact Rounded pwsx4537 power 0.854 0.5 -> 0.924 Inexact Rounded pwsx4538 power 0.0854 0.5 -> 0.292 Inexact Rounded pwsx4539 power 0.855 0.5 -> 0.925 Inexact Rounded pwsx4540 power 0.0855 0.5 -> 0.292 Inexact Rounded pwsx4541 power 0.856 0.5 -> 0.925 Inexact Rounded pwsx4542 power 0.0856 0.5 -> 0.293 Inexact Rounded pwsx4543 power 0.857 0.5 -> 0.926 Inexact Rounded pwsx4544 power 0.0857 0.5 -> 0.293 Inexact Rounded pwsx4545 power 0.858 0.5 -> 0.926 Inexact Rounded pwsx4546 power 0.0858 0.5 -> 0.293 Inexact Rounded pwsx4547 power 0.859 0.5 -> 0.927 Inexact Rounded pwsx4548 power 0.0859 0.5 -> 0.293 Inexact Rounded pwsx4549 power 0.861 0.5 -> 0.928 Inexact Rounded pwsx4550 power 0.0861 0.5 -> 0.293 Inexact Rounded pwsx4551 power 0.862 0.5 -> 0.928 Inexact Rounded pwsx4552 power 0.0862 0.5 -> 0.294 Inexact Rounded pwsx4553 power 0.863 0.5 -> 0.929 Inexact Rounded pwsx4554 power 0.0863 0.5 -> 0.294 Inexact Rounded pwsx4555 power 0.864 0.5 -> 0.930 Inexact Rounded pwsx4556 power 0.0864 0.5 -> 0.294 Inexact Rounded pwsx4557 power 0.865 0.5 -> 0.930 Inexact Rounded pwsx4558 power 0.0865 0.5 -> 0.294 Inexact Rounded pwsx4559 power 0.866 0.5 -> 0.931 Inexact Rounded pwsx4560 power 0.0866 0.5 -> 0.294 Inexact Rounded pwsx4561 power 0.867 0.5 -> 0.931 Inexact Rounded pwsx4562 power 0.0867 0.5 -> 0.294 Inexact Rounded pwsx4563 power 0.868 0.5 -> 0.932 Inexact Rounded pwsx4564 power 0.0868 0.5 -> 0.295 Inexact Rounded pwsx4565 power 0.869 0.5 -> 0.932 Inexact Rounded pwsx4566 power 0.0869 0.5 -> 0.295 Inexact Rounded pwsx4567 power 0.871 0.5 -> 0.933 Inexact Rounded pwsx4568 power 0.0871 0.5 -> 0.295 Inexact Rounded pwsx4569 power 0.872 0.5 -> 0.934 Inexact Rounded pwsx4570 power 0.0872 0.5 -> 0.295 Inexact Rounded pwsx4571 power 0.873 0.5 -> 0.934 Inexact Rounded pwsx4572 power 0.0873 0.5 -> 0.295 Inexact Rounded pwsx4573 power 0.874 0.5 -> 0.935 Inexact Rounded pwsx4574 power 0.0874 0.5 -> 0.296 Inexact Rounded pwsx4575 power 0.875 0.5 -> 0.935 Inexact Rounded pwsx4576 power 0.0875 0.5 -> 0.296 Inexact Rounded pwsx4577 power 0.876 0.5 -> 0.936 Inexact Rounded pwsx4578 power 0.0876 0.5 -> 0.296 Inexact Rounded pwsx4579 power 0.877 0.5 -> 0.936 Inexact Rounded pwsx4580 power 0.0877 0.5 -> 0.296 Inexact Rounded pwsx4581 power 0.878 0.5 -> 0.937 Inexact Rounded pwsx4582 power 0.0878 0.5 -> 0.296 Inexact Rounded pwsx4583 power 0.879 0.5 -> 0.938 Inexact Rounded pwsx4584 power 0.0879 0.5 -> 0.296 Inexact Rounded pwsx4585 power 0.881 0.5 -> 0.939 Inexact Rounded pwsx4586 power 0.0881 0.5 -> 0.297 Inexact Rounded pwsx4587 power 0.882 0.5 -> 0.939 Inexact Rounded pwsx4588 power 0.0882 0.5 -> 0.297 Inexact Rounded pwsx4589 power 0.883 0.5 -> 0.940 Inexact Rounded pwsx4590 power 0.0883 0.5 -> 0.297 Inexact Rounded pwsx4591 power 0.884 0.5 -> 0.940 Inexact Rounded pwsx4592 power 0.0884 0.5 -> 0.297 Inexact Rounded pwsx4593 power 0.885 0.5 -> 0.941 Inexact Rounded pwsx4594 power 0.0885 0.5 -> 0.297 Inexact Rounded pwsx4595 power 0.886 0.5 -> 0.941 Inexact Rounded pwsx4596 power 0.0886 0.5 -> 0.298 Inexact Rounded pwsx4597 power 0.887 0.5 -> 0.942 Inexact Rounded pwsx4598 power 0.0887 0.5 -> 0.298 Inexact Rounded pwsx4599 power 0.888 0.5 -> 0.942 Inexact Rounded pwsx4600 power 0.0888 0.5 -> 0.298 Inexact Rounded pwsx4601 power 0.889 0.5 -> 0.943 Inexact Rounded pwsx4602 power 0.0889 0.5 -> 0.298 Inexact Rounded pwsx4603 power 0.891 0.5 -> 0.944 Inexact Rounded pwsx4604 power 0.0891 0.5 -> 0.298 Inexact Rounded pwsx4605 power 0.892 0.5 -> 0.944 Inexact Rounded pwsx4606 power 0.0892 0.5 -> 0.299 Inexact Rounded pwsx4607 power 0.893 0.5 -> 0.945 Inexact Rounded pwsx4608 power 0.0893 0.5 -> 0.299 Inexact Rounded pwsx4609 power 0.894 0.5 -> 0.946 Inexact Rounded pwsx4610 power 0.0894 0.5 -> 0.299 Inexact Rounded pwsx4611 power 0.895 0.5 -> 0.946 Inexact Rounded pwsx4612 power 0.0895 0.5 -> 0.299 Inexact Rounded pwsx4613 power 0.896 0.5 -> 0.947 Inexact Rounded pwsx4614 power 0.0896 0.5 -> 0.299 Inexact Rounded pwsx4615 power 0.897 0.5 -> 0.947 Inexact Rounded pwsx4616 power 0.0897 0.5 -> 0.299 Inexact Rounded pwsx4617 power 0.898 0.5 -> 0.948 Inexact Rounded pwsx4618 power 0.0898 0.5 -> 0.300 Inexact Rounded pwsx4619 power 0.899 0.5 -> 0.948 Inexact Rounded pwsx4620 power 0.0899 0.5 -> 0.300 Inexact Rounded pwsx4621 power 0.901 0.5 -> 0.949 Inexact Rounded pwsx4622 power 0.0901 0.5 -> 0.300 Inexact Rounded pwsx4623 power 0.902 0.5 -> 0.950 Inexact Rounded pwsx4624 power 0.0902 0.5 -> 0.300 Inexact Rounded pwsx4625 power 0.903 0.5 -> 0.950 Inexact Rounded pwsx4626 power 0.0903 0.5 -> 0.300 Inexact Rounded pwsx4627 power 0.904 0.5 -> 0.951 Inexact Rounded pwsx4628 power 0.0904 0.5 -> 0.301 Inexact Rounded pwsx4629 power 0.905 0.5 -> 0.951 Inexact Rounded pwsx4630 power 0.0905 0.5 -> 0.301 Inexact Rounded pwsx4631 power 0.906 0.5 -> 0.952 Inexact Rounded pwsx4632 power 0.0906 0.5 -> 0.301 Inexact Rounded pwsx4633 power 0.907 0.5 -> 0.952 Inexact Rounded pwsx4634 power 0.0907 0.5 -> 0.301 Inexact Rounded pwsx4635 power 0.908 0.5 -> 0.953 Inexact Rounded pwsx4636 power 0.0908 0.5 -> 0.301 Inexact Rounded pwsx4637 power 0.909 0.5 -> 0.953 Inexact Rounded pwsx4638 power 0.0909 0.5 -> 0.301 Inexact Rounded pwsx4639 power 0.911 0.5 -> 0.954 Inexact Rounded pwsx4640 power 0.0911 0.5 -> 0.302 Inexact Rounded pwsx4641 power 0.912 0.5 -> 0.955 Inexact Rounded pwsx4642 power 0.0912 0.5 -> 0.302 Inexact Rounded pwsx4643 power 0.913 0.5 -> 0.956 Inexact Rounded pwsx4644 power 0.0913 0.5 -> 0.302 Inexact Rounded pwsx4645 power 0.914 0.5 -> 0.956 Inexact Rounded pwsx4646 power 0.0914 0.5 -> 0.302 Inexact Rounded pwsx4647 power 0.915 0.5 -> 0.957 Inexact Rounded pwsx4648 power 0.0915 0.5 -> 0.302 Inexact Rounded pwsx4649 power 0.916 0.5 -> 0.957 Inexact Rounded pwsx4650 power 0.0916 0.5 -> 0.303 Inexact Rounded pwsx4651 power 0.917 0.5 -> 0.958 Inexact Rounded pwsx4652 power 0.0917 0.5 -> 0.303 Inexact Rounded pwsx4653 power 0.918 0.5 -> 0.958 Inexact Rounded pwsx4654 power 0.0918 0.5 -> 0.303 Inexact Rounded pwsx4655 power 0.919 0.5 -> 0.959 Inexact Rounded pwsx4656 power 0.0919 0.5 -> 0.303 Inexact Rounded pwsx4657 power 0.921 0.5 -> 0.960 Inexact Rounded pwsx4658 power 0.0921 0.5 -> 0.303 Inexact Rounded pwsx4659 power 0.922 0.5 -> 0.960 Inexact Rounded pwsx4660 power 0.0922 0.5 -> 0.304 Inexact Rounded pwsx4661 power 0.923 0.5 -> 0.961 Inexact Rounded pwsx4662 power 0.0923 0.5 -> 0.304 Inexact Rounded pwsx4663 power 0.924 0.5 -> 0.961 Inexact Rounded pwsx4664 power 0.0924 0.5 -> 0.304 Inexact Rounded pwsx4665 power 0.925 0.5 -> 0.962 Inexact Rounded pwsx4666 power 0.0925 0.5 -> 0.304 Inexact Rounded pwsx4667 power 0.926 0.5 -> 0.962 Inexact Rounded pwsx4668 power 0.0926 0.5 -> 0.304 Inexact Rounded pwsx4669 power 0.927 0.5 -> 0.963 Inexact Rounded pwsx4670 power 0.0927 0.5 -> 0.304 Inexact Rounded pwsx4671 power 0.928 0.5 -> 0.963 Inexact Rounded pwsx4672 power 0.0928 0.5 -> 0.305 Inexact Rounded pwsx4673 power 0.929 0.5 -> 0.964 Inexact Rounded pwsx4674 power 0.0929 0.5 -> 0.305 Inexact Rounded pwsx4675 power 0.931 0.5 -> 0.965 Inexact Rounded pwsx4676 power 0.0931 0.5 -> 0.305 Inexact Rounded pwsx4677 power 0.932 0.5 -> 0.965 Inexact Rounded pwsx4678 power 0.0932 0.5 -> 0.305 Inexact Rounded pwsx4679 power 0.933 0.5 -> 0.966 Inexact Rounded pwsx4680 power 0.0933 0.5 -> 0.305 Inexact Rounded pwsx4681 power 0.934 0.5 -> 0.966 Inexact Rounded pwsx4682 power 0.0934 0.5 -> 0.306 Inexact Rounded pwsx4683 power 0.935 0.5 -> 0.967 Inexact Rounded pwsx4684 power 0.0935 0.5 -> 0.306 Inexact Rounded pwsx4685 power 0.936 0.5 -> 0.967 Inexact Rounded pwsx4686 power 0.0936 0.5 -> 0.306 Inexact Rounded pwsx4687 power 0.937 0.5 -> 0.968 Inexact Rounded pwsx4688 power 0.0937 0.5 -> 0.306 Inexact Rounded pwsx4689 power 0.938 0.5 -> 0.969 Inexact Rounded pwsx4690 power 0.0938 0.5 -> 0.306 Inexact Rounded pwsx4691 power 0.939 0.5 -> 0.969 Inexact Rounded pwsx4692 power 0.0939 0.5 -> 0.306 Inexact Rounded pwsx4693 power 0.941 0.5 -> 0.970 Inexact Rounded pwsx4694 power 0.0941 0.5 -> 0.307 Inexact Rounded pwsx4695 power 0.942 0.5 -> 0.971 Inexact Rounded pwsx4696 power 0.0942 0.5 -> 0.307 Inexact Rounded pwsx4697 power 0.943 0.5 -> 0.971 Inexact Rounded pwsx4698 power 0.0943 0.5 -> 0.307 Inexact Rounded pwsx4699 power 0.944 0.5 -> 0.972 Inexact Rounded pwsx4700 power 0.0944 0.5 -> 0.307 Inexact Rounded pwsx4701 power 0.945 0.5 -> 0.972 Inexact Rounded pwsx4702 power 0.0945 0.5 -> 0.307 Inexact Rounded pwsx4703 power 0.946 0.5 -> 0.973 Inexact Rounded pwsx4704 power 0.0946 0.5 -> 0.308 Inexact Rounded pwsx4705 power 0.947 0.5 -> 0.973 Inexact Rounded pwsx4706 power 0.0947 0.5 -> 0.308 Inexact Rounded pwsx4707 power 0.948 0.5 -> 0.974 Inexact Rounded pwsx4708 power 0.0948 0.5 -> 0.308 Inexact Rounded pwsx4709 power 0.949 0.5 -> 0.974 Inexact Rounded pwsx4710 power 0.0949 0.5 -> 0.308 Inexact Rounded pwsx4711 power 0.951 0.5 -> 0.975 Inexact Rounded pwsx4712 power 0.0951 0.5 -> 0.308 Inexact Rounded pwsx4713 power 0.952 0.5 -> 0.976 Inexact Rounded pwsx4714 power 0.0952 0.5 -> 0.309 Inexact Rounded pwsx4715 power 0.953 0.5 -> 0.976 Inexact Rounded pwsx4716 power 0.0953 0.5 -> 0.309 Inexact Rounded pwsx4717 power 0.954 0.5 -> 0.977 Inexact Rounded pwsx4718 power 0.0954 0.5 -> 0.309 Inexact Rounded pwsx4719 power 0.955 0.5 -> 0.977 Inexact Rounded pwsx4720 power 0.0955 0.5 -> 0.309 Inexact Rounded pwsx4721 power 0.956 0.5 -> 0.978 Inexact Rounded pwsx4722 power 0.0956 0.5 -> 0.309 Inexact Rounded pwsx4723 power 0.957 0.5 -> 0.978 Inexact Rounded pwsx4724 power 0.0957 0.5 -> 0.309 Inexact Rounded pwsx4725 power 0.958 0.5 -> 0.979 Inexact Rounded pwsx4726 power 0.0958 0.5 -> 0.310 Inexact Rounded pwsx4727 power 0.959 0.5 -> 0.979 Inexact Rounded pwsx4728 power 0.0959 0.5 -> 0.310 Inexact Rounded pwsx4729 power 0.961 0.5 -> 0.980 Inexact Rounded pwsx4730 power 0.0961 0.5 -> 0.310 Inexact Rounded pwsx4731 power 0.962 0.5 -> 0.981 Inexact Rounded pwsx4732 power 0.0962 0.5 -> 0.310 Inexact Rounded pwsx4733 power 0.963 0.5 -> 0.981 Inexact Rounded pwsx4734 power 0.0963 0.5 -> 0.310 Inexact Rounded pwsx4735 power 0.964 0.5 -> 0.982 Inexact Rounded pwsx4736 power 0.0964 0.5 -> 0.310 Inexact Rounded pwsx4737 power 0.965 0.5 -> 0.982 Inexact Rounded pwsx4738 power 0.0965 0.5 -> 0.311 Inexact Rounded pwsx4739 power 0.966 0.5 -> 0.983 Inexact Rounded pwsx4740 power 0.0966 0.5 -> 0.311 Inexact Rounded pwsx4741 power 0.967 0.5 -> 0.983 Inexact Rounded pwsx4742 power 0.0967 0.5 -> 0.311 Inexact Rounded pwsx4743 power 0.968 0.5 -> 0.984 Inexact Rounded pwsx4744 power 0.0968 0.5 -> 0.311 Inexact Rounded pwsx4745 power 0.969 0.5 -> 0.984 Inexact Rounded pwsx4746 power 0.0969 0.5 -> 0.311 Inexact Rounded pwsx4747 power 0.971 0.5 -> 0.985 Inexact Rounded pwsx4748 power 0.0971 0.5 -> 0.312 Inexact Rounded pwsx4749 power 0.972 0.5 -> 0.986 Inexact Rounded pwsx4750 power 0.0972 0.5 -> 0.312 Inexact Rounded pwsx4751 power 0.973 0.5 -> 0.986 Inexact Rounded pwsx4752 power 0.0973 0.5 -> 0.312 Inexact Rounded pwsx4753 power 0.974 0.5 -> 0.987 Inexact Rounded pwsx4754 power 0.0974 0.5 -> 0.312 Inexact Rounded pwsx4755 power 0.975 0.5 -> 0.987 Inexact Rounded pwsx4756 power 0.0975 0.5 -> 0.312 Inexact Rounded pwsx4757 power 0.976 0.5 -> 0.988 Inexact Rounded pwsx4758 power 0.0976 0.5 -> 0.312 Inexact Rounded pwsx4759 power 0.977 0.5 -> 0.988 Inexact Rounded pwsx4760 power 0.0977 0.5 -> 0.313 Inexact Rounded pwsx4761 power 0.978 0.5 -> 0.989 Inexact Rounded pwsx4762 power 0.0978 0.5 -> 0.313 Inexact Rounded pwsx4763 power 0.979 0.5 -> 0.989 Inexact Rounded pwsx4764 power 0.0979 0.5 -> 0.313 Inexact Rounded pwsx4765 power 0.981 0.5 -> 0.990 Inexact Rounded pwsx4766 power 0.0981 0.5 -> 0.313 Inexact Rounded pwsx4767 power 0.982 0.5 -> 0.991 Inexact Rounded pwsx4768 power 0.0982 0.5 -> 0.313 Inexact Rounded pwsx4769 power 0.983 0.5 -> 0.991 Inexact Rounded pwsx4770 power 0.0983 0.5 -> 0.314 Inexact Rounded pwsx4771 power 0.984 0.5 -> 0.992 Inexact Rounded pwsx4772 power 0.0984 0.5 -> 0.314 Inexact Rounded pwsx4773 power 0.985 0.5 -> 0.992 Inexact Rounded pwsx4774 power 0.0985 0.5 -> 0.314 Inexact Rounded pwsx4775 power 0.986 0.5 -> 0.993 Inexact Rounded pwsx4776 power 0.0986 0.5 -> 0.314 Inexact Rounded pwsx4777 power 0.987 0.5 -> 0.993 Inexact Rounded pwsx4778 power 0.0987 0.5 -> 0.314 Inexact Rounded pwsx4779 power 0.988 0.5 -> 0.994 Inexact Rounded pwsx4780 power 0.0988 0.5 -> 0.314 Inexact Rounded pwsx4781 power 0.989 0.5 -> 0.994 Inexact Rounded pwsx4782 power 0.0989 0.5 -> 0.314 Inexact Rounded pwsx4783 power 0.991 0.5 -> 0.995 Inexact Rounded pwsx4784 power 0.0991 0.5 -> 0.315 Inexact Rounded pwsx4785 power 0.992 0.5 -> 0.996 Inexact Rounded pwsx4786 power 0.0992 0.5 -> 0.315 Inexact Rounded pwsx4787 power 0.993 0.5 -> 0.996 Inexact Rounded pwsx4788 power 0.0993 0.5 -> 0.315 Inexact Rounded pwsx4789 power 0.994 0.5 -> 0.997 Inexact Rounded pwsx4790 power 0.0994 0.5 -> 0.315 Inexact Rounded pwsx4791 power 0.995 0.5 -> 0.997 Inexact Rounded pwsx4792 power 0.0995 0.5 -> 0.315 Inexact Rounded pwsx4793 power 0.996 0.5 -> 0.998 Inexact Rounded pwsx4794 power 0.0996 0.5 -> 0.316 Inexact Rounded pwsx4795 power 0.997 0.5 -> 0.998 Inexact Rounded pwsx4796 power 0.0997 0.5 -> 0.316 Inexact Rounded pwsx4797 power 0.998 0.5 -> 0.999 Inexact Rounded pwsx4798 power 0.0998 0.5 -> 0.316 Inexact Rounded pwsx4799 power 0.999 0.5 -> 0.999 Inexact Rounded pwsx4800 power 0.0999 0.5 -> 0.316 Inexact Rounded -- A group of precision 4 tests where Hull & Abrham adjustments are -- needed in some cases (both up and down) [see Hull1985b] rounding: half_even maxExponent: 999 minexponent: -999 precision: 4 pwsx5001 power 0.0118 0.5 -> 0.1086 Inexact Rounded pwsx5002 power 0.119 0.5 -> 0.3450 Inexact Rounded pwsx5003 power 0.0119 0.5 -> 0.1091 Inexact Rounded pwsx5004 power 0.121 0.5 -> 0.3479 Inexact Rounded pwsx5005 power 0.0121 0.5 -> 0.1100 Inexact Rounded pwsx5006 power 0.122 0.5 -> 0.3493 Inexact Rounded pwsx5007 power 0.0122 0.5 -> 0.1105 Inexact Rounded pwsx5008 power 0.123 0.5 -> 0.3507 Inexact Rounded pwsx5009 power 0.494 0.5 -> 0.7029 Inexact Rounded pwsx5010 power 0.0669 0.5 -> 0.2587 Inexact Rounded pwsx5011 power 0.9558 0.5 -> 0.9777 Inexact Rounded pwsx5012 power 0.9348 0.5 -> 0.9669 Inexact Rounded pwsx5013 power 0.9345 0.5 -> 0.9667 Inexact Rounded pwsx5014 power 0.09345 0.5 -> 0.3057 Inexact Rounded pwsx5015 power 0.9346 0.5 -> 0.9667 Inexact Rounded pwsx5016 power 0.09346 0.5 -> 0.3057 Inexact Rounded pwsx5017 power 0.9347 0.5 -> 0.9668 Inexact Rounded -- examples from decArith precision: 9 pwsx700 power 0 0.5 -> '0' pwsx701 power -0 0.5 -> '0' pwsx702 power 0.39 0.5 -> 0.624499800 Inexact Rounded pwsx703 power 100 0.5 -> '10.0000000' Inexact Rounded pwsx704 power 1.00 0.5 -> '1.00000000' Inexact Rounded pwsx705 power 7 0.5 -> '2.64575131' Inexact Rounded pwsx706 power 10 0.5 -> 3.16227766 Inexact Rounded -- some one-offs precision: 9 pwsx711 power 0.1 0.5 -> 0.316227766 Inexact Rounded pwsx712 power 0.2 0.5 -> 0.447213595 Inexact Rounded pwsx713 power 0.3 0.5 -> 0.547722558 Inexact Rounded pwsx714 power 0.4 0.5 -> 0.632455532 Inexact Rounded pwsx715 power 0.5 0.5 -> 0.707106781 Inexact Rounded pwsx716 power 0.6 0.5 -> 0.774596669 Inexact Rounded pwsx717 power 0.7 0.5 -> 0.836660027 Inexact Rounded pwsx718 power 0.8 0.5 -> 0.894427191 Inexact Rounded pwsx719 power 0.9 0.5 -> 0.948683298 Inexact Rounded precision: 10 -- note no normalizatoin here pwsx720 power +0.1 0.5 -> 0.3162277660 Inexact Rounded precision: 11 pwsx721 power +0.1 0.5 -> 0.31622776602 Inexact Rounded precision: 12 pwsx722 power +0.1 0.5 -> 0.316227766017 Inexact Rounded precision: 9 pwsx723 power 0.39 0.5 -> 0.624499800 Inexact Rounded precision: 15 pwsx724 power 0.39 0.5 -> 0.624499799839840 Inexact Rounded -- discussion cases precision: 7 pwsx731 power 9 0.5 -> 3.000000 Inexact Rounded pwsx732 power 100 0.5 -> 10.00000 Inexact Rounded pwsx733 power 123 0.5 -> 11.09054 Inexact Rounded pwsx734 power 144 0.5 -> 12.00000 Inexact Rounded pwsx735 power 156 0.5 -> 12.49000 Inexact Rounded pwsx736 power 10000 0.5 -> 100.0000 Inexact Rounded -- values close to overflow (if there were input rounding) maxexponent: 99 minexponent: -99 precision: 5 pwsx760 power 9.9997E+99 0.5 -> 9.9998E+49 Inexact Rounded pwsx761 power 9.9998E+99 0.5 -> 9.9999E+49 Inexact Rounded pwsx762 power 9.9999E+99 0.5 -> 9.9999E+49 Inexact Rounded pwsx763 power 9.99991E+99 0.5 -> 1.0000E+50 Inexact Rounded pwsx764 power 9.99994E+99 0.5 -> 1.0000E+50 Inexact Rounded pwsx765 power 9.99995E+99 0.5 -> 1.0000E+50 Inexact Rounded pwsx766 power 9.99999E+99 0.5 -> 1.0000E+50 Inexact Rounded precision: 9 pwsx770 power 9.9997E+99 0.5 -> 9.99985000E+49 Inexact Rounded pwsx771 power 9.9998E+99 0.5 -> 9.99990000E+49 Inexact Rounded pwsx772 power 9.9999E+99 0.5 -> 9.99995000E+49 Inexact Rounded pwsx773 power 9.99991E+99 0.5 -> 9.99995500E+49 Inexact Rounded pwsx774 power 9.99994E+99 0.5 -> 9.99997000E+49 Inexact Rounded pwsx775 power 9.99995E+99 0.5 -> 9.99997500E+49 Inexact Rounded pwsx776 power 9.99999E+99 0.5 -> 9.99999500E+49 Inexact Rounded precision: 20 pwsx780 power 9.9997E+99 0.5 -> '9.9998499988749831247E+49' Inexact Rounded pwsx781 power 9.9998E+99 0.5 -> '9.9998999994999949999E+49' Inexact Rounded pwsx782 power 9.9999E+99 0.5 -> '9.9999499998749993750E+49' Inexact Rounded pwsx783 power 9.99991E+99 0.5 -> '9.9999549998987495444E+49' Inexact Rounded pwsx784 power 9.99994E+99 0.5 -> '9.9999699999549998650E+49' Inexact Rounded pwsx785 power 9.99995E+99 0.5 -> '9.9999749999687499219E+49' Inexact Rounded pwsx786 power 9.99999E+99 0.5 -> '9.9999949999987499994E+49' Inexact Rounded -- subnormals and underflows [these can only result when eMax is < digits+1] -- Etiny = -(Emax + (precision-1)) -- start with subnormal operands and normal results maxexponent: 9 minexponent: -9 precision: 9 -- Etiny=-17 pwsx800 power 1E-17 0.5 -> 3.16227766E-9 Inexact Rounded pwsx801 power 10E-17 0.5 -> 1.00000000E-8 Inexact Rounded precision: 10 -- Etiny=-18 pwsx802 power 10E-18 0.5 -> 3.162277660E-9 Inexact Rounded pwsx803 power 1E-18 0.5 -> 1.000000000E-9 Inexact Rounded precision: 11 -- Etiny=-19 pwsx804 power 1E-19 0.5 -> 3.162277660E-10 Underflow Subnormal Inexact Rounded -- The next test should be skipped for decNumber pwsx805 power 10E-19 0.5 -> 1.0000000000E-9 Inexact Rounded precision: 12 -- Etiny=-20 pwsx806 power 10E-20 0.5 -> 3.1622776602E-10 Underflow Subnormal Inexact Rounded pwsx807 power 1E-20 0.5 -> 1.0000000000E-10 Underflow Subnormal Inexact Rounded precision: 13 -- Etiny=-21 pwsx808 power 1E-21 0.5 -> 3.1622776602E-11 Underflow Subnormal Inexact Rounded pwsx809 power 10E-21 0.5 -> 1.00000000000E-10 Underflow Subnormal Inexact Rounded precision: 14 -- Etiny=-22 pwsx810 power 1E-21 0.5 -> 3.16227766017E-11 Underflow Subnormal Inexact Rounded pwsx811 power 10E-22 0.5 -> 3.16227766017E-11 Underflow Subnormal Inexact Rounded pwsx812 power 1E-22 0.5 -> 1.00000000000E-11 Underflow Subnormal Inexact Rounded -- special values maxexponent: 999 minexponent: -999 pwsx820 power Inf 0.5 -> Infinity pwsx821 power -Inf 0.5 -> NaN Invalid_operation pwsx822 power NaN 0.5 -> NaN pwsx823 power sNaN 0.5 -> NaN Invalid_operation -- propagating NaNs pwsx824 power sNaN123 0.5 -> NaN123 Invalid_operation pwsx825 power -sNaN321 0.5 -> -NaN321 Invalid_operation pwsx826 power NaN456 0.5 -> NaN456 pwsx827 power -NaN654 0.5 -> -NaN654 pwsx828 power NaN1 0.5 -> NaN1 -- Null test pwsx900 power # 0.5 -> NaN Invalid_operation apd-3.2.1/testdata/quantize.decTest000066400000000000000000001360341450022325000172470ustar00rootroot00000000000000------------------------------------------------------------------------ -- quantize.decTest -- decimal quantize operation -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- Most of the tests here assume a "regular pattern", where the -- sign and coefficient are +1. -- 2004.03.15 Underflow for quantize is suppressed -- 2005.06.08 More extensive tests for 'does not fit' extended: 1 precision: 9 rounding: half_up maxExponent: 999 minexponent: -999 -- sanity checks quax001 quantize 0 1e0 -> 0 quax002 quantize 1 1e0 -> 1 quax003 quantize 0.1 1e+2 -> 0E+2 Inexact Rounded quax005 quantize 0.1 1e+1 -> 0E+1 Inexact Rounded quax006 quantize 0.1 1e0 -> 0 Inexact Rounded quax007 quantize 0.1 1e-1 -> 0.1 quax008 quantize 0.1 1e-2 -> 0.10 quax009 quantize 0.1 1e-3 -> 0.100 quax010 quantize 0.9 1e+2 -> 0E+2 Inexact Rounded quax011 quantize 0.9 1e+1 -> 0E+1 Inexact Rounded quax012 quantize 0.9 1e+0 -> 1 Inexact Rounded quax013 quantize 0.9 1e-1 -> 0.9 quax014 quantize 0.9 1e-2 -> 0.90 quax015 quantize 0.9 1e-3 -> 0.900 -- negatives quax021 quantize -0 1e0 -> -0 quax022 quantize -1 1e0 -> -1 quax023 quantize -0.1 1e+2 -> -0E+2 Inexact Rounded quax025 quantize -0.1 1e+1 -> -0E+1 Inexact Rounded quax026 quantize -0.1 1e0 -> -0 Inexact Rounded quax027 quantize -0.1 1e-1 -> -0.1 quax028 quantize -0.1 1e-2 -> -0.10 quax029 quantize -0.1 1e-3 -> -0.100 quax030 quantize -0.9 1e+2 -> -0E+2 Inexact Rounded quax031 quantize -0.9 1e+1 -> -0E+1 Inexact Rounded quax032 quantize -0.9 1e+0 -> -1 Inexact Rounded quax033 quantize -0.9 1e-1 -> -0.9 quax034 quantize -0.9 1e-2 -> -0.90 quax035 quantize -0.9 1e-3 -> -0.900 quax036 quantize -0.5 1e+2 -> -0E+2 Inexact Rounded quax037 quantize -0.5 1e+1 -> -0E+1 Inexact Rounded quax038 quantize -0.5 1e+0 -> -1 Inexact Rounded quax039 quantize -0.5 1e-1 -> -0.5 quax040 quantize -0.5 1e-2 -> -0.50 quax041 quantize -0.5 1e-3 -> -0.500 quax042 quantize -0.9 1e+2 -> -0E+2 Inexact Rounded quax043 quantize -0.9 1e+1 -> -0E+1 Inexact Rounded quax044 quantize -0.9 1e+0 -> -1 Inexact Rounded quax045 quantize -0.9 1e-1 -> -0.9 quax046 quantize -0.9 1e-2 -> -0.90 quax047 quantize -0.9 1e-3 -> -0.900 -- examples from Specification quax060 quantize 2.17 0.001 -> 2.170 quax061 quantize 2.17 0.01 -> 2.17 quax062 quantize 2.17 0.1 -> 2.2 Inexact Rounded quax063 quantize 2.17 1e+0 -> 2 Inexact Rounded quax064 quantize 2.17 1e+1 -> 0E+1 Inexact Rounded quax065 quantize -Inf Inf -> -Infinity quax066 quantize 2 Inf -> NaN Invalid_operation quax067 quantize -0.1 1 -> -0 Inexact Rounded quax068 quantize -0 1e+5 -> -0E+5 quax069 quantize +35236450.6 1e-2 -> NaN Invalid_operation quax070 quantize -35236450.6 1e-2 -> NaN Invalid_operation quax071 quantize 217 1e-1 -> 217.0 quax072 quantize 217 1e+0 -> 217 quax073 quantize 217 1e+1 -> 2.2E+2 Inexact Rounded quax074 quantize 217 1e+2 -> 2E+2 Inexact Rounded -- general tests .. quax089 quantize 12 1e+4 -> 0E+4 Inexact Rounded quax090 quantize 12 1e+3 -> 0E+3 Inexact Rounded quax091 quantize 12 1e+2 -> 0E+2 Inexact Rounded quax092 quantize 12 1e+1 -> 1E+1 Inexact Rounded quax093 quantize 1.2345 1e-2 -> 1.23 Inexact Rounded quax094 quantize 1.2355 1e-2 -> 1.24 Inexact Rounded quax095 quantize 1.2345 1e-6 -> 1.234500 quax096 quantize 9.9999 1e-2 -> 10.00 Inexact Rounded quax097 quantize 0.0001 1e-2 -> 0.00 Inexact Rounded quax098 quantize 0.001 1e-2 -> 0.00 Inexact Rounded quax099 quantize 0.009 1e-2 -> 0.01 Inexact Rounded quax100 quantize 92 1e+2 -> 1E+2 Inexact Rounded quax101 quantize -1 1e0 -> -1 quax102 quantize -1 1e-1 -> -1.0 quax103 quantize -1 1e-2 -> -1.00 quax104 quantize 0 1e0 -> 0 quax105 quantize 0 1e-1 -> 0.0 quax106 quantize 0 1e-2 -> 0.00 quax107 quantize 0.00 1e0 -> 0 quax108 quantize 0 1e+1 -> 0E+1 quax109 quantize 0 1e+2 -> 0E+2 quax110 quantize +1 1e0 -> 1 quax111 quantize +1 1e-1 -> 1.0 quax112 quantize +1 1e-2 -> 1.00 quax120 quantize 1.04 1e-3 -> 1.040 quax121 quantize 1.04 1e-2 -> 1.04 quax122 quantize 1.04 1e-1 -> 1.0 Inexact Rounded quax123 quantize 1.04 1e0 -> 1 Inexact Rounded quax124 quantize 1.05 1e-3 -> 1.050 quax125 quantize 1.05 1e-2 -> 1.05 quax126 quantize 1.05 1e-1 -> 1.1 Inexact Rounded quax131 quantize 1.05 1e0 -> 1 Inexact Rounded quax132 quantize 1.06 1e-3 -> 1.060 quax133 quantize 1.06 1e-2 -> 1.06 quax134 quantize 1.06 1e-1 -> 1.1 Inexact Rounded quax135 quantize 1.06 1e0 -> 1 Inexact Rounded quax140 quantize -10 1e-2 -> -10.00 quax141 quantize +1 1e-2 -> 1.00 quax142 quantize +10 1e-2 -> 10.00 quax143 quantize 1E+10 1e-2 -> NaN Invalid_operation quax144 quantize 1E-10 1e-2 -> 0.00 Inexact Rounded quax145 quantize 1E-3 1e-2 -> 0.00 Inexact Rounded quax146 quantize 1E-2 1e-2 -> 0.01 quax147 quantize 1E-1 1e-2 -> 0.10 quax148 quantize 0E-10 1e-2 -> 0.00 quax150 quantize 1.0600 1e-5 -> 1.06000 quax151 quantize 1.0600 1e-4 -> 1.0600 quax152 quantize 1.0600 1e-3 -> 1.060 Rounded quax153 quantize 1.0600 1e-2 -> 1.06 Rounded quax154 quantize 1.0600 1e-1 -> 1.1 Inexact Rounded quax155 quantize 1.0600 1e0 -> 1 Inexact Rounded -- base tests with non-1 coefficients quax161 quantize 0 -9e0 -> 0 quax162 quantize 1 -7e0 -> 1 quax163 quantize 0.1 -1e+2 -> 0E+2 Inexact Rounded quax165 quantize 0.1 0e+1 -> 0E+1 Inexact Rounded quax166 quantize 0.1 2e0 -> 0 Inexact Rounded quax167 quantize 0.1 3e-1 -> 0.1 quax168 quantize 0.1 44e-2 -> 0.10 quax169 quantize 0.1 555e-3 -> 0.100 quax170 quantize 0.9 6666e+2 -> 0E+2 Inexact Rounded quax171 quantize 0.9 -777e+1 -> 0E+1 Inexact Rounded quax172 quantize 0.9 -88e+0 -> 1 Inexact Rounded quax173 quantize 0.9 -9e-1 -> 0.9 quax174 quantize 0.9 0e-2 -> 0.90 quax175 quantize 0.9 1.1e-3 -> 0.9000 -- negatives quax181 quantize -0 1.1e0 -> -0.0 quax182 quantize -1 -1e0 -> -1 quax183 quantize -0.1 11e+2 -> -0E+2 Inexact Rounded quax185 quantize -0.1 111e+1 -> -0E+1 Inexact Rounded quax186 quantize -0.1 71e0 -> -0 Inexact Rounded quax187 quantize -0.1 -91e-1 -> -0.1 quax188 quantize -0.1 -.1e-2 -> -0.100 quax189 quantize -0.1 -1e-3 -> -0.100 quax190 quantize -0.9 0e+2 -> -0E+2 Inexact Rounded quax191 quantize -0.9 -0e+1 -> -0E+1 Inexact Rounded quax192 quantize -0.9 -10e+0 -> -1 Inexact Rounded quax193 quantize -0.9 100e-1 -> -0.9 quax194 quantize -0.9 999e-2 -> -0.90 -- +ve exponents .. quax201 quantize -1 1e+0 -> -1 quax202 quantize -1 1e+1 -> -0E+1 Inexact Rounded quax203 quantize -1 1e+2 -> -0E+2 Inexact Rounded quax204 quantize 0 1e+0 -> 0 quax205 quantize 0 1e+1 -> 0E+1 quax206 quantize 0 1e+2 -> 0E+2 quax207 quantize +1 1e+0 -> 1 quax208 quantize +1 1e+1 -> 0E+1 Inexact Rounded quax209 quantize +1 1e+2 -> 0E+2 Inexact Rounded quax220 quantize 1.04 1e+3 -> 0E+3 Inexact Rounded quax221 quantize 1.04 1e+2 -> 0E+2 Inexact Rounded quax222 quantize 1.04 1e+1 -> 0E+1 Inexact Rounded quax223 quantize 1.04 1e+0 -> 1 Inexact Rounded quax224 quantize 1.05 1e+3 -> 0E+3 Inexact Rounded quax225 quantize 1.05 1e+2 -> 0E+2 Inexact Rounded quax226 quantize 1.05 1e+1 -> 0E+1 Inexact Rounded quax227 quantize 1.05 1e+0 -> 1 Inexact Rounded quax228 quantize 1.05 1e+3 -> 0E+3 Inexact Rounded quax229 quantize 1.05 1e+2 -> 0E+2 Inexact Rounded quax230 quantize 1.05 1e+1 -> 0E+1 Inexact Rounded quax231 quantize 1.05 1e+0 -> 1 Inexact Rounded quax232 quantize 1.06 1e+3 -> 0E+3 Inexact Rounded quax233 quantize 1.06 1e+2 -> 0E+2 Inexact Rounded quax234 quantize 1.06 1e+1 -> 0E+1 Inexact Rounded quax235 quantize 1.06 1e+0 -> 1 Inexact Rounded quax240 quantize -10 1e+1 -> -1E+1 Rounded quax241 quantize +1 1e+1 -> 0E+1 Inexact Rounded quax242 quantize +10 1e+1 -> 1E+1 Rounded quax243 quantize 1E+1 1e+1 -> 1E+1 -- underneath this is E+1 quax244 quantize 1E+2 1e+1 -> 1.0E+2 -- underneath this is E+1 quax245 quantize 1E+3 1e+1 -> 1.00E+3 -- underneath this is E+1 quax246 quantize 1E+4 1e+1 -> 1.000E+4 -- underneath this is E+1 quax247 quantize 1E+5 1e+1 -> 1.0000E+5 -- underneath this is E+1 quax248 quantize 1E+6 1e+1 -> 1.00000E+6 -- underneath this is E+1 quax249 quantize 1E+7 1e+1 -> 1.000000E+7 -- underneath this is E+1 quax250 quantize 1E+8 1e+1 -> 1.0000000E+8 -- underneath this is E+1 quax251 quantize 1E+9 1e+1 -> 1.00000000E+9 -- underneath this is E+1 -- next one tries to add 9 zeros quax252 quantize 1E+10 1e+1 -> NaN Invalid_operation quax253 quantize 1E-10 1e+1 -> 0E+1 Inexact Rounded quax254 quantize 1E-2 1e+1 -> 0E+1 Inexact Rounded quax255 quantize 0E-10 1e+1 -> 0E+1 quax256 quantize -0E-10 1e+1 -> -0E+1 quax257 quantize -0E-1 1e+1 -> -0E+1 quax258 quantize -0 1e+1 -> -0E+1 quax259 quantize -0E+1 1e+1 -> -0E+1 quax260 quantize -10 1e+2 -> -0E+2 Inexact Rounded quax261 quantize +1 1e+2 -> 0E+2 Inexact Rounded quax262 quantize +10 1e+2 -> 0E+2 Inexact Rounded quax263 quantize 1E+1 1e+2 -> 0E+2 Inexact Rounded quax264 quantize 1E+2 1e+2 -> 1E+2 quax265 quantize 1E+3 1e+2 -> 1.0E+3 quax266 quantize 1E+4 1e+2 -> 1.00E+4 quax267 quantize 1E+5 1e+2 -> 1.000E+5 quax268 quantize 1E+6 1e+2 -> 1.0000E+6 quax269 quantize 1E+7 1e+2 -> 1.00000E+7 quax270 quantize 1E+8 1e+2 -> 1.000000E+8 quax271 quantize 1E+9 1e+2 -> 1.0000000E+9 quax272 quantize 1E+10 1e+2 -> 1.00000000E+10 quax273 quantize 1E-10 1e+2 -> 0E+2 Inexact Rounded quax274 quantize 1E-2 1e+2 -> 0E+2 Inexact Rounded quax275 quantize 0E-10 1e+2 -> 0E+2 quax280 quantize -10 1e+3 -> -0E+3 Inexact Rounded quax281 quantize +1 1e+3 -> 0E+3 Inexact Rounded quax282 quantize +10 1e+3 -> 0E+3 Inexact Rounded quax283 quantize 1E+1 1e+3 -> 0E+3 Inexact Rounded quax284 quantize 1E+2 1e+3 -> 0E+3 Inexact Rounded quax285 quantize 1E+3 1e+3 -> 1E+3 quax286 quantize 1E+4 1e+3 -> 1.0E+4 quax287 quantize 1E+5 1e+3 -> 1.00E+5 quax288 quantize 1E+6 1e+3 -> 1.000E+6 quax289 quantize 1E+7 1e+3 -> 1.0000E+7 quax290 quantize 1E+8 1e+3 -> 1.00000E+8 quax291 quantize 1E+9 1e+3 -> 1.000000E+9 quax292 quantize 1E+10 1e+3 -> 1.0000000E+10 quax293 quantize 1E-10 1e+3 -> 0E+3 Inexact Rounded quax294 quantize 1E-2 1e+3 -> 0E+3 Inexact Rounded quax295 quantize 0E-10 1e+3 -> 0E+3 -- round up from below [sign wrong in JIT compiler once] quax300 quantize 0.0078 1e-5 -> 0.00780 quax301 quantize 0.0078 1e-4 -> 0.0078 quax302 quantize 0.0078 1e-3 -> 0.008 Inexact Rounded quax303 quantize 0.0078 1e-2 -> 0.01 Inexact Rounded quax304 quantize 0.0078 1e-1 -> 0.0 Inexact Rounded quax305 quantize 0.0078 1e0 -> 0 Inexact Rounded quax306 quantize 0.0078 1e+1 -> 0E+1 Inexact Rounded quax307 quantize 0.0078 1e+2 -> 0E+2 Inexact Rounded quax310 quantize -0.0078 1e-5 -> -0.00780 quax311 quantize -0.0078 1e-4 -> -0.0078 quax312 quantize -0.0078 1e-3 -> -0.008 Inexact Rounded quax313 quantize -0.0078 1e-2 -> -0.01 Inexact Rounded quax314 quantize -0.0078 1e-1 -> -0.0 Inexact Rounded quax315 quantize -0.0078 1e0 -> -0 Inexact Rounded quax316 quantize -0.0078 1e+1 -> -0E+1 Inexact Rounded quax317 quantize -0.0078 1e+2 -> -0E+2 Inexact Rounded quax320 quantize 0.078 1e-5 -> 0.07800 quax321 quantize 0.078 1e-4 -> 0.0780 quax322 quantize 0.078 1e-3 -> 0.078 quax323 quantize 0.078 1e-2 -> 0.08 Inexact Rounded quax324 quantize 0.078 1e-1 -> 0.1 Inexact Rounded quax325 quantize 0.078 1e0 -> 0 Inexact Rounded quax326 quantize 0.078 1e+1 -> 0E+1 Inexact Rounded quax327 quantize 0.078 1e+2 -> 0E+2 Inexact Rounded quax330 quantize -0.078 1e-5 -> -0.07800 quax331 quantize -0.078 1e-4 -> -0.0780 quax332 quantize -0.078 1e-3 -> -0.078 quax333 quantize -0.078 1e-2 -> -0.08 Inexact Rounded quax334 quantize -0.078 1e-1 -> -0.1 Inexact Rounded quax335 quantize -0.078 1e0 -> -0 Inexact Rounded quax336 quantize -0.078 1e+1 -> -0E+1 Inexact Rounded quax337 quantize -0.078 1e+2 -> -0E+2 Inexact Rounded quax340 quantize 0.78 1e-5 -> 0.78000 quax341 quantize 0.78 1e-4 -> 0.7800 quax342 quantize 0.78 1e-3 -> 0.780 quax343 quantize 0.78 1e-2 -> 0.78 quax344 quantize 0.78 1e-1 -> 0.8 Inexact Rounded quax345 quantize 0.78 1e0 -> 1 Inexact Rounded quax346 quantize 0.78 1e+1 -> 0E+1 Inexact Rounded quax347 quantize 0.78 1e+2 -> 0E+2 Inexact Rounded quax350 quantize -0.78 1e-5 -> -0.78000 quax351 quantize -0.78 1e-4 -> -0.7800 quax352 quantize -0.78 1e-3 -> -0.780 quax353 quantize -0.78 1e-2 -> -0.78 quax354 quantize -0.78 1e-1 -> -0.8 Inexact Rounded quax355 quantize -0.78 1e0 -> -1 Inexact Rounded quax356 quantize -0.78 1e+1 -> -0E+1 Inexact Rounded quax357 quantize -0.78 1e+2 -> -0E+2 Inexact Rounded quax360 quantize 7.8 1e-5 -> 7.80000 quax361 quantize 7.8 1e-4 -> 7.8000 quax362 quantize 7.8 1e-3 -> 7.800 quax363 quantize 7.8 1e-2 -> 7.80 quax364 quantize 7.8 1e-1 -> 7.8 quax365 quantize 7.8 1e0 -> 8 Inexact Rounded quax366 quantize 7.8 1e+1 -> 1E+1 Inexact Rounded quax367 quantize 7.8 1e+2 -> 0E+2 Inexact Rounded quax368 quantize 7.8 1e+3 -> 0E+3 Inexact Rounded quax370 quantize -7.8 1e-5 -> -7.80000 quax371 quantize -7.8 1e-4 -> -7.8000 quax372 quantize -7.8 1e-3 -> -7.800 quax373 quantize -7.8 1e-2 -> -7.80 quax374 quantize -7.8 1e-1 -> -7.8 quax375 quantize -7.8 1e0 -> -8 Inexact Rounded quax376 quantize -7.8 1e+1 -> -1E+1 Inexact Rounded quax377 quantize -7.8 1e+2 -> -0E+2 Inexact Rounded quax378 quantize -7.8 1e+3 -> -0E+3 Inexact Rounded -- some individuals precision: 9 quax380 quantize 352364.506 1e-2 -> 352364.51 Inexact Rounded quax381 quantize 3523645.06 1e-2 -> 3523645.06 quax382 quantize 35236450.6 1e-2 -> NaN Invalid_operation quax383 quantize 352364506 1e-2 -> NaN Invalid_operation quax384 quantize -352364.506 1e-2 -> -352364.51 Inexact Rounded quax385 quantize -3523645.06 1e-2 -> -3523645.06 quax386 quantize -35236450.6 1e-2 -> NaN Invalid_operation quax387 quantize -352364506 1e-2 -> NaN Invalid_operation rounding: down quax389 quantize 35236450.6 1e-2 -> NaN Invalid_operation -- ? should that one instead have been: -- quax389 quantize 35236450.6 1e-2 -> NaN Invalid_operation rounding: half_up -- and a few more from e-mail discussions precision: 7 quax391 quantize 12.34567 1e-3 -> 12.346 Inexact Rounded quax392 quantize 123.4567 1e-3 -> 123.457 Inexact Rounded quax393 quantize 1234.567 1e-3 -> 1234.567 quax394 quantize 12345.67 1e-3 -> NaN Invalid_operation quax395 quantize 123456.7 1e-3 -> NaN Invalid_operation quax396 quantize 1234567. 1e-3 -> NaN Invalid_operation -- some 9999 round-up cases precision: 9 quax400 quantize 9.999 1e-5 -> 9.99900 quax401 quantize 9.999 1e-4 -> 9.9990 quax402 quantize 9.999 1e-3 -> 9.999 quax403 quantize 9.999 1e-2 -> 10.00 Inexact Rounded quax404 quantize 9.999 1e-1 -> 10.0 Inexact Rounded quax405 quantize 9.999 1e0 -> 10 Inexact Rounded quax406 quantize 9.999 1e1 -> 1E+1 Inexact Rounded quax407 quantize 9.999 1e2 -> 0E+2 Inexact Rounded quax410 quantize 0.999 1e-5 -> 0.99900 quax411 quantize 0.999 1e-4 -> 0.9990 quax412 quantize 0.999 1e-3 -> 0.999 quax413 quantize 0.999 1e-2 -> 1.00 Inexact Rounded quax414 quantize 0.999 1e-1 -> 1.0 Inexact Rounded quax415 quantize 0.999 1e0 -> 1 Inexact Rounded quax416 quantize 0.999 1e1 -> 0E+1 Inexact Rounded quax420 quantize 0.0999 1e-5 -> 0.09990 quax421 quantize 0.0999 1e-4 -> 0.0999 quax422 quantize 0.0999 1e-3 -> 0.100 Inexact Rounded quax423 quantize 0.0999 1e-2 -> 0.10 Inexact Rounded quax424 quantize 0.0999 1e-1 -> 0.1 Inexact Rounded quax425 quantize 0.0999 1e0 -> 0 Inexact Rounded quax426 quantize 0.0999 1e1 -> 0E+1 Inexact Rounded quax430 quantize 0.00999 1e-5 -> 0.00999 quax431 quantize 0.00999 1e-4 -> 0.0100 Inexact Rounded quax432 quantize 0.00999 1e-3 -> 0.010 Inexact Rounded quax433 quantize 0.00999 1e-2 -> 0.01 Inexact Rounded quax434 quantize 0.00999 1e-1 -> 0.0 Inexact Rounded quax435 quantize 0.00999 1e0 -> 0 Inexact Rounded quax436 quantize 0.00999 1e1 -> 0E+1 Inexact Rounded quax440 quantize 0.000999 1e-5 -> 0.00100 Inexact Rounded quax441 quantize 0.000999 1e-4 -> 0.0010 Inexact Rounded quax442 quantize 0.000999 1e-3 -> 0.001 Inexact Rounded quax443 quantize 0.000999 1e-2 -> 0.00 Inexact Rounded quax444 quantize 0.000999 1e-1 -> 0.0 Inexact Rounded quax445 quantize 0.000999 1e0 -> 0 Inexact Rounded quax446 quantize 0.000999 1e1 -> 0E+1 Inexact Rounded precision: 8 quax449 quantize 9.999E-15 1e-23 -> NaN Invalid_operation quax450 quantize 9.999E-15 1e-22 -> 9.9990000E-15 quax451 quantize 9.999E-15 1e-21 -> 9.999000E-15 quax452 quantize 9.999E-15 1e-20 -> 9.99900E-15 quax453 quantize 9.999E-15 1e-19 -> 9.9990E-15 quax454 quantize 9.999E-15 1e-18 -> 9.999E-15 quax455 quantize 9.999E-15 1e-17 -> 1.000E-14 Inexact Rounded quax456 quantize 9.999E-15 1e-16 -> 1.00E-14 Inexact Rounded quax457 quantize 9.999E-15 1e-15 -> 1.0E-14 Inexact Rounded quax458 quantize 9.999E-15 1e-14 -> 1E-14 Inexact Rounded quax459 quantize 9.999E-15 1e-13 -> 0E-13 Inexact Rounded quax460 quantize 9.999E-15 1e-12 -> 0E-12 Inexact Rounded quax461 quantize 9.999E-15 1e-11 -> 0E-11 Inexact Rounded quax462 quantize 9.999E-15 1e-10 -> 0E-10 Inexact Rounded quax463 quantize 9.999E-15 1e-9 -> 0E-9 Inexact Rounded quax464 quantize 9.999E-15 1e-8 -> 0E-8 Inexact Rounded quax465 quantize 9.999E-15 1e-7 -> 0E-7 Inexact Rounded quax466 quantize 9.999E-15 1e-6 -> 0.000000 Inexact Rounded quax467 quantize 9.999E-15 1e-5 -> 0.00000 Inexact Rounded quax468 quantize 9.999E-15 1e-4 -> 0.0000 Inexact Rounded quax469 quantize 9.999E-15 1e-3 -> 0.000 Inexact Rounded quax470 quantize 9.999E-15 1e-2 -> 0.00 Inexact Rounded quax471 quantize 9.999E-15 1e-1 -> 0.0 Inexact Rounded quax472 quantize 9.999E-15 1e0 -> 0 Inexact Rounded quax473 quantize 9.999E-15 1e1 -> 0E+1 Inexact Rounded precision: 7 quax900 quantize 9.999E-15 1e-22 -> NaN Invalid_operation quax901 quantize 9.999E-15 1e-21 -> 9.999000E-15 quax902 quantize 9.999E-15 1e-20 -> 9.99900E-15 quax903 quantize 9.999E-15 1e-19 -> 9.9990E-15 quax904 quantize 9.999E-15 1e-18 -> 9.999E-15 quax905 quantize 9.999E-15 1e-17 -> 1.000E-14 Inexact Rounded quax906 quantize 9.999E-15 1e-16 -> 1.00E-14 Inexact Rounded quax907 quantize 9.999E-15 1e-15 -> 1.0E-14 Inexact Rounded quax908 quantize 9.999E-15 1e-14 -> 1E-14 Inexact Rounded quax909 quantize 9.999E-15 1e-13 -> 0E-13 Inexact Rounded quax910 quantize 9.999E-15 1e-12 -> 0E-12 Inexact Rounded quax911 quantize 9.999E-15 1e-11 -> 0E-11 Inexact Rounded quax912 quantize 9.999E-15 1e-10 -> 0E-10 Inexact Rounded quax913 quantize 9.999E-15 1e-9 -> 0E-9 Inexact Rounded quax914 quantize 9.999E-15 1e-8 -> 0E-8 Inexact Rounded quax915 quantize 9.999E-15 1e-7 -> 0E-7 Inexact Rounded quax916 quantize 9.999E-15 1e-6 -> 0.000000 Inexact Rounded quax917 quantize 9.999E-15 1e-5 -> 0.00000 Inexact Rounded quax918 quantize 9.999E-15 1e-4 -> 0.0000 Inexact Rounded quax919 quantize 9.999E-15 1e-3 -> 0.000 Inexact Rounded quax920 quantize 9.999E-15 1e-2 -> 0.00 Inexact Rounded quax921 quantize 9.999E-15 1e-1 -> 0.0 Inexact Rounded quax922 quantize 9.999E-15 1e0 -> 0 Inexact Rounded quax923 quantize 9.999E-15 1e1 -> 0E+1 Inexact Rounded precision: 6 quax930 quantize 9.999E-15 1e-22 -> NaN Invalid_operation quax931 quantize 9.999E-15 1e-21 -> NaN Invalid_operation quax932 quantize 9.999E-15 1e-20 -> 9.99900E-15 quax933 quantize 9.999E-15 1e-19 -> 9.9990E-15 quax934 quantize 9.999E-15 1e-18 -> 9.999E-15 quax935 quantize 9.999E-15 1e-17 -> 1.000E-14 Inexact Rounded quax936 quantize 9.999E-15 1e-16 -> 1.00E-14 Inexact Rounded quax937 quantize 9.999E-15 1e-15 -> 1.0E-14 Inexact Rounded quax938 quantize 9.999E-15 1e-14 -> 1E-14 Inexact Rounded quax939 quantize 9.999E-15 1e-13 -> 0E-13 Inexact Rounded quax940 quantize 9.999E-15 1e-12 -> 0E-12 Inexact Rounded quax941 quantize 9.999E-15 1e-11 -> 0E-11 Inexact Rounded quax942 quantize 9.999E-15 1e-10 -> 0E-10 Inexact Rounded quax943 quantize 9.999E-15 1e-9 -> 0E-9 Inexact Rounded quax944 quantize 9.999E-15 1e-8 -> 0E-8 Inexact Rounded quax945 quantize 9.999E-15 1e-7 -> 0E-7 Inexact Rounded quax946 quantize 9.999E-15 1e-6 -> 0.000000 Inexact Rounded quax947 quantize 9.999E-15 1e-5 -> 0.00000 Inexact Rounded quax948 quantize 9.999E-15 1e-4 -> 0.0000 Inexact Rounded quax949 quantize 9.999E-15 1e-3 -> 0.000 Inexact Rounded quax950 quantize 9.999E-15 1e-2 -> 0.00 Inexact Rounded quax951 quantize 9.999E-15 1e-1 -> 0.0 Inexact Rounded quax952 quantize 9.999E-15 1e0 -> 0 Inexact Rounded quax953 quantize 9.999E-15 1e1 -> 0E+1 Inexact Rounded precision: 3 quax960 quantize 9.999E-15 1e-22 -> NaN Invalid_operation quax961 quantize 9.999E-15 1e-21 -> NaN Invalid_operation quax962 quantize 9.999E-15 1e-20 -> NaN Invalid_operation quax963 quantize 9.999E-15 1e-19 -> NaN Invalid_operation quax964 quantize 9.999E-15 1e-18 -> NaN Invalid_operation quax965 quantize 9.999E-15 1e-17 -> NaN Invalid_operation quax966 quantize 9.999E-15 1e-16 -> 1.00E-14 Inexact Rounded quax967 quantize 9.999E-15 1e-15 -> 1.0E-14 Inexact Rounded quax968 quantize 9.999E-15 1e-14 -> 1E-14 Inexact Rounded quax969 quantize 9.999E-15 1e-13 -> 0E-13 Inexact Rounded quax970 quantize 9.999E-15 1e-12 -> 0E-12 Inexact Rounded quax971 quantize 9.999E-15 1e-11 -> 0E-11 Inexact Rounded quax972 quantize 9.999E-15 1e-10 -> 0E-10 Inexact Rounded quax973 quantize 9.999E-15 1e-9 -> 0E-9 Inexact Rounded quax974 quantize 9.999E-15 1e-8 -> 0E-8 Inexact Rounded quax975 quantize 9.999E-15 1e-7 -> 0E-7 Inexact Rounded quax976 quantize 9.999E-15 1e-6 -> 0.000000 Inexact Rounded quax977 quantize 9.999E-15 1e-5 -> 0.00000 Inexact Rounded quax978 quantize 9.999E-15 1e-4 -> 0.0000 Inexact Rounded quax979 quantize 9.999E-15 1e-3 -> 0.000 Inexact Rounded quax980 quantize 9.999E-15 1e-2 -> 0.00 Inexact Rounded quax981 quantize 9.999E-15 1e-1 -> 0.0 Inexact Rounded quax982 quantize 9.999E-15 1e0 -> 0 Inexact Rounded quax983 quantize 9.999E-15 1e1 -> 0E+1 Inexact Rounded -- Fung Lee's case & similar precision: 3 quax1001 quantize 0.000 0.001 -> 0.000 quax1002 quantize 0.001 0.001 -> 0.001 quax1003 quantize 0.0012 0.001 -> 0.001 Inexact Rounded quax1004 quantize 0.0018 0.001 -> 0.002 Inexact Rounded quax1005 quantize 0.501 0.001 -> 0.501 quax1006 quantize 0.5012 0.001 -> 0.501 Inexact Rounded quax1007 quantize 0.5018 0.001 -> 0.502 Inexact Rounded quax1008 quantize 0.999 0.001 -> 0.999 quax1009 quantize 0.9992 0.001 -> 0.999 Inexact Rounded quax1010 quantize 0.9998 0.001 -> NaN Invalid_operation quax1011 quantize 1.0001 0.001 -> NaN Invalid_operation quax1012 quantize 1.0051 0.001 -> NaN Invalid_operation quax1013 quantize 1.0551 0.001 -> NaN Invalid_operation quax1014 quantize 1.5551 0.001 -> NaN Invalid_operation quax1015 quantize 1.9999 0.001 -> NaN Invalid_operation -- long operand checks [rhs checks removed] maxexponent: 999 minexponent: -999 precision: 9 quax481 quantize 12345678000 1e+3 -> 1.2345678E+10 Rounded quax482 quantize 1234567800 1e+1 -> 1.23456780E+9 Rounded quax483 quantize 1234567890 1e+1 -> 1.23456789E+9 Rounded quax484 quantize 1234567891 1e+1 -> 1.23456789E+9 Inexact Rounded quax485 quantize 12345678901 1e+2 -> 1.23456789E+10 Inexact Rounded quax486 quantize 1234567896 1e+1 -> 1.23456790E+9 Inexact Rounded -- a potential double-round quax487 quantize 1234.987643 1e-4 -> 1234.9876 Inexact Rounded quax488 quantize 1234.987647 1e-4 -> 1234.9876 Inexact Rounded precision: 15 quax491 quantize 12345678000 1e+3 -> 1.2345678E+10 Rounded quax492 quantize 1234567800 1e+1 -> 1.23456780E+9 Rounded quax493 quantize 1234567890 1e+1 -> 1.23456789E+9 Rounded quax494 quantize 1234567891 1e+1 -> 1.23456789E+9 Inexact Rounded quax495 quantize 12345678901 1e+2 -> 1.23456789E+10 Inexact Rounded quax496 quantize 1234567896 1e+1 -> 1.23456790E+9 Inexact Rounded quax497 quantize 1234.987643 1e-4 -> 1234.9876 Inexact Rounded quax498 quantize 1234.987647 1e-4 -> 1234.9876 Inexact Rounded -- Zeros quax500 quantize 0 1e1 -> 0E+1 quax501 quantize 0 1e0 -> 0 quax502 quantize 0 1e-1 -> 0.0 quax503 quantize 0.0 1e-1 -> 0.0 quax504 quantize 0.0 1e0 -> 0 quax505 quantize 0.0 1e+1 -> 0E+1 quax506 quantize 0E+1 1e-1 -> 0.0 quax507 quantize 0E+1 1e0 -> 0 quax508 quantize 0E+1 1e+1 -> 0E+1 quax509 quantize -0 1e1 -> -0E+1 quax510 quantize -0 1e0 -> -0 quax511 quantize -0 1e-1 -> -0.0 quax512 quantize -0.0 1e-1 -> -0.0 quax513 quantize -0.0 1e0 -> -0 quax514 quantize -0.0 1e+1 -> -0E+1 quax515 quantize -0E+1 1e-1 -> -0.0 quax516 quantize -0E+1 1e0 -> -0 quax517 quantize -0E+1 1e+1 -> -0E+1 -- Suspicious RHS values maxexponent: 999999999 minexponent: -999999999 precision: 15 quax520 quantize 1.234 1e999999000 -> 0E+999999000 Inexact Rounded quax521 quantize 123.456 1e999999000 -> 0E+999999000 Inexact Rounded quax522 quantize 1.234 1e999999999 -> 0E+999999999 Inexact Rounded quax523 quantize 123.456 1e999999999 -> 0E+999999999 Inexact Rounded quax524 quantize 123.456 1e1000000000 -> NaN Invalid_operation quax525 quantize 123.456 1e12345678903 -> NaN Invalid_operation -- next four are "won't fit" overflows quax526 quantize 1.234 1e-999999000 -> NaN Invalid_operation quax527 quantize 123.456 1e-999999000 -> NaN Invalid_operation quax528 quantize 1.234 1e-999999999 -> NaN Invalid_operation quax529 quantize 123.456 1e-999999999 -> NaN Invalid_operation quax530 quantize 123.456 1e-1000000014 -> NaN Invalid_operation quax531 quantize 123.456 1e-12345678903 -> NaN Invalid_operation maxexponent: 999 minexponent: -999 precision: 15 quax532 quantize 1.234E+999 1e999 -> 1E+999 Inexact Rounded quax533 quantize 1.234E+998 1e999 -> 0E+999 Inexact Rounded quax534 quantize 1.234 1e999 -> 0E+999 Inexact Rounded quax535 quantize 1.234 1e1000 -> NaN Invalid_operation quax536 quantize 1.234 1e5000 -> NaN Invalid_operation quax537 quantize 0 1e-999 -> 0E-999 -- next two are "won't fit" overflows quax538 quantize 1.234 1e-999 -> NaN Invalid_operation quax539 quantize 1.234 1e-1000 -> NaN Invalid_operation quax540 quantize 1.234 1e-5000 -> NaN Invalid_operation -- [more below] -- check bounds (lhs maybe out of range for destination, etc.) precision: 7 quax541 quantize 1E+999 1e+999 -> 1E+999 quax542 quantize 1E+1000 1e+999 -> NaN Invalid_operation quax543 quantize 1E+999 1e+1000 -> NaN Invalid_operation quax544 quantize 1E-999 1e-999 -> 1E-999 quax545 quantize 1E-1000 1e-999 -> 0E-999 Inexact Rounded quax546 quantize 1E-999 1e-1000 -> 1.0E-999 quax547 quantize 1E-1005 1e-999 -> 0E-999 Inexact Rounded quax548 quantize 1E-1006 1e-999 -> 0E-999 Inexact Rounded quax549 quantize 1E-1007 1e-999 -> 0E-999 Inexact Rounded quax550 quantize 1E-998 1e-1005 -> NaN Invalid_operation -- won't fit quax551 quantize 1E-999 1e-1005 -> 1.000000E-999 quax552 quantize 1E-1000 1e-1005 -> 1.00000E-1000 Subnormal quax553 quantize 1E-999 1e-1006 -> NaN Invalid_operation quax554 quantize 1E-999 1e-1007 -> NaN Invalid_operation -- related subnormal rounding quax555 quantize 1.666666E-999 1e-1005 -> 1.666666E-999 quax556 quantize 1.666666E-1000 1e-1005 -> 1.66667E-1000 Subnormal Inexact Rounded quax557 quantize 1.666666E-1001 1e-1005 -> 1.6667E-1001 Subnormal Inexact Rounded quax558 quantize 1.666666E-1002 1e-1005 -> 1.667E-1002 Subnormal Inexact Rounded quax559 quantize 1.666666E-1003 1e-1005 -> 1.67E-1003 Subnormal Inexact Rounded quax560 quantize 1.666666E-1004 1e-1005 -> 1.7E-1004 Subnormal Inexact Rounded quax561 quantize 1.666666E-1005 1e-1005 -> 2E-1005 Subnormal Inexact Rounded quax562 quantize 1.666666E-1006 1e-1005 -> 0E-1005 Inexact Rounded quax563 quantize 1.666666E-1007 1e-1005 -> 0E-1005 Inexact Rounded -- Specials quax580 quantize Inf -Inf -> Infinity quax581 quantize Inf 1e-1000 -> NaN Invalid_operation quax582 quantize Inf 1e-1 -> NaN Invalid_operation quax583 quantize Inf 1e0 -> NaN Invalid_operation quax584 quantize Inf 1e1 -> NaN Invalid_operation quax585 quantize Inf 1e1000 -> NaN Invalid_operation quax586 quantize Inf Inf -> Infinity quax587 quantize -1000 Inf -> NaN Invalid_operation quax588 quantize -Inf Inf -> -Infinity quax589 quantize -1 Inf -> NaN Invalid_operation quax590 quantize 0 Inf -> NaN Invalid_operation quax591 quantize 1 Inf -> NaN Invalid_operation quax592 quantize 1000 Inf -> NaN Invalid_operation quax593 quantize Inf Inf -> Infinity quax594 quantize Inf 1e-0 -> NaN Invalid_operation quax595 quantize -0 Inf -> NaN Invalid_operation quax600 quantize -Inf -Inf -> -Infinity quax601 quantize -Inf 1e-1000 -> NaN Invalid_operation quax602 quantize -Inf 1e-1 -> NaN Invalid_operation quax603 quantize -Inf 1e0 -> NaN Invalid_operation quax604 quantize -Inf 1e1 -> NaN Invalid_operation quax605 quantize -Inf 1e1000 -> NaN Invalid_operation quax606 quantize -Inf Inf -> -Infinity quax607 quantize -1000 Inf -> NaN Invalid_operation quax608 quantize -Inf -Inf -> -Infinity quax609 quantize -1 -Inf -> NaN Invalid_operation quax610 quantize 0 -Inf -> NaN Invalid_operation quax611 quantize 1 -Inf -> NaN Invalid_operation quax612 quantize 1000 -Inf -> NaN Invalid_operation quax613 quantize Inf -Inf -> Infinity quax614 quantize -Inf 1e-0 -> NaN Invalid_operation quax615 quantize -0 -Inf -> NaN Invalid_operation quax621 quantize NaN -Inf -> NaN quax622 quantize NaN 1e-1000 -> NaN quax623 quantize NaN 1e-1 -> NaN quax624 quantize NaN 1e0 -> NaN quax625 quantize NaN 1e1 -> NaN quax626 quantize NaN 1e1000 -> NaN quax627 quantize NaN Inf -> NaN quax628 quantize NaN NaN -> NaN quax629 quantize -Inf NaN -> NaN quax630 quantize -1000 NaN -> NaN quax631 quantize -1 NaN -> NaN quax632 quantize 0 NaN -> NaN quax633 quantize 1 NaN -> NaN quax634 quantize 1000 NaN -> NaN quax635 quantize Inf NaN -> NaN quax636 quantize NaN 1e-0 -> NaN quax637 quantize -0 NaN -> NaN quax641 quantize sNaN -Inf -> NaN Invalid_operation quax642 quantize sNaN 1e-1000 -> NaN Invalid_operation quax643 quantize sNaN 1e-1 -> NaN Invalid_operation quax644 quantize sNaN 1e0 -> NaN Invalid_operation quax645 quantize sNaN 1e1 -> NaN Invalid_operation quax646 quantize sNaN 1e1000 -> NaN Invalid_operation quax647 quantize sNaN NaN -> NaN Invalid_operation quax648 quantize sNaN sNaN -> NaN Invalid_operation quax649 quantize NaN sNaN -> NaN Invalid_operation quax650 quantize -Inf sNaN -> NaN Invalid_operation quax651 quantize -1000 sNaN -> NaN Invalid_operation quax652 quantize -1 sNaN -> NaN Invalid_operation quax653 quantize 0 sNaN -> NaN Invalid_operation quax654 quantize 1 sNaN -> NaN Invalid_operation quax655 quantize 1000 sNaN -> NaN Invalid_operation quax656 quantize Inf sNaN -> NaN Invalid_operation quax657 quantize NaN sNaN -> NaN Invalid_operation quax658 quantize sNaN 1e-0 -> NaN Invalid_operation quax659 quantize -0 sNaN -> NaN Invalid_operation -- propagating NaNs quax661 quantize NaN9 -Inf -> NaN9 quax662 quantize NaN8 919 -> NaN8 quax663 quantize NaN71 Inf -> NaN71 quax664 quantize NaN6 NaN5 -> NaN6 quax665 quantize -Inf NaN4 -> NaN4 quax666 quantize -919 NaN31 -> NaN31 quax667 quantize Inf NaN2 -> NaN2 quax671 quantize sNaN99 -Inf -> NaN99 Invalid_operation quax672 quantize sNaN98 -11 -> NaN98 Invalid_operation quax673 quantize sNaN97 NaN -> NaN97 Invalid_operation quax674 quantize sNaN16 sNaN94 -> NaN16 Invalid_operation quax675 quantize NaN95 sNaN93 -> NaN93 Invalid_operation quax676 quantize -Inf sNaN92 -> NaN92 Invalid_operation quax677 quantize 088 sNaN91 -> NaN91 Invalid_operation quax678 quantize Inf sNaN90 -> NaN90 Invalid_operation quax679 quantize NaN sNaN88 -> NaN88 Invalid_operation quax681 quantize -NaN9 -Inf -> -NaN9 quax682 quantize -NaN8 919 -> -NaN8 quax683 quantize -NaN71 Inf -> -NaN71 quax684 quantize -NaN6 -NaN5 -> -NaN6 quax685 quantize -Inf -NaN4 -> -NaN4 quax686 quantize -919 -NaN31 -> -NaN31 quax687 quantize Inf -NaN2 -> -NaN2 quax691 quantize -sNaN99 -Inf -> -NaN99 Invalid_operation quax692 quantize -sNaN98 -11 -> -NaN98 Invalid_operation quax693 quantize -sNaN97 NaN -> -NaN97 Invalid_operation quax694 quantize -sNaN16 sNaN94 -> -NaN16 Invalid_operation quax695 quantize -NaN95 -sNaN93 -> -NaN93 Invalid_operation quax696 quantize -Inf -sNaN92 -> -NaN92 Invalid_operation quax697 quantize 088 -sNaN91 -> -NaN91 Invalid_operation quax698 quantize Inf -sNaN90 -> -NaN90 Invalid_operation quax699 quantize NaN -sNaN88 -> -NaN88 Invalid_operation -- subnormals and underflow precision: 4 maxexponent: 999 minexponent: -999 quax710 quantize 1.00E-999 1e-999 -> 1E-999 Rounded quax711 quantize 0.1E-999 2e-1000 -> 1E-1000 Subnormal quax712 quantize 0.10E-999 3e-1000 -> 1E-1000 Subnormal Rounded quax713 quantize 0.100E-999 4e-1000 -> 1E-1000 Subnormal Rounded quax714 quantize 0.01E-999 5e-1001 -> 1E-1001 Subnormal -- next is rounded to Emin quax715 quantize 0.999E-999 1e-999 -> 1E-999 Inexact Rounded quax716 quantize 0.099E-999 10e-1000 -> 1E-1000 Inexact Rounded Subnormal quax717 quantize 0.009E-999 1e-1001 -> 1E-1001 Inexact Rounded Subnormal quax718 quantize 0.001E-999 1e-1001 -> 0E-1001 Inexact Rounded quax719 quantize 0.0009E-999 1e-1001 -> 0E-1001 Inexact Rounded quax720 quantize 0.0001E-999 1e-1001 -> 0E-1001 Inexact Rounded quax730 quantize -1.00E-999 1e-999 -> -1E-999 Rounded quax731 quantize -0.1E-999 1e-999 -> -0E-999 Rounded Inexact quax732 quantize -0.10E-999 1e-999 -> -0E-999 Rounded Inexact quax733 quantize -0.100E-999 1e-999 -> -0E-999 Rounded Inexact quax734 quantize -0.01E-999 1e-999 -> -0E-999 Inexact Rounded -- next is rounded to Emin quax735 quantize -0.999E-999 90e-999 -> -1E-999 Inexact Rounded quax736 quantize -0.099E-999 -1e-999 -> -0E-999 Inexact Rounded quax737 quantize -0.009E-999 -1e-999 -> -0E-999 Inexact Rounded quax738 quantize -0.001E-999 -0e-999 -> -0E-999 Inexact Rounded quax739 quantize -0.0001E-999 0e-999 -> -0E-999 Inexact Rounded quax740 quantize -1.00E-999 1e-1000 -> -1.0E-999 Rounded quax741 quantize -0.1E-999 1e-1000 -> -1E-1000 Subnormal quax742 quantize -0.10E-999 1e-1000 -> -1E-1000 Subnormal Rounded quax743 quantize -0.100E-999 1e-1000 -> -1E-1000 Subnormal Rounded quax744 quantize -0.01E-999 1e-1000 -> -0E-1000 Inexact Rounded -- next is rounded to Emin quax745 quantize -0.999E-999 1e-1000 -> -1.0E-999 Inexact Rounded quax746 quantize -0.099E-999 1e-1000 -> -1E-1000 Inexact Rounded Subnormal quax747 quantize -0.009E-999 1e-1000 -> -0E-1000 Inexact Rounded quax748 quantize -0.001E-999 1e-1000 -> -0E-1000 Inexact Rounded quax749 quantize -0.0001E-999 1e-1000 -> -0E-1000 Inexact Rounded quax750 quantize -1.00E-999 1e-1001 -> -1.00E-999 quax751 quantize -0.1E-999 1e-1001 -> -1.0E-1000 Subnormal quax752 quantize -0.10E-999 1e-1001 -> -1.0E-1000 Subnormal quax753 quantize -0.100E-999 1e-1001 -> -1.0E-1000 Subnormal Rounded quax754 quantize -0.01E-999 1e-1001 -> -1E-1001 Subnormal -- next is rounded to Emin quax755 quantize -0.999E-999 1e-1001 -> -1.00E-999 Inexact Rounded quax756 quantize -0.099E-999 1e-1001 -> -1.0E-1000 Inexact Rounded Subnormal quax757 quantize -0.009E-999 1e-1001 -> -1E-1001 Inexact Rounded Subnormal quax758 quantize -0.001E-999 1e-1001 -> -0E-1001 Inexact Rounded quax759 quantize -0.0001E-999 1e-1001 -> -0E-1001 Inexact Rounded quax760 quantize -1.00E-999 1e-1002 -> -1.000E-999 quax761 quantize -0.1E-999 1e-1002 -> -1.00E-1000 Subnormal quax762 quantize -0.10E-999 1e-1002 -> -1.00E-1000 Subnormal quax763 quantize -0.100E-999 1e-1002 -> -1.00E-1000 Subnormal quax764 quantize -0.01E-999 1e-1002 -> -1.0E-1001 Subnormal quax765 quantize -0.999E-999 1e-1002 -> -9.99E-1000 Subnormal quax766 quantize -0.099E-999 1e-1002 -> -9.9E-1001 Subnormal quax767 quantize -0.009E-999 1e-1002 -> -9E-1002 Subnormal quax768 quantize -0.001E-999 1e-1002 -> -1E-1002 Subnormal quax769 quantize -0.0001E-999 1e-1002 -> -0E-1002 Inexact Rounded -- rhs must be no less than Etiny quax770 quantize -1.00E-999 1e-1003 -> NaN Invalid_operation quax771 quantize -0.1E-999 1e-1003 -> NaN Invalid_operation quax772 quantize -0.10E-999 1e-1003 -> NaN Invalid_operation quax773 quantize -0.100E-999 1e-1003 -> NaN Invalid_operation quax774 quantize -0.01E-999 1e-1003 -> NaN Invalid_operation quax775 quantize -0.999E-999 1e-1003 -> NaN Invalid_operation quax776 quantize -0.099E-999 1e-1003 -> NaN Invalid_operation quax777 quantize -0.009E-999 1e-1003 -> NaN Invalid_operation quax778 quantize -0.001E-999 1e-1003 -> NaN Invalid_operation quax779 quantize -0.0001E-999 1e-1003 -> NaN Invalid_operation quax780 quantize -0.0001E-999 1e-1004 -> NaN Invalid_operation precision: 9 maxExponent: 999999999 minexponent: -999999999 -- some extremes derived from Rescale testcases quax801 quantize 0 1e1000000000 -> NaN Invalid_operation quax802 quantize 0 1e-1000000000 -> 0E-1000000000 quax803 quantize 0 1e2000000000 -> NaN Invalid_operation quax804 quantize 0 1e-2000000000 -> NaN Invalid_operation quax805 quantize 0 1e3000000000 -> NaN Invalid_operation quax806 quantize 0 1e-3000000000 -> NaN Invalid_operation quax807 quantize 0 1e4000000000 -> NaN Invalid_operation quax808 quantize 0 1e-4000000000 -> NaN Invalid_operation quax809 quantize 0 1e5000000000 -> NaN Invalid_operation quax810 quantize 0 1e-5000000000 -> NaN Invalid_operation quax811 quantize 0 1e6000000000 -> NaN Invalid_operation quax812 quantize 0 1e-6000000000 -> NaN Invalid_operation quax813 quantize 0 1e7000000000 -> NaN Invalid_operation quax814 quantize 0 1e-7000000000 -> NaN Invalid_operation quax815 quantize 0 1e8000000000 -> NaN Invalid_operation quax816 quantize 0 1e-8000000000 -> NaN Invalid_operation quax817 quantize 0 1e9000000000 -> NaN Invalid_operation quax818 quantize 0 1e-9000000000 -> NaN Invalid_operation quax819 quantize 0 1e9999999999 -> NaN Invalid_operation quax820 quantize 0 1e-9999999999 -> NaN Invalid_operation quax821 quantize 0 1e10000000000 -> NaN Invalid_operation quax822 quantize 0 1e-10000000000 -> NaN Invalid_operation quax843 quantize 0 1e999999999 -> 0E+999999999 quax844 quantize 0 1e1000000000 -> NaN Invalid_operation quax845 quantize 0 1e-999999999 -> 0E-999999999 quax846 quantize 0 1e-1000000000 -> 0E-1000000000 quax847 quantize 0 1e-1000000001 -> 0E-1000000001 quax848 quantize 0 1e-1000000002 -> 0E-1000000002 quax849 quantize 0 1e-1000000003 -> 0E-1000000003 quax850 quantize 0 1e-1000000004 -> 0E-1000000004 quax851 quantize 0 1e-1000000005 -> 0E-1000000005 quax852 quantize 0 1e-1000000006 -> 0E-1000000006 quax853 quantize 0 1e-1000000007 -> 0E-1000000007 quax854 quantize 0 1e-1000000008 -> NaN Invalid_operation quax861 quantize 1 1e+2147483649 -> NaN Invalid_operation quax862 quantize 1 1e+2147483648 -> NaN Invalid_operation quax863 quantize 1 1e+2147483647 -> NaN Invalid_operation quax864 quantize 1 1e-2147483647 -> NaN Invalid_operation quax865 quantize 1 1e-2147483648 -> NaN Invalid_operation quax866 quantize 1 1e-2147483649 -> NaN Invalid_operation -- More from Fung Lee precision: 16 rounding: half_up maxExponent: 384 minExponent: -383 quax1021 quantize 8.666666666666000E+384 1.000000000000000E+384 -> 8.666666666666000E+384 quax1022 quantize 64#8.666666666666000E+384 64#1.000000000000000E+384 -> 8.666666666666000E+384 quax1023 quantize 64#8.666666666666000E+384 128#1.000000000000000E+384 -> 8.666666666666000E+384 quax1024 quantize 64#8.666666666666000E+384 64#1E+384 -> 8.666666666666000E+384 quax1025 quantize 64#8.666666666666000E+384 64#1E+384 -> 64#8.666666666666000E+384 quax1026 quantize 64#8.666666666666000E+384 128#1E+384 -> 64#9E+384 Inexact Rounded Clamped quax1027 quantize 64#8.666666666666000E+323 64#1E+31 -> NaN Invalid_operation quax1028 quantize 64#8.666666666666000E+323 128#1E+31 -> NaN Invalid_operation quax1029 quantize 64#8.66666666E+3 128#1E+10 -> 64#0E10 Inexact Rounded quax1030 quantize 8.66666666E+3 1E+3 -> 9E+3 Inexact Rounded -- Int and uInt32 edge values for testing conversions quax1040 quantize -2147483646 0 -> -2147483646 quax1041 quantize -2147483647 0 -> -2147483647 quax1042 quantize -2147483648 0 -> -2147483648 quax1043 quantize -2147483649 0 -> -2147483649 quax1044 quantize 2147483646 0 -> 2147483646 quax1045 quantize 2147483647 0 -> 2147483647 quax1046 quantize 2147483648 0 -> 2147483648 quax1047 quantize 2147483649 0 -> 2147483649 quax1048 quantize 4294967294 0 -> 4294967294 quax1049 quantize 4294967295 0 -> 4294967295 quax1050 quantize 4294967296 0 -> 4294967296 quax1051 quantize 4294967297 0 -> 4294967297 -- and powers of ten for same quax1101 quantize 5000000000 0 -> 5000000000 quax1102 quantize 4000000000 0 -> 4000000000 quax1103 quantize 2000000000 0 -> 2000000000 quax1104 quantize 1000000000 0 -> 1000000000 quax1105 quantize 0100000000 0 -> 100000000 quax1106 quantize 0010000000 0 -> 10000000 quax1107 quantize 0001000000 0 -> 1000000 quax1108 quantize 0000100000 0 -> 100000 quax1109 quantize 0000010000 0 -> 10000 quax1110 quantize 0000001000 0 -> 1000 quax1111 quantize 0000000100 0 -> 100 quax1112 quantize 0000000010 0 -> 10 quax1113 quantize 0000000001 0 -> 1 quax1114 quantize 0000000000 0 -> 0 -- and powers of ten for same quax1121 quantize -5000000000 0 -> -5000000000 quax1122 quantize -4000000000 0 -> -4000000000 quax1123 quantize -2000000000 0 -> -2000000000 quax1124 quantize -1000000000 0 -> -1000000000 quax1125 quantize -0100000000 0 -> -100000000 quax1126 quantize -0010000000 0 -> -10000000 quax1127 quantize -0001000000 0 -> -1000000 quax1128 quantize -0000100000 0 -> -100000 quax1129 quantize -0000010000 0 -> -10000 quax1130 quantize -0000001000 0 -> -1000 quax1131 quantize -0000000100 0 -> -100 quax1132 quantize -0000000010 0 -> -10 quax1133 quantize -0000000001 0 -> -1 quax1134 quantize -0000000000 0 -> -0 -- Some miscellany precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 -- 1 2 3 -- 1 234567890123456789012345678901234 quax0a1 quantize 8.555555555555555555555555555555555E+6143 1E+6143 -> 9E+6143 Inexact Rounded quax0a2 quantize 128#8.555555555555555555555555555555555E+6143 128#1E+6143 -> 8.55555555555555555555555555555556E+6143 Rounded Inexact quax0a3 quantize 128#8.555555555555555555555555555555555E+6144 128#1E+6144 -> 8.555555555555555555555555555555555E+6144 -- payload decapitate precision: 5 quax62100 quantize 11 -sNaN1234567890 -> -NaN67890 Invalid_operation -- Null tests quax998 quantize 10 # -> NaN Invalid_operation quax999 quantize # 1e10 -> NaN Invalid_operation apd-3.2.1/testdata/randoms.decTest000066400000000000000000011001651450022325000170470ustar00rootroot00000000000000------------------------------------------------------------------------ -- randoms.decTest -- decimal random testcases -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 maxexponent: 999999999 minexponent: -999999999 precision: 9 rounding: half_up -- Randomly generated testcases [31 Dec 2000, with results defined for -- all cases [27 Oct 2001], and no trim/finish [9 Jun 2002] xadd001 add 905.67402 -202896611.E-780472620 -> 905.674020 Inexact Rounded xcom001 compare 905.67402 -202896611.E-780472620 -> 1 xdiv001 divide 905.67402 -202896611.E-780472620 -> -4.46372177E+780472614 Inexact Rounded xdvi001 divideint 905.67402 -202896611.E-780472620 -> NaN Division_impossible xmul001 multiply 905.67402 -202896611.E-780472620 -> -1.83758189E-780472609 Inexact Rounded xpow001 power 905.67402 -2 -> 0.00000121914730 Inexact Rounded xrem001 remainder 905.67402 -202896611.E-780472620 -> NaN Division_impossible xsub001 subtract 905.67402 -202896611.E-780472620 -> 905.674020 Inexact Rounded xadd002 add 3915134.7 -597164907. -> -593249772 Inexact Rounded xcom002 compare 3915134.7 -597164907. -> 1 xdiv002 divide 3915134.7 -597164907. -> -0.00655620358 Inexact Rounded xdvi002 divideint 3915134.7 -597164907. -> -0 xmul002 multiply 3915134.7 -597164907. -> -2.33798105E+15 Inexact Rounded xpow002 power 3915134.7 -597164907 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem002 remainder 3915134.7 -597164907. -> 3915134.7 xsub002 subtract 3915134.7 -597164907. -> 601080042 Inexact Rounded xadd003 add 309759261 62663.487 -> 309821924 Inexact Rounded xcom003 compare 309759261 62663.487 -> 1 xdiv003 divide 309759261 62663.487 -> 4943.21775 Inexact Rounded xdvi003 divideint 309759261 62663.487 -> 4943 xmul003 multiply 309759261 62663.487 -> 1.94105954E+13 Inexact Rounded xpow003 power 309759261 62663 -> 1.13679199E+532073 Inexact Rounded xrem003 remainder 309759261 62663.487 -> 13644.759 xsub003 subtract 309759261 62663.487 -> 309696598 Inexact Rounded xadd004 add 3.93591888E-236595626 7242375.00 -> 7242375.00 Inexact Rounded xcom004 compare 3.93591888E-236595626 7242375.00 -> -1 xdiv004 divide 3.93591888E-236595626 7242375.00 -> 5.43456930E-236595633 Inexact Rounded xdvi004 divideint 3.93591888E-236595626 7242375.00 -> 0 xmul004 multiply 3.93591888E-236595626 7242375.00 -> 2.85054005E-236595619 Inexact Rounded xpow004 power 3.93591888E-236595626 7242375 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem004 remainder 3.93591888E-236595626 7242375.00 -> 3.93591888E-236595626 xsub004 subtract 3.93591888E-236595626 7242375.00 -> -7242375.00 Inexact Rounded xadd005 add 323902.714 -608669.607E-657060568 -> 323902.714 Inexact Rounded xcom005 compare 323902.714 -608669.607E-657060568 -> 1 xdiv005 divide 323902.714 -608669.607E-657060568 -> -5.32148657E+657060567 Inexact Rounded xdvi005 divideint 323902.714 -608669.607E-657060568 -> NaN Division_impossible xmul005 multiply 323902.714 -608669.607E-657060568 -> -1.97149738E-657060557 Inexact Rounded xpow005 power 323902.714 -6 -> 8.65989204E-34 Inexact Rounded xrem005 remainder 323902.714 -608669.607E-657060568 -> NaN Division_impossible xsub005 subtract 323902.714 -608669.607E-657060568 -> 323902.714 Inexact Rounded xadd006 add 5.11970092 -8807.22036 -> -8802.10066 Inexact Rounded xcom006 compare 5.11970092 -8807.22036 -> 1 xdiv006 divide 5.11970092 -8807.22036 -> -0.000581307236 Inexact Rounded xdvi006 divideint 5.11970092 -8807.22036 -> -0 xmul006 multiply 5.11970092 -8807.22036 -> -45090.3342 Inexact Rounded xpow006 power 5.11970092 -8807 -> 4.81819262E-6247 Inexact Rounded xrem006 remainder 5.11970092 -8807.22036 -> 5.11970092 xsub006 subtract 5.11970092 -8807.22036 -> 8812.34006 Inexact Rounded xadd007 add -7.99874516 4561.83758 -> 4553.83883 Inexact Rounded xcom007 compare -7.99874516 4561.83758 -> -1 xdiv007 divide -7.99874516 4561.83758 -> -0.00175340420 Inexact Rounded xdvi007 divideint -7.99874516 4561.83758 -> -0 xmul007 multiply -7.99874516 4561.83758 -> -36488.9763 Inexact Rounded xpow007 power -7.99874516 4562 -> 3.85236199E+4119 Inexact Rounded xrem007 remainder -7.99874516 4561.83758 -> -7.99874516 xsub007 subtract -7.99874516 4561.83758 -> -4569.83633 Inexact Rounded xadd008 add 297802878 -927206.324 -> 296875672 Inexact Rounded xcom008 compare 297802878 -927206.324 -> 1 xdiv008 divide 297802878 -927206.324 -> -321.182967 Inexact Rounded xdvi008 divideint 297802878 -927206.324 -> -321 xmul008 multiply 297802878 -927206.324 -> -2.76124712E+14 Inexact Rounded xpow008 power 297802878 -927206 -> 1.94602810E-7857078 Inexact Rounded xrem008 remainder 297802878 -927206.324 -> 169647.996 xsub008 subtract 297802878 -927206.324 -> 298730084 Inexact Rounded xadd009 add -766.651824 31300.3619 -> 30533.7101 Inexact Rounded xcom009 compare -766.651824 31300.3619 -> -1 xdiv009 divide -766.651824 31300.3619 -> -0.0244933853 Inexact Rounded xdvi009 divideint -766.651824 31300.3619 -> -0 xmul009 multiply -766.651824 31300.3619 -> -23996479.5 Inexact Rounded xpow009 power -766.651824 31300 -> 8.37189011E+90287 Inexact Rounded xrem009 remainder -766.651824 31300.3619 -> -766.651824 xsub009 subtract -766.651824 31300.3619 -> -32067.0137 Inexact Rounded xadd010 add -56746.8689E+934981942 471002521. -> -5.67468689E+934981946 Inexact Rounded xcom010 compare -56746.8689E+934981942 471002521. -> -1 xdiv010 divide -56746.8689E+934981942 471002521. -> -1.20481030E+934981938 Inexact Rounded xdvi010 divideint -56746.8689E+934981942 471002521. -> NaN Division_impossible xmul010 multiply -56746.8689E+934981942 471002521. -> -2.67279183E+934981955 Inexact Rounded xpow010 power -56746.8689E+934981942 471002521 -> -Infinity Overflow Inexact Rounded xrem010 remainder -56746.8689E+934981942 471002521. -> NaN Division_impossible xsub010 subtract -56746.8689E+934981942 471002521. -> -5.67468689E+934981946 Inexact Rounded xadd011 add 456417160 -41346.1024 -> 456375814 Inexact Rounded xcom011 compare 456417160 -41346.1024 -> 1 xdiv011 divide 456417160 -41346.1024 -> -11038.9404 Inexact Rounded xdvi011 divideint 456417160 -41346.1024 -> -11038 xmul011 multiply 456417160 -41346.1024 -> -1.88710706E+13 Inexact Rounded xpow011 power 456417160 -41346 -> 1.04766863E-358030 Inexact Rounded xrem011 remainder 456417160 -41346.1024 -> 38881.7088 xsub011 subtract 456417160 -41346.1024 -> 456458506 Inexact Rounded xadd012 add 102895.722 -2.62214826 -> 102893.100 Inexact Rounded xcom012 compare 102895.722 -2.62214826 -> 1 xdiv012 divide 102895.722 -2.62214826 -> -39241.0008 Inexact Rounded xdvi012 divideint 102895.722 -2.62214826 -> -39241 xmul012 multiply 102895.722 -2.62214826 -> -269807.838 Inexact Rounded xpow012 power 102895.722 -3 -> 9.17926786E-16 Inexact Rounded xrem012 remainder 102895.722 -2.62214826 -> 0.00212934 xsub012 subtract 102895.722 -2.62214826 -> 102898.344 Inexact Rounded xadd013 add 61.3033331E+157644141 -567740.918E-893439456 -> 6.13033331E+157644142 Inexact Rounded xcom013 compare 61.3033331E+157644141 -567740.918E-893439456 -> 1 xdiv013 divide 61.3033331E+157644141 -567740.918E-893439456 -> -Infinity Inexact Overflow Rounded xdvi013 divideint 61.3033331E+157644141 -567740.918E-893439456 -> NaN Division_impossible xmul013 multiply 61.3033331E+157644141 -567740.918E-893439456 -> -3.48044106E-735795308 Inexact Rounded xpow013 power 61.3033331E+157644141 -6 -> 1.88406322E-945864857 Inexact Rounded xrem013 remainder 61.3033331E+157644141 -567740.918E-893439456 -> NaN Division_impossible xsub013 subtract 61.3033331E+157644141 -567740.918E-893439456 -> 6.13033331E+157644142 Inexact Rounded xadd014 add 80223.3897 73921.0383E-467772675 -> 80223.3897 Inexact Rounded xcom014 compare 80223.3897 73921.0383E-467772675 -> 1 xdiv014 divide 80223.3897 73921.0383E-467772675 -> 1.08525789E+467772675 Inexact Rounded xdvi014 divideint 80223.3897 73921.0383E-467772675 -> NaN Division_impossible xmul014 multiply 80223.3897 73921.0383E-467772675 -> 5.93019626E-467772666 Inexact Rounded xpow014 power 80223.3897 7 -> 2.13848919E+34 Inexact Rounded xrem014 remainder 80223.3897 73921.0383E-467772675 -> NaN Division_impossible xsub014 subtract 80223.3897 73921.0383E-467772675 -> 80223.3897 Inexact Rounded xadd015 add -654645.954 -9.12535752 -> -654655.079 Inexact Rounded xcom015 compare -654645.954 -9.12535752 -> -1 xdiv015 divide -654645.954 -9.12535752 -> 71739.2116 Inexact Rounded xdvi015 divideint -654645.954 -9.12535752 -> 71739 xmul015 multiply -654645.954 -9.12535752 -> 5973878.38 Inexact Rounded xpow015 power -654645.954 -9 -> -4.52836690E-53 Inexact Rounded xrem015 remainder -654645.954 -9.12535752 -> -1.93087272 xsub015 subtract -654645.954 -9.12535752 -> -654636.829 Inexact Rounded xadd016 add 63.1917772E-706014634 -7.56253257E-138579234 -> -7.56253257E-138579234 Inexact Rounded xcom016 compare 63.1917772E-706014634 -7.56253257E-138579234 -> 1 xdiv016 divide 63.1917772E-706014634 -7.56253257E-138579234 -> -8.35590149E-567435400 Inexact Rounded xdvi016 divideint 63.1917772E-706014634 -7.56253257E-138579234 -> -0 xmul016 multiply 63.1917772E-706014634 -7.56253257E-138579234 -> -4.77889873E-844593866 Inexact Rounded xpow016 power 63.1917772E-706014634 -8 -> Infinity Overflow Inexact Rounded xrem016 remainder 63.1917772E-706014634 -7.56253257E-138579234 -> 6.31917772E-706014633 xsub016 subtract 63.1917772E-706014634 -7.56253257E-138579234 -> 7.56253257E-138579234 Inexact Rounded xadd017 add -39674.7190 2490607.78 -> 2450933.06 Inexact Rounded xcom017 compare -39674.7190 2490607.78 -> -1 xdiv017 divide -39674.7190 2490607.78 -> -0.0159297338 Inexact Rounded xdvi017 divideint -39674.7190 2490607.78 -> -0 xmul017 multiply -39674.7190 2490607.78 -> -9.88141638E+10 Inexact Rounded xpow017 power -39674.7190 2490608 -> 2.55032329E+11453095 Inexact Rounded xrem017 remainder -39674.7190 2490607.78 -> -39674.7190 xsub017 subtract -39674.7190 2490607.78 -> -2530282.50 Inexact Rounded xadd018 add -3364.59737E-600363681 896487.451 -> 896487.451 Inexact Rounded xcom018 compare -3364.59737E-600363681 896487.451 -> -1 xdiv018 divide -3364.59737E-600363681 896487.451 -> -3.75308920E-600363684 Inexact Rounded xdvi018 divideint -3364.59737E-600363681 896487.451 -> -0 xmul018 multiply -3364.59737E-600363681 896487.451 -> -3.01631932E-600363672 Inexact Rounded xpow018 power -3364.59737E-600363681 896487 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem018 remainder -3364.59737E-600363681 896487.451 -> -3.36459737E-600363678 xsub018 subtract -3364.59737E-600363681 896487.451 -> -896487.451 Inexact Rounded xadd019 add -64138.0578 31759011.3E+697488342 -> 3.17590113E+697488349 Inexact Rounded xcom019 compare -64138.0578 31759011.3E+697488342 -> -1 xdiv019 divide -64138.0578 31759011.3E+697488342 -> -2.01952313E-697488345 Inexact Rounded xdvi019 divideint -64138.0578 31759011.3E+697488342 -> -0 xmul019 multiply -64138.0578 31759011.3E+697488342 -> -2.03696130E+697488354 Inexact Rounded xpow019 power -64138.0578 3 -> -2.63844116E+14 Inexact Rounded xrem019 remainder -64138.0578 31759011.3E+697488342 -> -64138.0578 xsub019 subtract -64138.0578 31759011.3E+697488342 -> -3.17590113E+697488349 Inexact Rounded xadd020 add 61399.8527 -64344484.5 -> -64283084.6 Inexact Rounded xcom020 compare 61399.8527 -64344484.5 -> 1 xdiv020 divide 61399.8527 -64344484.5 -> -0.000954236454 Inexact Rounded xdvi020 divideint 61399.8527 -64344484.5 -> -0 xmul020 multiply 61399.8527 -64344484.5 -> -3.95074187E+12 Inexact Rounded xpow020 power 61399.8527 -64344485 -> 1.27378842E-308092161 Inexact Rounded xrem020 remainder 61399.8527 -64344484.5 -> 61399.8527 xsub020 subtract 61399.8527 -64344484.5 -> 64405884.4 Inexact Rounded xadd021 add -722960.204 -26154599.8 -> -26877560.0 Inexact Rounded xcom021 compare -722960.204 -26154599.8 -> 1 xdiv021 divide -722960.204 -26154599.8 -> 0.0276417995 Inexact Rounded xdvi021 divideint -722960.204 -26154599.8 -> 0 xmul021 multiply -722960.204 -26154599.8 -> 1.89087348E+13 Inexact Rounded xpow021 power -722960.204 -26154600 -> 5.34236139E-153242794 Inexact Rounded xrem021 remainder -722960.204 -26154599.8 -> -722960.204 xsub021 subtract -722960.204 -26154599.8 -> 25431639.6 Inexact Rounded xadd022 add 9.47109959E+230565093 73354723.2 -> 9.47109959E+230565093 Inexact Rounded xcom022 compare 9.47109959E+230565093 73354723.2 -> 1 xdiv022 divide 9.47109959E+230565093 73354723.2 -> 1.29113698E+230565086 Inexact Rounded xdvi022 divideint 9.47109959E+230565093 73354723.2 -> NaN Division_impossible xmul022 multiply 9.47109959E+230565093 73354723.2 -> 6.94749889E+230565101 Inexact Rounded xpow022 power 9.47109959E+230565093 73354723 -> Infinity Overflow Inexact Rounded xrem022 remainder 9.47109959E+230565093 73354723.2 -> NaN Division_impossible xsub022 subtract 9.47109959E+230565093 73354723.2 -> 9.47109959E+230565093 Inexact Rounded xadd023 add 43.7456245 547441956. -> 547442000 Inexact Rounded xcom023 compare 43.7456245 547441956. -> -1 xdiv023 divide 43.7456245 547441956. -> 7.99091557E-8 Inexact Rounded xdvi023 divideint 43.7456245 547441956. -> 0 xmul023 multiply 43.7456245 547441956. -> 2.39481902E+10 Inexact Rounded xpow023 power 43.7456245 547441956 -> 2.91742391E+898316458 Inexact Rounded xrem023 remainder 43.7456245 547441956. -> 43.7456245 xsub023 subtract 43.7456245 547441956. -> -547441912 Inexact Rounded xadd024 add -73150542E-242017390 -8.15869954 -> -8.15869954 Inexact Rounded xcom024 compare -73150542E-242017390 -8.15869954 -> 1 xdiv024 divide -73150542E-242017390 -8.15869954 -> 8.96595611E-242017384 Inexact Rounded xdvi024 divideint -73150542E-242017390 -8.15869954 -> 0 xmul024 multiply -73150542E-242017390 -8.15869954 -> 5.96813293E-242017382 Inexact Rounded xpow024 power -73150542E-242017390 -8 -> Infinity Overflow Inexact Rounded xrem024 remainder -73150542E-242017390 -8.15869954 -> -7.3150542E-242017383 xsub024 subtract -73150542E-242017390 -8.15869954 -> 8.15869954 Inexact Rounded xadd025 add 2015.62109E+299897596 -11788916.1 -> 2.01562109E+299897599 Inexact Rounded xcom025 compare 2015.62109E+299897596 -11788916.1 -> 1 xdiv025 divide 2015.62109E+299897596 -11788916.1 -> -1.70975947E+299897592 Inexact Rounded xdvi025 divideint 2015.62109E+299897596 -11788916.1 -> NaN Division_impossible xmul025 multiply 2015.62109E+299897596 -11788916.1 -> -2.37619879E+299897606 Inexact Rounded xpow025 power 2015.62109E+299897596 -11788916 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem025 remainder 2015.62109E+299897596 -11788916.1 -> NaN Division_impossible xsub025 subtract 2015.62109E+299897596 -11788916.1 -> 2.01562109E+299897599 Inexact Rounded xadd026 add 29.498114 -26486451 -> -26486421.5 Inexact Rounded xcom026 compare 29.498114 -26486451 -> 1 xdiv026 divide 29.498114 -26486451 -> -0.00000111370580 Inexact Rounded xdvi026 divideint 29.498114 -26486451 -> -0 xmul026 multiply 29.498114 -26486451 -> -781300351 Inexact Rounded xpow026 power 29.498114 -26486451 -> 4.22252513E-38929634 Inexact Rounded xrem026 remainder 29.498114 -26486451 -> 29.498114 xsub026 subtract 29.498114 -26486451 -> 26486480.5 Inexact Rounded xadd027 add 244375043.E+130840878 -9.44522029 -> 2.44375043E+130840886 Inexact Rounded xcom027 compare 244375043.E+130840878 -9.44522029 -> 1 xdiv027 divide 244375043.E+130840878 -9.44522029 -> -2.58728791E+130840885 Inexact Rounded xdvi027 divideint 244375043.E+130840878 -9.44522029 -> NaN Division_impossible xmul027 multiply 244375043.E+130840878 -9.44522029 -> -2.30817611E+130840887 Inexact Rounded xpow027 power 244375043.E+130840878 -9 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem027 remainder 244375043.E+130840878 -9.44522029 -> NaN Division_impossible xsub027 subtract 244375043.E+130840878 -9.44522029 -> 2.44375043E+130840886 Inexact Rounded xadd028 add -349388.759 -196215.776 -> -545604.535 xcom028 compare -349388.759 -196215.776 -> -1 xdiv028 divide -349388.759 -196215.776 -> 1.78063541 Inexact Rounded xdvi028 divideint -349388.759 -196215.776 -> 1 xmul028 multiply -349388.759 -196215.776 -> 6.85555865E+10 Inexact Rounded xpow028 power -349388.759 -196216 -> 1.24551752E-1087686 Inexact Rounded xrem028 remainder -349388.759 -196215.776 -> -153172.983 xsub028 subtract -349388.759 -196215.776 -> -153172.983 xadd029 add -70905112.4 -91353968.8 -> -162259081 Inexact Rounded xcom029 compare -70905112.4 -91353968.8 -> 1 xdiv029 divide -70905112.4 -91353968.8 -> 0.776157986 Inexact Rounded xdvi029 divideint -70905112.4 -91353968.8 -> 0 xmul029 multiply -70905112.4 -91353968.8 -> 6.47746343E+15 Inexact Rounded xpow029 power -70905112.4 -91353969 -> -3.05944741E-717190554 Inexact Rounded xrem029 remainder -70905112.4 -91353968.8 -> -70905112.4 xsub029 subtract -70905112.4 -91353968.8 -> 20448856.4 xadd030 add -225094.28 -88.7723542 -> -225183.052 Inexact Rounded xcom030 compare -225094.28 -88.7723542 -> -1 xdiv030 divide -225094.28 -88.7723542 -> 2535.63491 Inexact Rounded xdvi030 divideint -225094.28 -88.7723542 -> 2535 xmul030 multiply -225094.28 -88.7723542 -> 19982149.2 Inexact Rounded xpow030 power -225094.28 -89 -> -4.36076965E-477 Inexact Rounded xrem030 remainder -225094.28 -88.7723542 -> -56.3621030 xsub030 subtract -225094.28 -88.7723542 -> -225005.508 Inexact Rounded xadd031 add 50.4442340 82.7952169E+880120759 -> 8.27952169E+880120760 Inexact Rounded xcom031 compare 50.4442340 82.7952169E+880120759 -> -1 xdiv031 divide 50.4442340 82.7952169E+880120759 -> 6.09265075E-880120760 Inexact Rounded xdvi031 divideint 50.4442340 82.7952169E+880120759 -> 0 xmul031 multiply 50.4442340 82.7952169E+880120759 -> 4.17654130E+880120762 Inexact Rounded xpow031 power 50.4442340 8 -> 4.19268518E+13 Inexact Rounded xrem031 remainder 50.4442340 82.7952169E+880120759 -> 50.4442340 xsub031 subtract 50.4442340 82.7952169E+880120759 -> -8.27952169E+880120760 Inexact Rounded xadd032 add -32311.9037 8.36379449 -> -32303.5399 Inexact Rounded xcom032 compare -32311.9037 8.36379449 -> -1 xdiv032 divide -32311.9037 8.36379449 -> -3863.30675 Inexact Rounded xdvi032 divideint -32311.9037 8.36379449 -> -3863 xmul032 multiply -32311.9037 8.36379449 -> -270250.122 Inexact Rounded xpow032 power -32311.9037 8 -> 1.18822960E+36 Inexact Rounded xrem032 remainder -32311.9037 8.36379449 -> -2.56558513 xsub032 subtract -32311.9037 8.36379449 -> -32320.2675 Inexact Rounded xadd033 add 615396156.E+549895291 -29530247.4 -> 6.15396156E+549895299 Inexact Rounded xcom033 compare 615396156.E+549895291 -29530247.4 -> 1 xdiv033 divide 615396156.E+549895291 -29530247.4 -> -2.08395191E+549895292 Inexact Rounded xdvi033 divideint 615396156.E+549895291 -29530247.4 -> NaN Division_impossible xmul033 multiply 615396156.E+549895291 -29530247.4 -> -1.81728007E+549895307 Inexact Rounded xpow033 power 615396156.E+549895291 -29530247 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem033 remainder 615396156.E+549895291 -29530247.4 -> NaN Division_impossible xsub033 subtract 615396156.E+549895291 -29530247.4 -> 6.15396156E+549895299 Inexact Rounded xadd034 add 592.142173E-419941416 -3.46079109E-844011845 -> 5.92142173E-419941414 Inexact Rounded xcom034 compare 592.142173E-419941416 -3.46079109E-844011845 -> 1 xdiv034 divide 592.142173E-419941416 -3.46079109E-844011845 -> -1.71100236E+424070431 Inexact Rounded xdvi034 divideint 592.142173E-419941416 -3.46079109E-844011845 -> NaN Division_impossible xmul034 multiply 592.142173E-419941416 -3.46079109E-844011845 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow034 power 592.142173E-419941416 -3 -> Infinity Overflow Inexact Rounded xrem034 remainder 592.142173E-419941416 -3.46079109E-844011845 -> NaN Division_impossible xsub034 subtract 592.142173E-419941416 -3.46079109E-844011845 -> 5.92142173E-419941414 Inexact Rounded xadd035 add 849.515993E-878446473 -1039.08778 -> -1039.08778 Inexact Rounded xcom035 compare 849.515993E-878446473 -1039.08778 -> 1 xdiv035 divide 849.515993E-878446473 -1039.08778 -> -8.17559411E-878446474 Inexact Rounded xdvi035 divideint 849.515993E-878446473 -1039.08778 -> -0 xmul035 multiply 849.515993E-878446473 -1039.08778 -> -8.82721687E-878446468 Inexact Rounded xpow035 power 849.515993E-878446473 -1039 -> Infinity Overflow Inexact Rounded xrem035 remainder 849.515993E-878446473 -1039.08778 -> 8.49515993E-878446471 xsub035 subtract 849.515993E-878446473 -1039.08778 -> 1039.08778 Inexact Rounded xadd036 add 213361789 -599.644851 -> 213361189 Inexact Rounded xcom036 compare 213361789 -599.644851 -> 1 xdiv036 divide 213361789 -599.644851 -> -355813.593 Inexact Rounded xdvi036 divideint 213361789 -599.644851 -> -355813 xmul036 multiply 213361789 -599.644851 -> -1.27941298E+11 Inexact Rounded xpow036 power 213361789 -600 -> 3.38854684E-4998 Inexact Rounded xrem036 remainder 213361789 -599.644851 -> 355.631137 xsub036 subtract 213361789 -599.644851 -> 213362389 Inexact Rounded xadd037 add -795522555. -298.037702 -> -795522853 Inexact Rounded xcom037 compare -795522555. -298.037702 -> -1 xdiv037 divide -795522555. -298.037702 -> 2669201.08 Inexact Rounded xdvi037 divideint -795522555. -298.037702 -> 2669201 xmul037 multiply -795522555. -298.037702 -> 2.37095714E+11 Inexact Rounded xpow037 power -795522555. -298 -> 4.03232712E-2653 Inexact Rounded xrem037 remainder -795522555. -298.037702 -> -22.783898 xsub037 subtract -795522555. -298.037702 -> -795522257 Inexact Rounded xadd038 add -501260651. -8761893.0E-689281479 -> -501260651 Inexact Rounded xcom038 compare -501260651. -8761893.0E-689281479 -> -1 xdiv038 divide -501260651. -8761893.0E-689281479 -> 5.72091728E+689281480 Inexact Rounded xdvi038 divideint -501260651. -8761893.0E-689281479 -> NaN Division_impossible xmul038 multiply -501260651. -8761893.0E-689281479 -> 4.39199219E-689281464 Inexact Rounded xpow038 power -501260651. -9 -> -5.00526961E-79 Inexact Rounded xrem038 remainder -501260651. -8761893.0E-689281479 -> NaN Division_impossible xsub038 subtract -501260651. -8761893.0E-689281479 -> -501260651 Inexact Rounded xadd039 add -1.70781105E-848889023 36504769.4 -> 36504769.4 Inexact Rounded xcom039 compare -1.70781105E-848889023 36504769.4 -> -1 xdiv039 divide -1.70781105E-848889023 36504769.4 -> -4.67832307E-848889031 Inexact Rounded xdvi039 divideint -1.70781105E-848889023 36504769.4 -> -0 xmul039 multiply -1.70781105E-848889023 36504769.4 -> -6.23432486E-848889016 Inexact Rounded xpow039 power -1.70781105E-848889023 36504769 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem039 remainder -1.70781105E-848889023 36504769.4 -> -1.70781105E-848889023 xsub039 subtract -1.70781105E-848889023 36504769.4 -> -36504769.4 Inexact Rounded xadd040 add -5290.54984E-490626676 842535254 -> 842535254 Inexact Rounded xcom040 compare -5290.54984E-490626676 842535254 -> -1 xdiv040 divide -5290.54984E-490626676 842535254 -> -6.27932162E-490626682 Inexact Rounded xdvi040 divideint -5290.54984E-490626676 842535254 -> -0 xmul040 multiply -5290.54984E-490626676 842535254 -> -4.45747475E-490626664 Inexact Rounded xpow040 power -5290.54984E-490626676 842535254 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem040 remainder -5290.54984E-490626676 842535254 -> -5.29054984E-490626673 xsub040 subtract -5290.54984E-490626676 842535254 -> -842535254 Inexact Rounded xadd041 add 608.31825E+535268120 -59609.0993 -> 6.08318250E+535268122 Inexact Rounded xcom041 compare 608.31825E+535268120 -59609.0993 -> 1 xdiv041 divide 608.31825E+535268120 -59609.0993 -> -1.02051240E+535268118 Inexact Rounded xdvi041 divideint 608.31825E+535268120 -59609.0993 -> NaN Division_impossible xmul041 multiply 608.31825E+535268120 -59609.0993 -> -3.62613030E+535268127 Inexact Rounded xpow041 power 608.31825E+535268120 -59609 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem041 remainder 608.31825E+535268120 -59609.0993 -> NaN Division_impossible xsub041 subtract 608.31825E+535268120 -59609.0993 -> 6.08318250E+535268122 Inexact Rounded xadd042 add -4629035.31 -167.884398 -> -4629203.19 Inexact Rounded xcom042 compare -4629035.31 -167.884398 -> -1 xdiv042 divide -4629035.31 -167.884398 -> 27572.7546 Inexact Rounded xdvi042 divideint -4629035.31 -167.884398 -> 27572 xmul042 multiply -4629035.31 -167.884398 -> 777142806 Inexact Rounded xpow042 power -4629035.31 -168 -> 1.57614831E-1120 Inexact Rounded xrem042 remainder -4629035.31 -167.884398 -> -126.688344 xsub042 subtract -4629035.31 -167.884398 -> -4628867.43 Inexact Rounded xadd043 add -66527378. -706400268. -> -772927646 xcom043 compare -66527378. -706400268. -> 1 xdiv043 divide -66527378. -706400268. -> 0.0941780192 Inexact Rounded xdvi043 divideint -66527378. -706400268. -> 0 xmul043 multiply -66527378. -706400268. -> 4.69949576E+16 Inexact Rounded xpow043 power -66527378. -706400268 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem043 remainder -66527378. -706400268. -> -66527378 xsub043 subtract -66527378. -706400268. -> 639872890 xadd044 add -2510497.53 372882462. -> 370371964 Inexact Rounded xcom044 compare -2510497.53 372882462. -> -1 xdiv044 divide -2510497.53 372882462. -> -0.00673267795 Inexact Rounded xdvi044 divideint -2510497.53 372882462. -> -0 xmul044 multiply -2510497.53 372882462. -> -9.36120500E+14 Inexact Rounded xpow044 power -2510497.53 372882462 -> Infinity Overflow Inexact Rounded xrem044 remainder -2510497.53 372882462. -> -2510497.53 xsub044 subtract -2510497.53 372882462. -> -375392960 Inexact Rounded xadd045 add 136.255393E+53329961 -53494.7201E+720058060 -> -5.34947201E+720058064 Inexact Rounded xcom045 compare 136.255393E+53329961 -53494.7201E+720058060 -> 1 xdiv045 divide 136.255393E+53329961 -53494.7201E+720058060 -> -2.54708115E-666728102 Inexact Rounded xdvi045 divideint 136.255393E+53329961 -53494.7201E+720058060 -> -0 xmul045 multiply 136.255393E+53329961 -53494.7201E+720058060 -> -7.28894411E+773388027 Inexact Rounded xpow045 power 136.255393E+53329961 -5 -> 2.12927373E-266649816 Inexact Rounded xrem045 remainder 136.255393E+53329961 -53494.7201E+720058060 -> 1.36255393E+53329963 xsub045 subtract 136.255393E+53329961 -53494.7201E+720058060 -> 5.34947201E+720058064 Inexact Rounded xadd046 add -876673.100 -6150.92266 -> -882824.023 Inexact Rounded xcom046 compare -876673.100 -6150.92266 -> -1 xdiv046 divide -876673.100 -6150.92266 -> 142.527089 Inexact Rounded xdvi046 divideint -876673.100 -6150.92266 -> 142 xmul046 multiply -876673.100 -6150.92266 -> 5.39234844E+9 Inexact Rounded xpow046 power -876673.100 -6151 -> -4.03111774E-36555 Inexact Rounded xrem046 remainder -876673.100 -6150.92266 -> -3242.08228 xsub046 subtract -876673.100 -6150.92266 -> -870522.177 Inexact Rounded xadd047 add -2.45151797E+911306117 27235771 -> -2.45151797E+911306117 Inexact Rounded xcom047 compare -2.45151797E+911306117 27235771 -> -1 xdiv047 divide -2.45151797E+911306117 27235771 -> -9.00109628E+911306109 Inexact Rounded xdvi047 divideint -2.45151797E+911306117 27235771 -> NaN Division_impossible xmul047 multiply -2.45151797E+911306117 27235771 -> -6.67689820E+911306124 Inexact Rounded xpow047 power -2.45151797E+911306117 27235771 -> -Infinity Overflow Inexact Rounded xrem047 remainder -2.45151797E+911306117 27235771 -> NaN Division_impossible xsub047 subtract -2.45151797E+911306117 27235771 -> -2.45151797E+911306117 Inexact Rounded xadd048 add -9.15117551 -4.95100733E-314511326 -> -9.15117551 Inexact Rounded xcom048 compare -9.15117551 -4.95100733E-314511326 -> -1 xdiv048 divide -9.15117551 -4.95100733E-314511326 -> 1.84834618E+314511326 Inexact Rounded xdvi048 divideint -9.15117551 -4.95100733E-314511326 -> NaN Division_impossible xmul048 multiply -9.15117551 -4.95100733E-314511326 -> 4.53075370E-314511325 Inexact Rounded xpow048 power -9.15117551 -5 -> -0.0000155817265 Inexact Rounded xrem048 remainder -9.15117551 -4.95100733E-314511326 -> NaN Division_impossible xsub048 subtract -9.15117551 -4.95100733E-314511326 -> -9.15117551 Inexact Rounded xadd049 add 3.61890453E-985606128 30664416. -> 30664416.0 Inexact Rounded xcom049 compare 3.61890453E-985606128 30664416. -> -1 xdiv049 divide 3.61890453E-985606128 30664416. -> 1.18016418E-985606135 Inexact Rounded xdvi049 divideint 3.61890453E-985606128 30664416. -> 0 xmul049 multiply 3.61890453E-985606128 30664416. -> 1.10971594E-985606120 Inexact Rounded xpow049 power 3.61890453E-985606128 30664416 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem049 remainder 3.61890453E-985606128 30664416. -> 3.61890453E-985606128 xsub049 subtract 3.61890453E-985606128 30664416. -> -30664416.0 Inexact Rounded xadd050 add -257674602E+216723382 -70820959.4 -> -2.57674602E+216723390 Inexact Rounded xcom050 compare -257674602E+216723382 -70820959.4 -> -1 xdiv050 divide -257674602E+216723382 -70820959.4 -> 3.63839468E+216723382 Inexact Rounded xdvi050 divideint -257674602E+216723382 -70820959.4 -> NaN Division_impossible xmul050 multiply -257674602E+216723382 -70820959.4 -> 1.82487625E+216723398 Inexact Rounded xpow050 power -257674602E+216723382 -70820959 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem050 remainder -257674602E+216723382 -70820959.4 -> NaN Division_impossible xsub050 subtract -257674602E+216723382 -70820959.4 -> -2.57674602E+216723390 Inexact Rounded xadd051 add 218699.206 556944241. -> 557162940 Inexact Rounded xcom051 compare 218699.206 556944241. -> -1 xdiv051 divide 218699.206 556944241. -> 0.000392677022 Inexact Rounded xdvi051 divideint 218699.206 556944241. -> 0 xmul051 multiply 218699.206 556944241. -> 1.21803263E+14 Inexact Rounded xpow051 power 218699.206 556944241 -> Infinity Overflow Inexact Rounded xrem051 remainder 218699.206 556944241. -> 218699.206 xsub051 subtract 218699.206 556944241. -> -556725542 Inexact Rounded xadd052 add 106211716. -3456793.74 -> 102754922 Inexact Rounded xcom052 compare 106211716. -3456793.74 -> 1 xdiv052 divide 106211716. -3456793.74 -> -30.7255000 Inexact Rounded xdvi052 divideint 106211716. -3456793.74 -> -30 xmul052 multiply 106211716. -3456793.74 -> -3.67151995E+14 Inexact Rounded xpow052 power 106211716. -3456794 -> 2.07225581E-27744825 Inexact Rounded xrem052 remainder 106211716. -3456793.74 -> 2507903.80 xsub052 subtract 106211716. -3456793.74 -> 109668510 Inexact Rounded xadd053 add 1.25018078 399856.763E-726816740 -> 1.25018078 Inexact Rounded xcom053 compare 1.25018078 399856.763E-726816740 -> 1 xdiv053 divide 1.25018078 399856.763E-726816740 -> 3.12657155E+726816734 Inexact Rounded xdvi053 divideint 1.25018078 399856.763E-726816740 -> NaN Division_impossible xmul053 multiply 1.25018078 399856.763E-726816740 -> 4.99893240E-726816735 Inexact Rounded xpow053 power 1.25018078 4 -> 2.44281890 Inexact Rounded xrem053 remainder 1.25018078 399856.763E-726816740 -> NaN Division_impossible xsub053 subtract 1.25018078 399856.763E-726816740 -> 1.25018078 Inexact Rounded xadd054 add 364.99811 -46222.0505 -> -45857.0524 Inexact Rounded xcom054 compare 364.99811 -46222.0505 -> 1 xdiv054 divide 364.99811 -46222.0505 -> -0.00789662306 Inexact Rounded xdvi054 divideint 364.99811 -46222.0505 -> -0 xmul054 multiply 364.99811 -46222.0505 -> -16870961.1 Inexact Rounded xpow054 power 364.99811 -46222 -> 6.35570856E-118435 Inexact Rounded xrem054 remainder 364.99811 -46222.0505 -> 364.99811 xsub054 subtract 364.99811 -46222.0505 -> 46587.0486 Inexact Rounded xadd055 add -392217576. -958364096 -> -1.35058167E+9 Inexact Rounded xcom055 compare -392217576. -958364096 -> 1 xdiv055 divide -392217576. -958364096 -> 0.409257377 Inexact Rounded xdvi055 divideint -392217576. -958364096 -> 0 xmul055 multiply -392217576. -958364096 -> 3.75887243E+17 Inexact Rounded xpow055 power -392217576. -958364096 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem055 remainder -392217576. -958364096 -> -392217576 xsub055 subtract -392217576. -958364096 -> 566146520 xadd056 add 169601285 714526.639 -> 170315812 Inexact Rounded xcom056 compare 169601285 714526.639 -> 1 xdiv056 divide 169601285 714526.639 -> 237.361738 Inexact Rounded xdvi056 divideint 169601285 714526.639 -> 237 xmul056 multiply 169601285 714526.639 -> 1.21184636E+14 Inexact Rounded xpow056 power 169601285 714527 -> 2.06052444E+5880149 Inexact Rounded xrem056 remainder 169601285 714526.639 -> 258471.557 xsub056 subtract 169601285 714526.639 -> 168886758 Inexact Rounded xadd057 add -674.094552E+586944319 6354.2668E+589657266 -> 6.35426680E+589657269 Inexact Rounded xcom057 compare -674.094552E+586944319 6354.2668E+589657266 -> -1 xdiv057 divide -674.094552E+586944319 6354.2668E+589657266 -> -1.06085340E-2712948 Inexact Rounded xdvi057 divideint -674.094552E+586944319 6354.2668E+589657266 -> -0 xmul057 multiply -674.094552E+586944319 6354.2668E+589657266 -> -Infinity Inexact Overflow Rounded xpow057 power -674.094552E+586944319 6 -> Infinity Overflow Inexact Rounded xrem057 remainder -674.094552E+586944319 6354.2668E+589657266 -> -6.74094552E+586944321 xsub057 subtract -674.094552E+586944319 6354.2668E+589657266 -> -6.35426680E+589657269 Inexact Rounded xadd058 add 151795163E-371727182 -488.09788E-738852245 -> 1.51795163E-371727174 Inexact Rounded xcom058 compare 151795163E-371727182 -488.09788E-738852245 -> 1 xdiv058 divide 151795163E-371727182 -488.09788E-738852245 -> -3.10993285E+367125068 Inexact Rounded xdvi058 divideint 151795163E-371727182 -488.09788E-738852245 -> NaN Division_impossible xmul058 multiply 151795163E-371727182 -488.09788E-738852245 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow058 power 151795163E-371727182 -5 -> Infinity Overflow Inexact Rounded xrem058 remainder 151795163E-371727182 -488.09788E-738852245 -> NaN Division_impossible xsub058 subtract 151795163E-371727182 -488.09788E-738852245 -> 1.51795163E-371727174 Inexact Rounded xadd059 add -746.293386 927749.647 -> 927003.354 Inexact Rounded xcom059 compare -746.293386 927749.647 -> -1 xdiv059 divide -746.293386 927749.647 -> -0.000804412471 Inexact Rounded xdvi059 divideint -746.293386 927749.647 -> -0 xmul059 multiply -746.293386 927749.647 -> -692373425 Inexact Rounded xpow059 power -746.293386 927750 -> 7.49278741E+2665341 Inexact Rounded xrem059 remainder -746.293386 927749.647 -> -746.293386 xsub059 subtract -746.293386 927749.647 -> -928495.940 Inexact Rounded xadd060 add 888946471E+241331592 -235739.595 -> 8.88946471E+241331600 Inexact Rounded xcom060 compare 888946471E+241331592 -235739.595 -> 1 xdiv060 divide 888946471E+241331592 -235739.595 -> -3.77088317E+241331595 Inexact Rounded xdvi060 divideint 888946471E+241331592 -235739.595 -> NaN Division_impossible xmul060 multiply 888946471E+241331592 -235739.595 -> -2.09559881E+241331606 Inexact Rounded xpow060 power 888946471E+241331592 -235740 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem060 remainder 888946471E+241331592 -235739.595 -> NaN Division_impossible xsub060 subtract 888946471E+241331592 -235739.595 -> 8.88946471E+241331600 Inexact Rounded xadd061 add 6.64377249 79161.1070E+619453776 -> 7.91611070E+619453780 Inexact Rounded xcom061 compare 6.64377249 79161.1070E+619453776 -> -1 xdiv061 divide 6.64377249 79161.1070E+619453776 -> 8.39272307E-619453781 Inexact Rounded xdvi061 divideint 6.64377249 79161.1070E+619453776 -> 0 xmul061 multiply 6.64377249 79161.1070E+619453776 -> 5.25928385E+619453781 Inexact Rounded xpow061 power 6.64377249 8 -> 3795928.44 Inexact Rounded xrem061 remainder 6.64377249 79161.1070E+619453776 -> 6.64377249 xsub061 subtract 6.64377249 79161.1070E+619453776 -> -7.91611070E+619453780 Inexact Rounded xadd062 add 3146.66571E-313373366 88.5282010 -> 88.5282010 Inexact Rounded xcom062 compare 3146.66571E-313373366 88.5282010 -> -1 xdiv062 divide 3146.66571E-313373366 88.5282010 -> 3.55442184E-313373365 Inexact Rounded xdvi062 divideint 3146.66571E-313373366 88.5282010 -> 0 xmul062 multiply 3146.66571E-313373366 88.5282010 -> 2.78568654E-313373361 Inexact Rounded xpow062 power 3146.66571E-313373366 89 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem062 remainder 3146.66571E-313373366 88.5282010 -> 3.14666571E-313373363 xsub062 subtract 3146.66571E-313373366 88.5282010 -> -88.5282010 Inexact Rounded xadd063 add 6.44693097 -87195.8711 -> -87189.4242 Inexact Rounded xcom063 compare 6.44693097 -87195.8711 -> 1 xdiv063 divide 6.44693097 -87195.8711 -> -0.0000739361955 Inexact Rounded xdvi063 divideint 6.44693097 -87195.8711 -> -0 xmul063 multiply 6.44693097 -87195.8711 -> -562145.762 Inexact Rounded xpow063 power 6.44693097 -87196 -> 4.50881730E-70573 Inexact Rounded xrem063 remainder 6.44693097 -87195.8711 -> 6.44693097 xsub063 subtract 6.44693097 -87195.8711 -> 87202.3180 Inexact Rounded xadd064 add -2113132.56E+577957840 981125821 -> -2.11313256E+577957846 Inexact Rounded xcom064 compare -2113132.56E+577957840 981125821 -> -1 xdiv064 divide -2113132.56E+577957840 981125821 -> -2.15378345E+577957837 Inexact Rounded xdvi064 divideint -2113132.56E+577957840 981125821 -> NaN Division_impossible xmul064 multiply -2113132.56E+577957840 981125821 -> -2.07324892E+577957855 Inexact Rounded xpow064 power -2113132.56E+577957840 981125821 -> -Infinity Overflow Inexact Rounded xrem064 remainder -2113132.56E+577957840 981125821 -> NaN Division_impossible xsub064 subtract -2113132.56E+577957840 981125821 -> -2.11313256E+577957846 Inexact Rounded xadd065 add -7701.42814 72667.5181 -> 64966.0900 Inexact Rounded xcom065 compare -7701.42814 72667.5181 -> -1 xdiv065 divide -7701.42814 72667.5181 -> -0.105981714 Inexact Rounded xdvi065 divideint -7701.42814 72667.5181 -> -0 xmul065 multiply -7701.42814 72667.5181 -> -559643669 Inexact Rounded xpow065 power -7701.42814 72668 -> 2.29543837E+282429 Inexact Rounded xrem065 remainder -7701.42814 72667.5181 -> -7701.42814 xsub065 subtract -7701.42814 72667.5181 -> -80368.9462 Inexact Rounded xadd066 add -851.754789 -582659.149 -> -583510.904 Inexact Rounded xcom066 compare -851.754789 -582659.149 -> 1 xdiv066 divide -851.754789 -582659.149 -> 0.00146184058 Inexact Rounded xdvi066 divideint -851.754789 -582659.149 -> 0 xmul066 multiply -851.754789 -582659.149 -> 496282721 Inexact Rounded xpow066 power -851.754789 -582659 -> -6.83532593E-1707375 Inexact Rounded xrem066 remainder -851.754789 -582659.149 -> -851.754789 xsub066 subtract -851.754789 -582659.149 -> 581807.394 Inexact Rounded xadd067 add -5.01992943 7852.16531 -> 7847.14538 Inexact Rounded xcom067 compare -5.01992943 7852.16531 -> -1 xdiv067 divide -5.01992943 7852.16531 -> -0.000639305113 Inexact Rounded xdvi067 divideint -5.01992943 7852.16531 -> -0 xmul067 multiply -5.01992943 7852.16531 -> -39417.3157 Inexact Rounded xpow067 power -5.01992943 7852 -> 7.54481448E+5501 Inexact Rounded xrem067 remainder -5.01992943 7852.16531 -> -5.01992943 xsub067 subtract -5.01992943 7852.16531 -> -7857.18524 Inexact Rounded xadd068 add -12393257.2 76803689E+949125770 -> 7.68036890E+949125777 Inexact Rounded xcom068 compare -12393257.2 76803689E+949125770 -> -1 xdiv068 divide -12393257.2 76803689E+949125770 -> -1.61362786E-949125771 Inexact Rounded xdvi068 divideint -12393257.2 76803689E+949125770 -> -0 xmul068 multiply -12393257.2 76803689E+949125770 -> -9.51847872E+949125784 Inexact Rounded xpow068 power -12393257.2 8 -> 5.56523749E+56 Inexact Rounded xrem068 remainder -12393257.2 76803689E+949125770 -> -12393257.2 xsub068 subtract -12393257.2 76803689E+949125770 -> -7.68036890E+949125777 Inexact Rounded xadd069 add -754771634.E+716555026 -292336.311 -> -7.54771634E+716555034 Inexact Rounded xcom069 compare -754771634.E+716555026 -292336.311 -> -1 xdiv069 divide -754771634.E+716555026 -292336.311 -> 2.58186070E+716555029 Inexact Rounded xdvi069 divideint -754771634.E+716555026 -292336.311 -> NaN Division_impossible xmul069 multiply -754771634.E+716555026 -292336.311 -> 2.20647155E+716555040 Inexact Rounded xpow069 power -754771634.E+716555026 -292336 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem069 remainder -754771634.E+716555026 -292336.311 -> NaN Division_impossible xsub069 subtract -754771634.E+716555026 -292336.311 -> -7.54771634E+716555034 Inexact Rounded xadd070 add -915006.171E+614548652 -314086965. -> -9.15006171E+614548657 Inexact Rounded xcom070 compare -915006.171E+614548652 -314086965. -> -1 xdiv070 divide -915006.171E+614548652 -314086965. -> 2.91322555E+614548649 Inexact Rounded xdvi070 divideint -915006.171E+614548652 -314086965. -> NaN Division_impossible xmul070 multiply -915006.171E+614548652 -314086965. -> 2.87391511E+614548666 Inexact Rounded xpow070 power -915006.171E+614548652 -314086965 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem070 remainder -915006.171E+614548652 -314086965. -> NaN Division_impossible xsub070 subtract -915006.171E+614548652 -314086965. -> -9.15006171E+614548657 Inexact Rounded xadd071 add -296590035 -481734529 -> -778324564 xcom071 compare -296590035 -481734529 -> 1 xdiv071 divide -296590035 -481734529 -> 0.615671116 Inexact Rounded xdvi071 divideint -296590035 -481734529 -> 0 xmul071 multiply -296590035 -481734529 -> 1.42877661E+17 Inexact Rounded xpow071 power -296590035 -481734529 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem071 remainder -296590035 -481734529 -> -296590035 xsub071 subtract -296590035 -481734529 -> 185144494 xadd072 add 8.27822605 9241557.19 -> 9241565.47 Inexact Rounded xcom072 compare 8.27822605 9241557.19 -> -1 xdiv072 divide 8.27822605 9241557.19 -> 8.95760950E-7 Inexact Rounded xdvi072 divideint 8.27822605 9241557.19 -> 0 xmul072 multiply 8.27822605 9241557.19 -> 76503699.5 Inexact Rounded xpow072 power 8.27822605 9241557 -> 5.10219969E+8483169 Inexact Rounded xrem072 remainder 8.27822605 9241557.19 -> 8.27822605 xsub072 subtract 8.27822605 9241557.19 -> -9241548.91 Inexact Rounded xadd073 add -1.43581098 7286313.54 -> 7286312.10 Inexact Rounded xcom073 compare -1.43581098 7286313.54 -> -1 xdiv073 divide -1.43581098 7286313.54 -> -1.97055887E-7 Inexact Rounded xdvi073 divideint -1.43581098 7286313.54 -> -0 xmul073 multiply -1.43581098 7286313.54 -> -10461769.0 Inexact Rounded xpow073 power -1.43581098 7286314 -> 1.09389741E+1144660 Inexact Rounded xrem073 remainder -1.43581098 7286313.54 -> -1.43581098 xsub073 subtract -1.43581098 7286313.54 -> -7286314.98 Inexact Rounded xadd074 add -699036193. 759263.509E+533543625 -> 7.59263509E+533543630 Inexact Rounded xcom074 compare -699036193. 759263.509E+533543625 -> -1 xdiv074 divide -699036193. 759263.509E+533543625 -> -9.20676662E-533543623 Inexact Rounded xdvi074 divideint -699036193. 759263.509E+533543625 -> -0 xmul074 multiply -699036193. 759263.509E+533543625 -> -5.30752673E+533543639 Inexact Rounded xpow074 power -699036193. 8 -> 5.70160724E+70 Inexact Rounded xrem074 remainder -699036193. 759263.509E+533543625 -> -699036193 xsub074 subtract -699036193. 759263.509E+533543625 -> -7.59263509E+533543630 Inexact Rounded xadd075 add -83.7273615E-305281957 -287779593.E+458777774 -> -2.87779593E+458777782 Inexact Rounded xcom075 compare -83.7273615E-305281957 -287779593.E+458777774 -> 1 xdiv075 divide -83.7273615E-305281957 -287779593.E+458777774 -> 2.90942664E-764059738 Inexact Rounded xdvi075 divideint -83.7273615E-305281957 -287779593.E+458777774 -> 0 xmul075 multiply -83.7273615E-305281957 -287779593.E+458777774 -> 2.40950260E+153495827 Inexact Rounded xpow075 power -83.7273615E-305281957 -3 -> -1.70371828E+915845865 Inexact Rounded xrem075 remainder -83.7273615E-305281957 -287779593.E+458777774 -> -8.37273615E-305281956 xsub075 subtract -83.7273615E-305281957 -287779593.E+458777774 -> 2.87779593E+458777782 Inexact Rounded xadd076 add 8.48503224 6522.03316 -> 6530.51819 Inexact Rounded xcom076 compare 8.48503224 6522.03316 -> -1 xdiv076 divide 8.48503224 6522.03316 -> 0.00130097962 Inexact Rounded xdvi076 divideint 8.48503224 6522.03316 -> 0 xmul076 multiply 8.48503224 6522.03316 -> 55339.6616 Inexact Rounded xpow076 power 8.48503224 6522 -> 4.76547542E+6056 Inexact Rounded xrem076 remainder 8.48503224 6522.03316 -> 8.48503224 xsub076 subtract 8.48503224 6522.03316 -> -6513.54813 Inexact Rounded xadd077 add 527916091 -809.054070 -> 527915282 Inexact Rounded xcom077 compare 527916091 -809.054070 -> 1 xdiv077 divide 527916091 -809.054070 -> -652510.272 Inexact Rounded xdvi077 divideint 527916091 -809.054070 -> -652510 xmul077 multiply 527916091 -809.054070 -> -4.27112662E+11 Inexact Rounded xpow077 power 527916091 -809 -> 2.78609697E-7057 Inexact Rounded xrem077 remainder 527916091 -809.054070 -> 219.784300 xsub077 subtract 527916091 -809.054070 -> 527916900 Inexact Rounded xadd078 add 3857058.60 5792997.58E+881077409 -> 5.79299758E+881077415 Inexact Rounded xcom078 compare 3857058.60 5792997.58E+881077409 -> -1 xdiv078 divide 3857058.60 5792997.58E+881077409 -> 6.65813950E-881077410 Inexact Rounded xdvi078 divideint 3857058.60 5792997.58E+881077409 -> 0 xmul078 multiply 3857058.60 5792997.58E+881077409 -> 2.23439311E+881077422 Inexact Rounded xpow078 power 3857058.60 6 -> 3.29258824E+39 Inexact Rounded xrem078 remainder 3857058.60 5792997.58E+881077409 -> 3857058.60 xsub078 subtract 3857058.60 5792997.58E+881077409 -> -5.79299758E+881077415 Inexact Rounded xadd079 add -66587363.E+556538173 -551902402E+357309146 -> -6.65873630E+556538180 Inexact Rounded xcom079 compare -66587363.E+556538173 -551902402E+357309146 -> -1 xdiv079 divide -66587363.E+556538173 -551902402E+357309146 -> 1.20650613E+199229026 Inexact Rounded xdvi079 divideint -66587363.E+556538173 -551902402E+357309146 -> NaN Division_impossible xmul079 multiply -66587363.E+556538173 -551902402E+357309146 -> 3.67497256E+913847335 Inexact Rounded xpow079 power -66587363.E+556538173 -6 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem079 remainder -66587363.E+556538173 -551902402E+357309146 -> NaN Division_impossible xsub079 subtract -66587363.E+556538173 -551902402E+357309146 -> -6.65873630E+556538180 Inexact Rounded xadd080 add -580.502955 38125521.7 -> 38124941.2 Inexact Rounded xcom080 compare -580.502955 38125521.7 -> -1 xdiv080 divide -580.502955 38125521.7 -> -0.0000152260987 Inexact Rounded xdvi080 divideint -580.502955 38125521.7 -> -0 xmul080 multiply -580.502955 38125521.7 -> -2.21319780E+10 Inexact Rounded xpow080 power -580.502955 38125522 -> 6.07262078E+105371486 Inexact Rounded xrem080 remainder -580.502955 38125521.7 -> -580.502955 xsub080 subtract -580.502955 38125521.7 -> -38126102.2 Inexact Rounded xadd081 add -9627363.00 -80616885E-749891394 -> -9627363.00 Inexact Rounded xcom081 compare -9627363.00 -80616885E-749891394 -> -1 xdiv081 divide -9627363.00 -80616885E-749891394 -> 1.19421173E+749891393 Inexact Rounded xdvi081 divideint -9627363.00 -80616885E-749891394 -> NaN Division_impossible xmul081 multiply -9627363.00 -80616885E-749891394 -> 7.76128016E-749891380 Inexact Rounded xpow081 power -9627363.00 -8 -> 1.35500601E-56 Inexact Rounded xrem081 remainder -9627363.00 -80616885E-749891394 -> NaN Division_impossible xsub081 subtract -9627363.00 -80616885E-749891394 -> -9627363.00 Inexact Rounded xadd082 add -526.594855E+803110107 -64.5451639 -> -5.26594855E+803110109 Inexact Rounded xcom082 compare -526.594855E+803110107 -64.5451639 -> -1 xdiv082 divide -526.594855E+803110107 -64.5451639 -> 8.15854858E+803110107 Inexact Rounded xdvi082 divideint -526.594855E+803110107 -64.5451639 -> NaN Division_impossible xmul082 multiply -526.594855E+803110107 -64.5451639 -> 3.39891512E+803110111 Inexact Rounded xpow082 power -526.594855E+803110107 -65 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem082 remainder -526.594855E+803110107 -64.5451639 -> NaN Division_impossible xsub082 subtract -526.594855E+803110107 -64.5451639 -> -5.26594855E+803110109 Inexact Rounded xadd083 add -8378.55499 760.131257 -> -7618.42373 Inexact Rounded xcom083 compare -8378.55499 760.131257 -> -1 xdiv083 divide -8378.55499 760.131257 -> -11.0225108 Inexact Rounded xdvi083 divideint -8378.55499 760.131257 -> -11 xmul083 multiply -8378.55499 760.131257 -> -6368801.54 Inexact Rounded xpow083 power -8378.55499 760 -> 4.06007928E+2981 Inexact Rounded xrem083 remainder -8378.55499 760.131257 -> -17.111163 xsub083 subtract -8378.55499 760.131257 -> -9138.68625 Inexact Rounded xadd084 add -717.697718 984304413 -> 984303695 Inexact Rounded xcom084 compare -717.697718 984304413 -> -1 xdiv084 divide -717.697718 984304413 -> -7.29142030E-7 Inexact Rounded xdvi084 divideint -717.697718 984304413 -> -0 xmul084 multiply -717.697718 984304413 -> -7.06433031E+11 Inexact Rounded xpow084 power -717.697718 984304413 -> -Infinity Overflow Inexact Rounded xrem084 remainder -717.697718 984304413 -> -717.697718 xsub084 subtract -717.697718 984304413 -> -984305131 Inexact Rounded xadd085 add -76762243.4E-741100094 -273.706674 -> -273.706674 Inexact Rounded xcom085 compare -76762243.4E-741100094 -273.706674 -> 1 xdiv085 divide -76762243.4E-741100094 -273.706674 -> 2.80454409E-741100089 Inexact Rounded xdvi085 divideint -76762243.4E-741100094 -273.706674 -> 0 xmul085 multiply -76762243.4E-741100094 -273.706674 -> 2.10103383E-741100084 Inexact Rounded xpow085 power -76762243.4E-741100094 -274 -> Infinity Overflow Inexact Rounded xrem085 remainder -76762243.4E-741100094 -273.706674 -> -7.67622434E-741100087 xsub085 subtract -76762243.4E-741100094 -273.706674 -> 273.706674 Inexact Rounded xadd086 add -701.518354E+786274918 8822750.68E+243052107 -> -7.01518354E+786274920 Inexact Rounded xcom086 compare -701.518354E+786274918 8822750.68E+243052107 -> -1 xdiv086 divide -701.518354E+786274918 8822750.68E+243052107 -> -7.95124309E+543222806 Inexact Rounded xdvi086 divideint -701.518354E+786274918 8822750.68E+243052107 -> NaN Division_impossible xmul086 multiply -701.518354E+786274918 8822750.68E+243052107 -> -Infinity Inexact Overflow Rounded xpow086 power -701.518354E+786274918 9 -> -Infinity Overflow Inexact Rounded xrem086 remainder -701.518354E+786274918 8822750.68E+243052107 -> NaN Division_impossible xsub086 subtract -701.518354E+786274918 8822750.68E+243052107 -> -7.01518354E+786274920 Inexact Rounded xadd087 add -359866845. -4.57434117 -> -359866850 Inexact Rounded xcom087 compare -359866845. -4.57434117 -> -1 xdiv087 divide -359866845. -4.57434117 -> 78670748.8 Inexact Rounded xdvi087 divideint -359866845. -4.57434117 -> 78670748 xmul087 multiply -359866845. -4.57434117 -> 1.64615372E+9 Inexact Rounded xpow087 power -359866845. -5 -> -1.65687909E-43 Inexact Rounded xrem087 remainder -359866845. -4.57434117 -> -3.54890484 xsub087 subtract -359866845. -4.57434117 -> -359866840 Inexact Rounded xadd088 add 779934536. -76562645.7 -> 703371890 Inexact Rounded xcom088 compare 779934536. -76562645.7 -> 1 xdiv088 divide 779934536. -76562645.7 -> -10.1868807 Inexact Rounded xdvi088 divideint 779934536. -76562645.7 -> -10 xmul088 multiply 779934536. -76562645.7 -> -5.97138515E+16 Inexact Rounded xpow088 power 779934536. -76562646 -> 3.36739063E-680799501 Inexact Rounded xrem088 remainder 779934536. -76562645.7 -> 14308079.0 xsub088 subtract 779934536. -76562645.7 -> 856497182 Inexact Rounded xadd089 add -4820.95451 3516234.99E+303303176 -> 3.51623499E+303303182 Inexact Rounded xcom089 compare -4820.95451 3516234.99E+303303176 -> -1 xdiv089 divide -4820.95451 3516234.99E+303303176 -> -1.37105584E-303303179 Inexact Rounded xdvi089 divideint -4820.95451 3516234.99E+303303176 -> -0 xmul089 multiply -4820.95451 3516234.99E+303303176 -> -1.69516089E+303303186 Inexact Rounded xpow089 power -4820.95451 4 -> 5.40172082E+14 Inexact Rounded xrem089 remainder -4820.95451 3516234.99E+303303176 -> -4820.95451 xsub089 subtract -4820.95451 3516234.99E+303303176 -> -3.51623499E+303303182 Inexact Rounded xadd090 add 69355976.9 -9.57838562E+758804984 -> -9.57838562E+758804984 Inexact Rounded xcom090 compare 69355976.9 -9.57838562E+758804984 -> 1 xdiv090 divide 69355976.9 -9.57838562E+758804984 -> -7.24088376E-758804978 Inexact Rounded xdvi090 divideint 69355976.9 -9.57838562E+758804984 -> -0 xmul090 multiply 69355976.9 -9.57838562E+758804984 -> -6.64318292E+758804992 Inexact Rounded xpow090 power 69355976.9 -10 -> 3.88294346E-79 Inexact Rounded xrem090 remainder 69355976.9 -9.57838562E+758804984 -> 69355976.9 xsub090 subtract 69355976.9 -9.57838562E+758804984 -> 9.57838562E+758804984 Inexact Rounded xadd091 add -12672093.1 8569.78255E-382866025 -> -12672093.1 Inexact Rounded xcom091 compare -12672093.1 8569.78255E-382866025 -> -1 xdiv091 divide -12672093.1 8569.78255E-382866025 -> -1.47869482E+382866028 Inexact Rounded xdvi091 divideint -12672093.1 8569.78255E-382866025 -> NaN Division_impossible xmul091 multiply -12672093.1 8569.78255E-382866025 -> -1.08597082E-382866014 Inexact Rounded xpow091 power -12672093.1 9 -> -8.42626658E+63 Inexact Rounded xrem091 remainder -12672093.1 8569.78255E-382866025 -> NaN Division_impossible xsub091 subtract -12672093.1 8569.78255E-382866025 -> -12672093.1 Inexact Rounded xadd092 add -5910750.2 66150383E-662459241 -> -5910750.20 Inexact Rounded xcom092 compare -5910750.2 66150383E-662459241 -> -1 xdiv092 divide -5910750.2 66150383E-662459241 -> -8.93532272E+662459239 Inexact Rounded xdvi092 divideint -5910750.2 66150383E-662459241 -> NaN Division_impossible xmul092 multiply -5910750.2 66150383E-662459241 -> -3.90998390E-662459227 Inexact Rounded xpow092 power -5910750.2 7 -> -2.52056696E+47 Inexact Rounded xrem092 remainder -5910750.2 66150383E-662459241 -> NaN Division_impossible xsub092 subtract -5910750.2 66150383E-662459241 -> -5910750.20 Inexact Rounded xadd093 add -532577268.E-163806629 -240650398E-650110558 -> -5.32577268E-163806621 Inexact Rounded xcom093 compare -532577268.E-163806629 -240650398E-650110558 -> -1 xdiv093 divide -532577268.E-163806629 -240650398E-650110558 -> 2.21307454E+486303929 Inexact Rounded xdvi093 divideint -532577268.E-163806629 -240650398E-650110558 -> NaN Division_impossible xmul093 multiply -532577268.E-163806629 -240650398E-650110558 -> 1.28164932E-813917170 Inexact Rounded xpow093 power -532577268.E-163806629 -2 -> 3.52561389E+327613240 Inexact Rounded xrem093 remainder -532577268.E-163806629 -240650398E-650110558 -> NaN Division_impossible xsub093 subtract -532577268.E-163806629 -240650398E-650110558 -> -5.32577268E-163806621 Inexact Rounded xadd094 add -671.507198E-908587890 3057429.32E-555230623 -> 3.05742932E-555230617 Inexact Rounded xcom094 compare -671.507198E-908587890 3057429.32E-555230623 -> -1 xdiv094 divide -671.507198E-908587890 3057429.32E-555230623 -> -2.19631307E-353357271 Inexact Rounded xdvi094 divideint -671.507198E-908587890 3057429.32E-555230623 -> -0 xmul094 multiply -671.507198E-908587890 3057429.32E-555230623 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow094 power -671.507198E-908587890 3 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem094 remainder -671.507198E-908587890 3057429.32E-555230623 -> -6.71507198E-908587888 xsub094 subtract -671.507198E-908587890 3057429.32E-555230623 -> -3.05742932E-555230617 Inexact Rounded xadd095 add -294.994352E+346452027 -6061853.0 -> -2.94994352E+346452029 Inexact Rounded xcom095 compare -294.994352E+346452027 -6061853.0 -> -1 xdiv095 divide -294.994352E+346452027 -6061853.0 -> 4.86640557E+346452022 Inexact Rounded xdvi095 divideint -294.994352E+346452027 -6061853.0 -> NaN Division_impossible xmul095 multiply -294.994352E+346452027 -6061853.0 -> 1.78821240E+346452036 Inexact Rounded xpow095 power -294.994352E+346452027 -6061853 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem095 remainder -294.994352E+346452027 -6061853.0 -> NaN Division_impossible xsub095 subtract -294.994352E+346452027 -6061853.0 -> -2.94994352E+346452029 Inexact Rounded xadd096 add 329579114 146780548. -> 476359662 xcom096 compare 329579114 146780548. -> 1 xdiv096 divide 329579114 146780548. -> 2.24538686 Inexact Rounded xdvi096 divideint 329579114 146780548. -> 2 xmul096 multiply 329579114 146780548. -> 4.83758030E+16 Inexact Rounded xpow096 power 329579114 146780548 -> Infinity Overflow Inexact Rounded xrem096 remainder 329579114 146780548. -> 36018018 xsub096 subtract 329579114 146780548. -> 182798566 xadd097 add -789904.686E-217225000 -1991.07181E-84080059 -> -1.99107181E-84080056 Inexact Rounded xcom097 compare -789904.686E-217225000 -1991.07181E-84080059 -> 1 xdiv097 divide -789904.686E-217225000 -1991.07181E-84080059 -> 3.96723354E-133144939 Inexact Rounded xdvi097 divideint -789904.686E-217225000 -1991.07181E-84080059 -> 0 xmul097 multiply -789904.686E-217225000 -1991.07181E-84080059 -> 1.57275695E-301305050 Inexact Rounded xpow097 power -789904.686E-217225000 -2 -> 1.60269403E+434449988 Inexact Rounded xrem097 remainder -789904.686E-217225000 -1991.07181E-84080059 -> -7.89904686E-217224995 xsub097 subtract -789904.686E-217225000 -1991.07181E-84080059 -> 1.99107181E-84080056 Inexact Rounded xadd098 add 59893.3544 -408595868 -> -408535975 Inexact Rounded xcom098 compare 59893.3544 -408595868 -> 1 xdiv098 divide 59893.3544 -408595868 -> -0.000146583358 Inexact Rounded xdvi098 divideint 59893.3544 -408595868 -> -0 xmul098 multiply 59893.3544 -408595868 -> -2.44721771E+13 Inexact Rounded xpow098 power 59893.3544 -408595868 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem098 remainder 59893.3544 -408595868 -> 59893.3544 xsub098 subtract 59893.3544 -408595868 -> 408655761 Inexact Rounded xadd099 add 129.878613 -54652.7288E-963564940 -> 129.878613 Inexact Rounded xcom099 compare 129.878613 -54652.7288E-963564940 -> 1 xdiv099 divide 129.878613 -54652.7288E-963564940 -> -2.37643418E+963564937 Inexact Rounded xdvi099 divideint 129.878613 -54652.7288E-963564940 -> NaN Division_impossible xmul099 multiply 129.878613 -54652.7288E-963564940 -> -7.09822061E-963564934 Inexact Rounded xpow099 power 129.878613 -5 -> 2.70590029E-11 Inexact Rounded xrem099 remainder 129.878613 -54652.7288E-963564940 -> NaN Division_impossible xsub099 subtract 129.878613 -54652.7288E-963564940 -> 129.878613 Inexact Rounded xadd100 add 9866.99208 708756501. -> 708766368 Inexact Rounded xcom100 compare 9866.99208 708756501. -> -1 xdiv100 divide 9866.99208 708756501. -> 0.0000139215543 Inexact Rounded xdvi100 divideint 9866.99208 708756501. -> 0 xmul100 multiply 9866.99208 708756501. -> 6.99329478E+12 Inexact Rounded xpow100 power 9866.99208 708756501 -> Infinity Overflow Inexact Rounded xrem100 remainder 9866.99208 708756501. -> 9866.99208 xsub100 subtract 9866.99208 708756501. -> -708746634 Inexact Rounded xadd101 add -78810.6297 -399884.68 -> -478695.310 Inexact Rounded xcom101 compare -78810.6297 -399884.68 -> 1 xdiv101 divide -78810.6297 -399884.68 -> 0.197083393 Inexact Rounded xdvi101 divideint -78810.6297 -399884.68 -> 0 xmul101 multiply -78810.6297 -399884.68 -> 3.15151634E+10 Inexact Rounded xpow101 power -78810.6297 -399885 -> -1.54252408E-1958071 Inexact Rounded xrem101 remainder -78810.6297 -399884.68 -> -78810.6297 xsub101 subtract -78810.6297 -399884.68 -> 321074.050 Inexact Rounded xadd102 add 409189761 -771.471460 -> 409188990 Inexact Rounded xcom102 compare 409189761 -771.471460 -> 1 xdiv102 divide 409189761 -771.471460 -> -530401.683 Inexact Rounded xdvi102 divideint 409189761 -771.471460 -> -530401 xmul102 multiply 409189761 -771.471460 -> -3.15678222E+11 Inexact Rounded xpow102 power 409189761 -771 -> 1.60698414E-6640 Inexact Rounded xrem102 remainder 409189761 -771.471460 -> 527.144540 xsub102 subtract 409189761 -771.471460 -> 409190532 Inexact Rounded xadd103 add -1.68748838 460.46924 -> 458.781752 Inexact Rounded xcom103 compare -1.68748838 460.46924 -> -1 xdiv103 divide -1.68748838 460.46924 -> -0.00366471467 Inexact Rounded xdvi103 divideint -1.68748838 460.46924 -> -0 xmul103 multiply -1.68748838 460.46924 -> -777.036492 Inexact Rounded xpow103 power -1.68748838 460 -> 3.39440648E+104 Inexact Rounded xrem103 remainder -1.68748838 460.46924 -> -1.68748838 xsub103 subtract -1.68748838 460.46924 -> -462.156728 Inexact Rounded xadd104 add 553527296. -7924.40185 -> 553519372 Inexact Rounded xcom104 compare 553527296. -7924.40185 -> 1 xdiv104 divide 553527296. -7924.40185 -> -69850.9877 Inexact Rounded xdvi104 divideint 553527296. -7924.40185 -> -69850 xmul104 multiply 553527296. -7924.40185 -> -4.38637273E+12 Inexact Rounded xpow104 power 553527296. -7924 -> 2.32397214E-69281 Inexact Rounded xrem104 remainder 553527296. -7924.40185 -> 7826.77750 xsub104 subtract 553527296. -7924.40185 -> 553535220 Inexact Rounded xadd105 add -38.7465207 64936.2942 -> 64897.5477 Inexact Rounded xcom105 compare -38.7465207 64936.2942 -> -1 xdiv105 divide -38.7465207 64936.2942 -> -0.000596685123 Inexact Rounded xdvi105 divideint -38.7465207 64936.2942 -> -0 xmul105 multiply -38.7465207 64936.2942 -> -2516055.47 Inexact Rounded xpow105 power -38.7465207 64936 -> 3.01500762E+103133 Inexact Rounded xrem105 remainder -38.7465207 64936.2942 -> -38.7465207 xsub105 subtract -38.7465207 64936.2942 -> -64975.0407 Inexact Rounded xadd106 add -201075.248 845.663928 -> -200229.584 Inexact Rounded xcom106 compare -201075.248 845.663928 -> -1 xdiv106 divide -201075.248 845.663928 -> -237.772053 Inexact Rounded xdvi106 divideint -201075.248 845.663928 -> -237 xmul106 multiply -201075.248 845.663928 -> -170042084 Inexact Rounded xpow106 power -201075.248 846 -> 4.37911767E+4486 Inexact Rounded xrem106 remainder -201075.248 845.663928 -> -652.897064 xsub106 subtract -201075.248 845.663928 -> -201920.912 Inexact Rounded xadd107 add 91048.4559 75953609.3 -> 76044657.8 Inexact Rounded xcom107 compare 91048.4559 75953609.3 -> -1 xdiv107 divide 91048.4559 75953609.3 -> 0.00119873771 Inexact Rounded xdvi107 divideint 91048.4559 75953609.3 -> 0 xmul107 multiply 91048.4559 75953609.3 -> 6.91545885E+12 Inexact Rounded xpow107 power 91048.4559 75953609 -> 6.94467746E+376674650 Inexact Rounded xrem107 remainder 91048.4559 75953609.3 -> 91048.4559 xsub107 subtract 91048.4559 75953609.3 -> -75862560.8 Inexact Rounded xadd108 add 6898273.86E-252097460 15.3456196 -> 15.3456196 Inexact Rounded xcom108 compare 6898273.86E-252097460 15.3456196 -> -1 xdiv108 divide 6898273.86E-252097460 15.3456196 -> 4.49527229E-252097455 Inexact Rounded xdvi108 divideint 6898273.86E-252097460 15.3456196 -> 0 xmul108 multiply 6898273.86E-252097460 15.3456196 -> 1.05858287E-252097452 Inexact Rounded xpow108 power 6898273.86E-252097460 15 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem108 remainder 6898273.86E-252097460 15.3456196 -> 6.89827386E-252097454 xsub108 subtract 6898273.86E-252097460 15.3456196 -> -15.3456196 Inexact Rounded xadd109 add 88.4370343 -980709105E-869899289 -> 88.4370343 Inexact Rounded xcom109 compare 88.4370343 -980709105E-869899289 -> 1 xdiv109 divide 88.4370343 -980709105E-869899289 -> -9.01766220E+869899281 Inexact Rounded xdvi109 divideint 88.4370343 -980709105E-869899289 -> NaN Division_impossible xmul109 multiply 88.4370343 -980709105E-869899289 -> -8.67310048E-869899279 Inexact Rounded xpow109 power 88.4370343 -10 -> 3.41710479E-20 Inexact Rounded xrem109 remainder 88.4370343 -980709105E-869899289 -> NaN Division_impossible xsub109 subtract 88.4370343 -980709105E-869899289 -> 88.4370343 Inexact Rounded xadd110 add -17643.39 2.0352568E+304871331 -> 2.03525680E+304871331 Inexact Rounded xcom110 compare -17643.39 2.0352568E+304871331 -> -1 xdiv110 divide -17643.39 2.0352568E+304871331 -> -8.66887658E-304871328 Inexact Rounded xdvi110 divideint -17643.39 2.0352568E+304871331 -> -0 xmul110 multiply -17643.39 2.0352568E+304871331 -> -3.59088295E+304871335 Inexact Rounded xpow110 power -17643.39 2 -> 311289211 Inexact Rounded xrem110 remainder -17643.39 2.0352568E+304871331 -> -17643.39 xsub110 subtract -17643.39 2.0352568E+304871331 -> -2.03525680E+304871331 Inexact Rounded xadd111 add 4589785.16 7459.04237 -> 4597244.20 Inexact Rounded xcom111 compare 4589785.16 7459.04237 -> 1 xdiv111 divide 4589785.16 7459.04237 -> 615.331692 Inexact Rounded xdvi111 divideint 4589785.16 7459.04237 -> 615 xmul111 multiply 4589785.16 7459.04237 -> 3.42354020E+10 Inexact Rounded xpow111 power 4589785.16 7459 -> 2.03795258E+49690 Inexact Rounded xrem111 remainder 4589785.16 7459.04237 -> 2474.10245 xsub111 subtract 4589785.16 7459.04237 -> 4582326.12 Inexact Rounded xadd112 add -51.1632090E-753968082 8.96207471E-585797887 -> 8.96207471E-585797887 Inexact Rounded xcom112 compare -51.1632090E-753968082 8.96207471E-585797887 -> -1 xdiv112 divide -51.1632090E-753968082 8.96207471E-585797887 -> -5.70885768E-168170195 Inexact Rounded xdvi112 divideint -51.1632090E-753968082 8.96207471E-585797887 -> -0 xmul112 multiply -51.1632090E-753968082 8.96207471E-585797887 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow112 power -51.1632090E-753968082 9 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem112 remainder -51.1632090E-753968082 8.96207471E-585797887 -> -5.11632090E-753968081 xsub112 subtract -51.1632090E-753968082 8.96207471E-585797887 -> -8.96207471E-585797887 Inexact Rounded xadd113 add 982.217817 7224909.4E-45243816 -> 982.217817 Inexact Rounded xcom113 compare 982.217817 7224909.4E-45243816 -> 1 xdiv113 divide 982.217817 7224909.4E-45243816 -> 1.35948807E+45243812 Inexact Rounded xdvi113 divideint 982.217817 7224909.4E-45243816 -> NaN Division_impossible xmul113 multiply 982.217817 7224909.4E-45243816 -> 7.09643474E-45243807 Inexact Rounded xpow113 power 982.217817 7 -> 8.81971709E+20 Inexact Rounded xrem113 remainder 982.217817 7224909.4E-45243816 -> NaN Division_impossible xsub113 subtract 982.217817 7224909.4E-45243816 -> 982.217817 Inexact Rounded xadd114 add 503712056. -57490703.5E+924890183 -> -5.74907035E+924890190 Inexact Rounded xcom114 compare 503712056. -57490703.5E+924890183 -> 1 xdiv114 divide 503712056. -57490703.5E+924890183 -> -8.76162623E-924890183 Inexact Rounded xdvi114 divideint 503712056. -57490703.5E+924890183 -> -0 xmul114 multiply 503712056. -57490703.5E+924890183 -> -2.89587605E+924890199 Inexact Rounded xpow114 power 503712056. -6 -> 6.12217764E-53 Inexact Rounded xrem114 remainder 503712056. -57490703.5E+924890183 -> 503712056 xsub114 subtract 503712056. -57490703.5E+924890183 -> 5.74907035E+924890190 Inexact Rounded xadd115 add 883.849223 249259171 -> 249260055 Inexact Rounded xcom115 compare 883.849223 249259171 -> -1 xdiv115 divide 883.849223 249259171 -> 0.00000354590453 Inexact Rounded xdvi115 divideint 883.849223 249259171 -> 0 xmul115 multiply 883.849223 249259171 -> 2.20307525E+11 Inexact Rounded xpow115 power 883.849223 249259171 -> 5.15642844E+734411783 Inexact Rounded xrem115 remainder 883.849223 249259171 -> 883.849223 xsub115 subtract 883.849223 249259171 -> -249258287 Inexact Rounded xadd116 add 245.092853E+872642874 828195.152E+419771532 -> 2.45092853E+872642876 Inexact Rounded xcom116 compare 245.092853E+872642874 828195.152E+419771532 -> 1 xdiv116 divide 245.092853E+872642874 828195.152E+419771532 -> 2.95936112E+452871338 Inexact Rounded xdvi116 divideint 245.092853E+872642874 828195.152E+419771532 -> NaN Division_impossible xmul116 multiply 245.092853E+872642874 828195.152E+419771532 -> Infinity Inexact Overflow Rounded xpow116 power 245.092853E+872642874 8 -> Infinity Overflow Inexact Rounded xrem116 remainder 245.092853E+872642874 828195.152E+419771532 -> NaN Division_impossible xsub116 subtract 245.092853E+872642874 828195.152E+419771532 -> 2.45092853E+872642876 Inexact Rounded xadd117 add -83658638.6E+728551928 2952478.42 -> -8.36586386E+728551935 Inexact Rounded xcom117 compare -83658638.6E+728551928 2952478.42 -> -1 xdiv117 divide -83658638.6E+728551928 2952478.42 -> -2.83350551E+728551929 Inexact Rounded xdvi117 divideint -83658638.6E+728551928 2952478.42 -> NaN Division_impossible xmul117 multiply -83658638.6E+728551928 2952478.42 -> -2.47000325E+728551942 Inexact Rounded xpow117 power -83658638.6E+728551928 2952478 -> Infinity Overflow Inexact Rounded xrem117 remainder -83658638.6E+728551928 2952478.42 -> NaN Division_impossible xsub117 subtract -83658638.6E+728551928 2952478.42 -> -8.36586386E+728551935 Inexact Rounded xadd118 add -6291780.97 269967.394E-22000817 -> -6291780.97 Inexact Rounded xcom118 compare -6291780.97 269967.394E-22000817 -> -1 xdiv118 divide -6291780.97 269967.394E-22000817 -> -2.33057069E+22000818 Inexact Rounded xdvi118 divideint -6291780.97 269967.394E-22000817 -> NaN Division_impossible xmul118 multiply -6291780.97 269967.394E-22000817 -> -1.69857571E-22000805 Inexact Rounded xpow118 power -6291780.97 3 -> -2.49069636E+20 Inexact Rounded xrem118 remainder -6291780.97 269967.394E-22000817 -> NaN Division_impossible xsub118 subtract -6291780.97 269967.394E-22000817 -> -6291780.97 Inexact Rounded xadd119 add 978571348.E+222382547 6006.19370 -> 9.78571348E+222382555 Inexact Rounded xcom119 compare 978571348.E+222382547 6006.19370 -> 1 xdiv119 divide 978571348.E+222382547 6006.19370 -> 1.62927038E+222382552 Inexact Rounded xdvi119 divideint 978571348.E+222382547 6006.19370 -> NaN Division_impossible xmul119 multiply 978571348.E+222382547 6006.19370 -> 5.87748907E+222382559 Inexact Rounded xpow119 power 978571348.E+222382547 6006 -> Infinity Overflow Inexact Rounded xrem119 remainder 978571348.E+222382547 6006.19370 -> NaN Division_impossible xsub119 subtract 978571348.E+222382547 6006.19370 -> 9.78571348E+222382555 Inexact Rounded xadd120 add 14239029. -36527.2221 -> 14202501.8 Inexact Rounded xcom120 compare 14239029. -36527.2221 -> 1 xdiv120 divide 14239029. -36527.2221 -> -389.819652 Inexact Rounded xdvi120 divideint 14239029. -36527.2221 -> -389 xmul120 multiply 14239029. -36527.2221 -> -5.20112175E+11 Inexact Rounded xpow120 power 14239029. -36527 -> 6.64292731E-261296 Inexact Rounded xrem120 remainder 14239029. -36527.2221 -> 29939.6031 xsub120 subtract 14239029. -36527.2221 -> 14275556.2 Inexact Rounded xadd121 add 72333.2654E-544425548 -690.664836E+662155120 -> -6.90664836E+662155122 Inexact Rounded xcom121 compare 72333.2654E-544425548 -690.664836E+662155120 -> 1 xdiv121 divide 72333.2654E-544425548 -690.664836E+662155120 -> -0E-1000000007 Inexact Rounded Underflow Subnormal Clamped xdvi121 divideint 72333.2654E-544425548 -690.664836E+662155120 -> -0 xmul121 multiply 72333.2654E-544425548 -690.664836E+662155120 -> -4.99580429E+117729579 Inexact Rounded xpow121 power 72333.2654E-544425548 -7 -> Infinity Overflow Inexact Rounded xrem121 remainder 72333.2654E-544425548 -690.664836E+662155120 -> 7.23332654E-544425544 xsub121 subtract 72333.2654E-544425548 -690.664836E+662155120 -> 6.90664836E+662155122 Inexact Rounded xadd122 add -37721.1567E-115787341 -828949864E-76251747 -> -8.28949864E-76251739 Inexact Rounded xcom122 compare -37721.1567E-115787341 -828949864E-76251747 -> 1 xdiv122 divide -37721.1567E-115787341 -828949864E-76251747 -> 4.55047505E-39535599 Inexact Rounded xdvi122 divideint -37721.1567E-115787341 -828949864E-76251747 -> 0 xmul122 multiply -37721.1567E-115787341 -828949864E-76251747 -> 3.12689477E-192039075 Inexact Rounded xpow122 power -37721.1567E-115787341 -8 -> 2.43960765E+926298691 Inexact Rounded xrem122 remainder -37721.1567E-115787341 -828949864E-76251747 -> -3.77211567E-115787337 xsub122 subtract -37721.1567E-115787341 -828949864E-76251747 -> 8.28949864E-76251739 Inexact Rounded xadd123 add -2078852.83E-647080089 -119779858.E+734665461 -> -1.19779858E+734665469 Inexact Rounded xcom123 compare -2078852.83E-647080089 -119779858.E+734665461 -> 1 xdiv123 divide -2078852.83E-647080089 -119779858.E+734665461 -> 0E-1000000007 Inexact Rounded Underflow Subnormal Clamped xdvi123 divideint -2078852.83E-647080089 -119779858.E+734665461 -> 0 xmul123 multiply -2078852.83E-647080089 -119779858.E+734665461 -> 2.49004697E+87585386 Inexact Rounded xpow123 power -2078852.83E-647080089 -1 -> -4.81034533E+647080082 Inexact Rounded xrem123 remainder -2078852.83E-647080089 -119779858.E+734665461 -> -2.07885283E-647080083 xsub123 subtract -2078852.83E-647080089 -119779858.E+734665461 -> 1.19779858E+734665469 Inexact Rounded xadd124 add -79145.3625 -7718.57307 -> -86863.9356 Inexact Rounded xcom124 compare -79145.3625 -7718.57307 -> -1 xdiv124 divide -79145.3625 -7718.57307 -> 10.2538852 Inexact Rounded xdvi124 divideint -79145.3625 -7718.57307 -> 10 xmul124 multiply -79145.3625 -7718.57307 -> 610889264 Inexact Rounded xpow124 power -79145.3625 -7719 -> -1.13181941E-37811 Inexact Rounded xrem124 remainder -79145.3625 -7718.57307 -> -1959.63180 xsub124 subtract -79145.3625 -7718.57307 -> -71426.7894 Inexact Rounded xadd125 add 2103890.49E+959247237 20024.3017 -> 2.10389049E+959247243 Inexact Rounded xcom125 compare 2103890.49E+959247237 20024.3017 -> 1 xdiv125 divide 2103890.49E+959247237 20024.3017 -> 1.05066859E+959247239 Inexact Rounded xdvi125 divideint 2103890.49E+959247237 20024.3017 -> NaN Division_impossible xmul125 multiply 2103890.49E+959247237 20024.3017 -> 4.21289379E+959247247 Inexact Rounded xpow125 power 2103890.49E+959247237 20024 -> Infinity Overflow Inexact Rounded xrem125 remainder 2103890.49E+959247237 20024.3017 -> NaN Division_impossible xsub125 subtract 2103890.49E+959247237 20024.3017 -> 2.10389049E+959247243 Inexact Rounded xadd126 add 911249557 79810804.9 -> 991060362 Inexact Rounded xcom126 compare 911249557 79810804.9 -> 1 xdiv126 divide 911249557 79810804.9 -> 11.4176214 Inexact Rounded xdvi126 divideint 911249557 79810804.9 -> 11 xmul126 multiply 911249557 79810804.9 -> 7.27275606E+16 Inexact Rounded xpow126 power 911249557 79810805 -> 6.77595741E+715075867 Inexact Rounded xrem126 remainder 911249557 79810804.9 -> 33330703.1 xsub126 subtract 911249557 79810804.9 -> 831438752 Inexact Rounded xadd127 add 341134.994 3.37486292 -> 341138.369 Inexact Rounded xcom127 compare 341134.994 3.37486292 -> 1 xdiv127 divide 341134.994 3.37486292 -> 101081.141 Inexact Rounded xdvi127 divideint 341134.994 3.37486292 -> 101081 xmul127 multiply 341134.994 3.37486292 -> 1151283.84 Inexact Rounded xpow127 power 341134.994 3 -> 3.96989314E+16 Inexact Rounded xrem127 remainder 341134.994 3.37486292 -> 0.47518348 xsub127 subtract 341134.994 3.37486292 -> 341131.619 Inexact Rounded xadd128 add 244.23634 512706190E-341459836 -> 244.236340 Inexact Rounded xcom128 compare 244.23634 512706190E-341459836 -> 1 xdiv128 divide 244.23634 512706190E-341459836 -> 4.76367059E+341459829 Inexact Rounded xdvi128 divideint 244.23634 512706190E-341459836 -> NaN Division_impossible xmul128 multiply 244.23634 512706190E-341459836 -> 1.25221483E-341459825 Inexact Rounded xpow128 power 244.23634 5 -> 8.69063312E+11 Inexact Rounded xrem128 remainder 244.23634 512706190E-341459836 -> NaN Division_impossible xsub128 subtract 244.23634 512706190E-341459836 -> 244.236340 Inexact Rounded xadd129 add -9.22783849E+171585954 -99.0946800 -> -9.22783849E+171585954 Inexact Rounded xcom129 compare -9.22783849E+171585954 -99.0946800 -> -1 xdiv129 divide -9.22783849E+171585954 -99.0946800 -> 9.31214318E+171585952 Inexact Rounded xdvi129 divideint -9.22783849E+171585954 -99.0946800 -> NaN Division_impossible xmul129 multiply -9.22783849E+171585954 -99.0946800 -> 9.14429702E+171585956 Inexact Rounded xpow129 power -9.22783849E+171585954 -99 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem129 remainder -9.22783849E+171585954 -99.0946800 -> NaN Division_impossible xsub129 subtract -9.22783849E+171585954 -99.0946800 -> -9.22783849E+171585954 Inexact Rounded xadd130 add 699631.893 -226.423958 -> 699405.469 Inexact Rounded xcom130 compare 699631.893 -226.423958 -> 1 xdiv130 divide 699631.893 -226.423958 -> -3089.91990 Inexact Rounded xdvi130 divideint 699631.893 -226.423958 -> -3089 xmul130 multiply 699631.893 -226.423958 -> -158413422 Inexact Rounded xpow130 power 699631.893 -226 -> 1.14675511E-1321 Inexact Rounded xrem130 remainder 699631.893 -226.423958 -> 208.286738 xsub130 subtract 699631.893 -226.423958 -> 699858.317 Inexact Rounded xadd131 add -249350139.E-571793673 775732428. -> 775732428 Inexact Rounded xcom131 compare -249350139.E-571793673 775732428. -> -1 xdiv131 divide -249350139.E-571793673 775732428. -> -3.21438334E-571793674 Inexact Rounded xdvi131 divideint -249350139.E-571793673 775732428. -> -0 xmul131 multiply -249350139.E-571793673 775732428. -> -1.93428989E-571793656 Inexact Rounded xpow131 power -249350139.E-571793673 775732428 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem131 remainder -249350139.E-571793673 775732428. -> -2.49350139E-571793665 xsub131 subtract -249350139.E-571793673 775732428. -> -775732428 Inexact Rounded xadd132 add 5.11629020 -480.53194 -> -475.415650 Inexact Rounded xcom132 compare 5.11629020 -480.53194 -> 1 xdiv132 divide 5.11629020 -480.53194 -> -0.0106471387 Inexact Rounded xdvi132 divideint 5.11629020 -480.53194 -> -0 xmul132 multiply 5.11629020 -480.53194 -> -2458.54086 Inexact Rounded xpow132 power 5.11629020 -481 -> 9.83021951E-342 Inexact Rounded xrem132 remainder 5.11629020 -480.53194 -> 5.11629020 xsub132 subtract 5.11629020 -480.53194 -> 485.648230 Inexact Rounded xadd133 add -8.23352673E-446723147 -530710.866 -> -530710.866 Inexact Rounded xcom133 compare -8.23352673E-446723147 -530710.866 -> 1 xdiv133 divide -8.23352673E-446723147 -530710.866 -> 1.55141476E-446723152 Inexact Rounded xdvi133 divideint -8.23352673E-446723147 -530710.866 -> 0 xmul133 multiply -8.23352673E-446723147 -530710.866 -> 4.36962210E-446723141 Inexact Rounded xpow133 power -8.23352673E-446723147 -530711 -> -Infinity Overflow Inexact Rounded xrem133 remainder -8.23352673E-446723147 -530710.866 -> -8.23352673E-446723147 xsub133 subtract -8.23352673E-446723147 -530710.866 -> 530710.866 Inexact Rounded xadd134 add 7.0598608 -95908.35 -> -95901.2901 Inexact Rounded xcom134 compare 7.0598608 -95908.35 -> 1 xdiv134 divide 7.0598608 -95908.35 -> -0.0000736104917 Inexact Rounded xdvi134 divideint 7.0598608 -95908.35 -> -0 xmul134 multiply 7.0598608 -95908.35 -> -677099.601 Inexact Rounded xpow134 power 7.0598608 -95908 -> 4.57073877E-81407 Inexact Rounded xrem134 remainder 7.0598608 -95908.35 -> 7.0598608 xsub134 subtract 7.0598608 -95908.35 -> 95915.4099 Inexact Rounded xadd135 add -7.91189845E+207202706 1532.71847E+509944335 -> 1.53271847E+509944338 Inexact Rounded xcom135 compare -7.91189845E+207202706 1532.71847E+509944335 -> -1 xdiv135 divide -7.91189845E+207202706 1532.71847E+509944335 -> -5.16200372E-302741632 Inexact Rounded xdvi135 divideint -7.91189845E+207202706 1532.71847E+509944335 -> -0 xmul135 multiply -7.91189845E+207202706 1532.71847E+509944335 -> -1.21267129E+717147045 Inexact Rounded xpow135 power -7.91189845E+207202706 2 -> 6.25981371E+414405413 Inexact Rounded xrem135 remainder -7.91189845E+207202706 1532.71847E+509944335 -> -7.91189845E+207202706 xsub135 subtract -7.91189845E+207202706 1532.71847E+509944335 -> -1.53271847E+509944338 Inexact Rounded xadd136 add 208839370.E-215147432 -75.9420559 -> -75.9420559 Inexact Rounded xcom136 compare 208839370.E-215147432 -75.9420559 -> 1 xdiv136 divide 208839370.E-215147432 -75.9420559 -> -2.74998310E-215147426 Inexact Rounded xdvi136 divideint 208839370.E-215147432 -75.9420559 -> -0 xmul136 multiply 208839370.E-215147432 -75.9420559 -> -1.58596911E-215147422 Inexact Rounded xpow136 power 208839370.E-215147432 -76 -> Infinity Overflow Inexact Rounded xrem136 remainder 208839370.E-215147432 -75.9420559 -> 2.08839370E-215147424 xsub136 subtract 208839370.E-215147432 -75.9420559 -> 75.9420559 Inexact Rounded xadd137 add 427.754244E-353328369 4705.0796 -> 4705.07960 Inexact Rounded xcom137 compare 427.754244E-353328369 4705.0796 -> -1 xdiv137 divide 427.754244E-353328369 4705.0796 -> 9.09132853E-353328371 Inexact Rounded xdvi137 divideint 427.754244E-353328369 4705.0796 -> 0 xmul137 multiply 427.754244E-353328369 4705.0796 -> 2.01261777E-353328363 Inexact Rounded xpow137 power 427.754244E-353328369 4705 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem137 remainder 427.754244E-353328369 4705.0796 -> 4.27754244E-353328367 xsub137 subtract 427.754244E-353328369 4705.0796 -> -4705.07960 Inexact Rounded xadd138 add 44911.089 -95.1733605E-313081848 -> 44911.0890 Inexact Rounded xcom138 compare 44911.089 -95.1733605E-313081848 -> 1 xdiv138 divide 44911.089 -95.1733605E-313081848 -> -4.71887183E+313081850 Inexact Rounded xdvi138 divideint 44911.089 -95.1733605E-313081848 -> NaN Division_impossible xmul138 multiply 44911.089 -95.1733605E-313081848 -> -4.27433926E-313081842 Inexact Rounded xpow138 power 44911.089 -10 -> 2.99546425E-47 Inexact Rounded xrem138 remainder 44911.089 -95.1733605E-313081848 -> NaN Division_impossible xsub138 subtract 44911.089 -95.1733605E-313081848 -> 44911.0890 Inexact Rounded xadd139 add 452371821. -4109709.19 -> 448262112 Inexact Rounded xcom139 compare 452371821. -4109709.19 -> 1 xdiv139 divide 452371821. -4109709.19 -> -110.073925 Inexact Rounded xdvi139 divideint 452371821. -4109709.19 -> -110 xmul139 multiply 452371821. -4109709.19 -> -1.85911663E+15 Inexact Rounded xpow139 power 452371821. -4109709 -> 1.15528807E-35571568 Inexact Rounded xrem139 remainder 452371821. -4109709.19 -> 303810.10 xsub139 subtract 452371821. -4109709.19 -> 456481530 Inexact Rounded xadd140 add 94007.4392 -9467725.5E+681898234 -> -9.46772550E+681898240 Inexact Rounded xcom140 compare 94007.4392 -9467725.5E+681898234 -> 1 xdiv140 divide 94007.4392 -9467725.5E+681898234 -> -9.92925272E-681898237 Inexact Rounded xdvi140 divideint 94007.4392 -9467725.5E+681898234 -> -0 xmul140 multiply 94007.4392 -9467725.5E+681898234 -> -8.90036629E+681898245 Inexact Rounded xpow140 power 94007.4392 -9 -> 1.74397397E-45 Inexact Rounded xrem140 remainder 94007.4392 -9467725.5E+681898234 -> 94007.4392 xsub140 subtract 94007.4392 -9467725.5E+681898234 -> 9.46772550E+681898240 Inexact Rounded xadd141 add 99147554.0E-751410586 38313.6423 -> 38313.6423 Inexact Rounded xcom141 compare 99147554.0E-751410586 38313.6423 -> -1 xdiv141 divide 99147554.0E-751410586 38313.6423 -> 2.58778722E-751410583 Inexact Rounded xdvi141 divideint 99147554.0E-751410586 38313.6423 -> 0 xmul141 multiply 99147554.0E-751410586 38313.6423 -> 3.79870392E-751410574 Inexact Rounded xpow141 power 99147554.0E-751410586 38314 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem141 remainder 99147554.0E-751410586 38313.6423 -> 9.91475540E-751410579 xsub141 subtract 99147554.0E-751410586 38313.6423 -> -38313.6423 Inexact Rounded xadd142 add -7919.30254 -669.607854 -> -8588.91039 Inexact Rounded xcom142 compare -7919.30254 -669.607854 -> -1 xdiv142 divide -7919.30254 -669.607854 -> 11.8267767 Inexact Rounded xdvi142 divideint -7919.30254 -669.607854 -> 11 xmul142 multiply -7919.30254 -669.607854 -> 5302827.18 Inexact Rounded xpow142 power -7919.30254 -670 -> 7.58147724E-2613 Inexact Rounded xrem142 remainder -7919.30254 -669.607854 -> -553.616146 xsub142 subtract -7919.30254 -669.607854 -> -7249.69469 Inexact Rounded xadd143 add 461.58280E+136110821 710666052.E-383754231 -> 4.61582800E+136110823 Inexact Rounded xcom143 compare 461.58280E+136110821 710666052.E-383754231 -> 1 xdiv143 divide 461.58280E+136110821 710666052.E-383754231 -> 6.49507316E+519865045 Inexact Rounded xdvi143 divideint 461.58280E+136110821 710666052.E-383754231 -> NaN Division_impossible xmul143 multiply 461.58280E+136110821 710666052.E-383754231 -> 3.28031226E-247643399 Inexact Rounded xpow143 power 461.58280E+136110821 7 -> 4.46423781E+952775765 Inexact Rounded xrem143 remainder 461.58280E+136110821 710666052.E-383754231 -> NaN Division_impossible xsub143 subtract 461.58280E+136110821 710666052.E-383754231 -> 4.61582800E+136110823 Inexact Rounded xadd144 add 3455755.47E-112465506 771.674306 -> 771.674306 Inexact Rounded xcom144 compare 3455755.47E-112465506 771.674306 -> -1 xdiv144 divide 3455755.47E-112465506 771.674306 -> 4.47825649E-112465503 Inexact Rounded xdvi144 divideint 3455755.47E-112465506 771.674306 -> 0 xmul144 multiply 3455755.47E-112465506 771.674306 -> 2.66671770E-112465497 Inexact Rounded xpow144 power 3455755.47E-112465506 772 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem144 remainder 3455755.47E-112465506 771.674306 -> 3.45575547E-112465500 xsub144 subtract 3455755.47E-112465506 771.674306 -> -771.674306 Inexact Rounded xadd145 add -477067757.E-961684940 7.70122608E-741072245 -> 7.70122608E-741072245 Inexact Rounded xcom145 compare -477067757.E-961684940 7.70122608E-741072245 -> -1 xdiv145 divide -477067757.E-961684940 7.70122608E-741072245 -> -6.19469877E-220612688 Inexact Rounded xdvi145 divideint -477067757.E-961684940 7.70122608E-741072245 -> -0 xmul145 multiply -477067757.E-961684940 7.70122608E-741072245 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow145 power -477067757.E-961684940 8 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem145 remainder -477067757.E-961684940 7.70122608E-741072245 -> -4.77067757E-961684932 xsub145 subtract -477067757.E-961684940 7.70122608E-741072245 -> -7.70122608E-741072245 Inexact Rounded xadd146 add 76482.352 8237806.8 -> 8314289.15 Inexact Rounded xcom146 compare 76482.352 8237806.8 -> -1 xdiv146 divide 76482.352 8237806.8 -> 0.00928430999 Inexact Rounded xdvi146 divideint 76482.352 8237806.8 -> 0 xmul146 multiply 76482.352 8237806.8 -> 6.30046839E+11 Inexact Rounded xpow146 power 76482.352 8237807 -> 8.44216559E+40229834 Inexact Rounded xrem146 remainder 76482.352 8237806.8 -> 76482.352 xsub146 subtract 76482.352 8237806.8 -> -8161324.45 Inexact Rounded xadd147 add 1.21505164E-565556504 9.26146573 -> 9.26146573 Inexact Rounded xcom147 compare 1.21505164E-565556504 9.26146573 -> -1 xdiv147 divide 1.21505164E-565556504 9.26146573 -> 1.31194314E-565556505 Inexact Rounded xdvi147 divideint 1.21505164E-565556504 9.26146573 -> 0 xmul147 multiply 1.21505164E-565556504 9.26146573 -> 1.12531591E-565556503 Inexact Rounded xpow147 power 1.21505164E-565556504 9 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem147 remainder 1.21505164E-565556504 9.26146573 -> 1.21505164E-565556504 xsub147 subtract 1.21505164E-565556504 9.26146573 -> -9.26146573 Inexact Rounded xadd148 add -8303060.25E-169894883 901561.985 -> 901561.985 Inexact Rounded xcom148 compare -8303060.25E-169894883 901561.985 -> -1 xdiv148 divide -8303060.25E-169894883 901561.985 -> -9.20963881E-169894883 Inexact Rounded xdvi148 divideint -8303060.25E-169894883 901561.985 -> -0 xmul148 multiply -8303060.25E-169894883 901561.985 -> -7.48572348E-169894871 Inexact Rounded xpow148 power -8303060.25E-169894883 901562 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem148 remainder -8303060.25E-169894883 901561.985 -> -8.30306025E-169894877 xsub148 subtract -8303060.25E-169894883 901561.985 -> -901561.985 Inexact Rounded xadd149 add -592464.92 71445510.7 -> 70853045.8 Inexact Rounded xcom149 compare -592464.92 71445510.7 -> -1 xdiv149 divide -592464.92 71445510.7 -> -0.00829254231 Inexact Rounded xdvi149 divideint -592464.92 71445510.7 -> -0 xmul149 multiply -592464.92 71445510.7 -> -4.23289588E+13 Inexact Rounded xpow149 power -592464.92 71445511 -> -1.58269108E+412430832 Inexact Rounded xrem149 remainder -592464.92 71445510.7 -> -592464.92 xsub149 subtract -592464.92 71445510.7 -> -72037975.6 Inexact Rounded xadd150 add -73774.4165 -39.8243027 -> -73814.2408 Inexact Rounded xcom150 compare -73774.4165 -39.8243027 -> -1 xdiv150 divide -73774.4165 -39.8243027 -> 1852.49738 Inexact Rounded xdvi150 divideint -73774.4165 -39.8243027 -> 1852 xmul150 multiply -73774.4165 -39.8243027 -> 2938014.69 Inexact Rounded xpow150 power -73774.4165 -40 -> 1.92206765E-195 Inexact Rounded xrem150 remainder -73774.4165 -39.8243027 -> -19.8078996 xsub150 subtract -73774.4165 -39.8243027 -> -73734.5922 Inexact Rounded xadd151 add -524724715. -55763.7937 -> -524780479 Inexact Rounded xcom151 compare -524724715. -55763.7937 -> -1 xdiv151 divide -524724715. -55763.7937 -> 9409.77434 Inexact Rounded xdvi151 divideint -524724715. -55763.7937 -> 9409 xmul151 multiply -524724715. -55763.7937 -> 2.92606408E+13 Inexact Rounded xpow151 power -524724715. -55764 -> 5.47898351E-486259 Inexact Rounded xrem151 remainder -524724715. -55763.7937 -> -43180.0767 xsub151 subtract -524724715. -55763.7937 -> -524668951 Inexact Rounded xadd152 add 7.53800427 784873768E-9981146 -> 7.53800427 Inexact Rounded xcom152 compare 7.53800427 784873768E-9981146 -> 1 xdiv152 divide 7.53800427 784873768E-9981146 -> 9.60409760E+9981137 Inexact Rounded xdvi152 divideint 7.53800427 784873768E-9981146 -> NaN Division_impossible xmul152 multiply 7.53800427 784873768E-9981146 -> 5.91638181E-9981137 Inexact Rounded xpow152 power 7.53800427 8 -> 10424399.2 Inexact Rounded xrem152 remainder 7.53800427 784873768E-9981146 -> NaN Division_impossible xsub152 subtract 7.53800427 784873768E-9981146 -> 7.53800427 Inexact Rounded xadd153 add 37.6027452 7.22454233 -> 44.8272875 Inexact Rounded xcom153 compare 37.6027452 7.22454233 -> 1 xdiv153 divide 37.6027452 7.22454233 -> 5.20486191 Inexact Rounded xdvi153 divideint 37.6027452 7.22454233 -> 5 xmul153 multiply 37.6027452 7.22454233 -> 271.662624 Inexact Rounded xpow153 power 37.6027452 7 -> 1.06300881E+11 Inexact Rounded xrem153 remainder 37.6027452 7.22454233 -> 1.48003355 xsub153 subtract 37.6027452 7.22454233 -> 30.3782029 Inexact Rounded xadd154 add 2447660.39 -36981.4253 -> 2410678.96 Inexact Rounded xcom154 compare 2447660.39 -36981.4253 -> 1 xdiv154 divide 2447660.39 -36981.4253 -> -66.1862102 Inexact Rounded xdvi154 divideint 2447660.39 -36981.4253 -> -66 xmul154 multiply 2447660.39 -36981.4253 -> -9.05179699E+10 Inexact Rounded xpow154 power 2447660.39 -36981 -> 3.92066064E-236263 Inexact Rounded xrem154 remainder 2447660.39 -36981.4253 -> 6886.3202 xsub154 subtract 2447660.39 -36981.4253 -> 2484641.82 Inexact Rounded xadd155 add 2160.36419 1418.33574E+656265382 -> 1.41833574E+656265385 Inexact Rounded xcom155 compare 2160.36419 1418.33574E+656265382 -> -1 xdiv155 divide 2160.36419 1418.33574E+656265382 -> 1.52316841E-656265382 Inexact Rounded xdvi155 divideint 2160.36419 1418.33574E+656265382 -> 0 xmul155 multiply 2160.36419 1418.33574E+656265382 -> 3.06412174E+656265388 Inexact Rounded xpow155 power 2160.36419 1 -> 2160.36419 xrem155 remainder 2160.36419 1418.33574E+656265382 -> 2160.36419 xsub155 subtract 2160.36419 1418.33574E+656265382 -> -1.41833574E+656265385 Inexact Rounded xadd156 add 8926.44939 54.9430027 -> 8981.39239 Inexact Rounded xcom156 compare 8926.44939 54.9430027 -> 1 xdiv156 divide 8926.44939 54.9430027 -> 162.467447 Inexact Rounded xdvi156 divideint 8926.44939 54.9430027 -> 162 xmul156 multiply 8926.44939 54.9430027 -> 490445.933 Inexact Rounded xpow156 power 8926.44939 55 -> 1.93789877E+217 Inexact Rounded xrem156 remainder 8926.44939 54.9430027 -> 25.6829526 xsub156 subtract 8926.44939 54.9430027 -> 8871.50639 Inexact Rounded xadd157 add 861588029 -41657398E+77955925 -> -4.16573980E+77955932 Inexact Rounded xcom157 compare 861588029 -41657398E+77955925 -> 1 xdiv157 divide 861588029 -41657398E+77955925 -> -2.06827135E-77955924 Inexact Rounded xdvi157 divideint 861588029 -41657398E+77955925 -> -0 xmul157 multiply 861588029 -41657398E+77955925 -> -3.58915154E+77955941 Inexact Rounded xpow157 power 861588029 -4 -> 1.81468553E-36 Inexact Rounded xrem157 remainder 861588029 -41657398E+77955925 -> 861588029 xsub157 subtract 861588029 -41657398E+77955925 -> 4.16573980E+77955932 Inexact Rounded xadd158 add -34.5253062 52.6722019 -> 18.1468957 xcom158 compare -34.5253062 52.6722019 -> -1 xdiv158 divide -34.5253062 52.6722019 -> -0.655474899 Inexact Rounded xdvi158 divideint -34.5253062 52.6722019 -> -0 xmul158 multiply -34.5253062 52.6722019 -> -1818.52390 Inexact Rounded xpow158 power -34.5253062 53 -> -3.32115821E+81 Inexact Rounded xrem158 remainder -34.5253062 52.6722019 -> -34.5253062 xsub158 subtract -34.5253062 52.6722019 -> -87.1975081 xadd159 add -18861647. 99794586.7 -> 80932939.7 xcom159 compare -18861647. 99794586.7 -> -1 xdiv159 divide -18861647. 99794586.7 -> -0.189004711 Inexact Rounded xdvi159 divideint -18861647. 99794586.7 -> -0 xmul159 multiply -18861647. 99794586.7 -> -1.88229027E+15 Inexact Rounded xpow159 power -18861647. 99794587 -> -4.28957459E+726063462 Inexact Rounded xrem159 remainder -18861647. 99794586.7 -> -18861647.0 xsub159 subtract -18861647. 99794586.7 -> -118656234 Inexact Rounded xadd160 add 322192.407 461.67044 -> 322654.077 Inexact Rounded xcom160 compare 322192.407 461.67044 -> 1 xdiv160 divide 322192.407 461.67044 -> 697.883986 Inexact Rounded xdvi160 divideint 322192.407 461.67044 -> 697 xmul160 multiply 322192.407 461.67044 -> 148746710 Inexact Rounded xpow160 power 322192.407 462 -> 5.61395873E+2544 Inexact Rounded xrem160 remainder 322192.407 461.67044 -> 408.11032 xsub160 subtract 322192.407 461.67044 -> 321730.737 Inexact Rounded xadd161 add -896298518E+61412314 78873.8049 -> -8.96298518E+61412322 Inexact Rounded xcom161 compare -896298518E+61412314 78873.8049 -> -1 xdiv161 divide -896298518E+61412314 78873.8049 -> -1.13637033E+61412318 Inexact Rounded xdvi161 divideint -896298518E+61412314 78873.8049 -> NaN Division_impossible xmul161 multiply -896298518E+61412314 78873.8049 -> -7.06944744E+61412327 Inexact Rounded xpow161 power -896298518E+61412314 78874 -> Infinity Overflow Inexact Rounded xrem161 remainder -896298518E+61412314 78873.8049 -> NaN Division_impossible xsub161 subtract -896298518E+61412314 78873.8049 -> -8.96298518E+61412322 Inexact Rounded xadd162 add 293.773732 479899052E+789950177 -> 4.79899052E+789950185 Inexact Rounded xcom162 compare 293.773732 479899052E+789950177 -> -1 xdiv162 divide 293.773732 479899052E+789950177 -> 6.12157350E-789950184 Inexact Rounded xdvi162 divideint 293.773732 479899052E+789950177 -> 0 xmul162 multiply 293.773732 479899052E+789950177 -> 1.40981735E+789950188 Inexact Rounded xpow162 power 293.773732 5 -> 2.18808809E+12 Inexact Rounded xrem162 remainder 293.773732 479899052E+789950177 -> 293.773732 xsub162 subtract 293.773732 479899052E+789950177 -> -4.79899052E+789950185 Inexact Rounded xadd163 add -103519362 51897955.3 -> -51621406.7 xcom163 compare -103519362 51897955.3 -> -1 xdiv163 divide -103519362 51897955.3 -> -1.99467130 Inexact Rounded xdvi163 divideint -103519362 51897955.3 -> -1 xmul163 multiply -103519362 51897955.3 -> -5.37244322E+15 Inexact Rounded xpow163 power -103519362 51897955 -> -4.28858229E+415963229 Inexact Rounded xrem163 remainder -103519362 51897955.3 -> -51621406.7 xsub163 subtract -103519362 51897955.3 -> -155417317 Inexact Rounded xadd164 add 37380.7802 -277719788. -> -277682407 Inexact Rounded xcom164 compare 37380.7802 -277719788. -> 1 xdiv164 divide 37380.7802 -277719788. -> -0.000134598908 Inexact Rounded xdvi164 divideint 37380.7802 -277719788. -> -0 xmul164 multiply 37380.7802 -277719788. -> -1.03813824E+13 Inexact Rounded xpow164 power 37380.7802 -277719788 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem164 remainder 37380.7802 -277719788. -> 37380.7802 xsub164 subtract 37380.7802 -277719788. -> 277757169 Inexact Rounded xadd165 add 320133844. -977517477 -> -657383633 xcom165 compare 320133844. -977517477 -> 1 xdiv165 divide 320133844. -977517477 -> -0.327496798 Inexact Rounded xdvi165 divideint 320133844. -977517477 -> -0 xmul165 multiply 320133844. -977517477 -> -3.12936427E+17 Inexact Rounded xpow165 power 320133844. -977517477 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem165 remainder 320133844. -977517477 -> 320133844 xsub165 subtract 320133844. -977517477 -> 1.29765132E+9 Inexact Rounded xadd166 add 721776701E+933646161 -5689279.64E+669903645 -> 7.21776701E+933646169 Inexact Rounded xcom166 compare 721776701E+933646161 -5689279.64E+669903645 -> 1 xdiv166 divide 721776701E+933646161 -5689279.64E+669903645 -> -1.26866097E+263742518 Inexact Rounded xdvi166 divideint 721776701E+933646161 -5689279.64E+669903645 -> NaN Division_impossible xmul166 multiply 721776701E+933646161 -5689279.64E+669903645 -> -Infinity Inexact Overflow Rounded xpow166 power 721776701E+933646161 -6 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem166 remainder 721776701E+933646161 -5689279.64E+669903645 -> NaN Division_impossible xsub166 subtract 721776701E+933646161 -5689279.64E+669903645 -> 7.21776701E+933646169 Inexact Rounded xadd167 add -5409.00482 -2.16149386 -> -5411.16631 Inexact Rounded xcom167 compare -5409.00482 -2.16149386 -> -1 xdiv167 divide -5409.00482 -2.16149386 -> 2502.43821 Inexact Rounded xdvi167 divideint -5409.00482 -2.16149386 -> 2502 xmul167 multiply -5409.00482 -2.16149386 -> 11691.5307 Inexact Rounded xpow167 power -5409.00482 -2 -> 3.41794652E-8 Inexact Rounded xrem167 remainder -5409.00482 -2.16149386 -> -0.94718228 xsub167 subtract -5409.00482 -2.16149386 -> -5406.84333 Inexact Rounded xadd168 add -957960.367 322.858170 -> -957637.509 Inexact Rounded xcom168 compare -957960.367 322.858170 -> -1 xdiv168 divide -957960.367 322.858170 -> -2967.12444 Inexact Rounded xdvi168 divideint -957960.367 322.858170 -> -2967 xmul168 multiply -957960.367 322.858170 -> -309285331 Inexact Rounded xpow168 power -957960.367 323 -> -9.44617460E+1931 Inexact Rounded xrem168 remainder -957960.367 322.858170 -> -40.176610 xsub168 subtract -957960.367 322.858170 -> -958283.225 Inexact Rounded xadd169 add -11817.8754E+613893442 -3.84735082E+888333249 -> -3.84735082E+888333249 Inexact Rounded xcom169 compare -11817.8754E+613893442 -3.84735082E+888333249 -> 1 xdiv169 divide -11817.8754E+613893442 -3.84735082E+888333249 -> 3.07169165E-274439804 Inexact Rounded xdvi169 divideint -11817.8754E+613893442 -3.84735082E+888333249 -> 0 xmul169 multiply -11817.8754E+613893442 -3.84735082E+888333249 -> Infinity Inexact Overflow Rounded xpow169 power -11817.8754E+613893442 -4 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem169 remainder -11817.8754E+613893442 -3.84735082E+888333249 -> -1.18178754E+613893446 xsub169 subtract -11817.8754E+613893442 -3.84735082E+888333249 -> 3.84735082E+888333249 Inexact Rounded xadd170 add 840258203 58363.980E-906584723 -> 840258203 Inexact Rounded xcom170 compare 840258203 58363.980E-906584723 -> 1 xdiv170 divide 840258203 58363.980E-906584723 -> 1.43968626E+906584727 Inexact Rounded xdvi170 divideint 840258203 58363.980E-906584723 -> NaN Division_impossible xmul170 multiply 840258203 58363.980E-906584723 -> 4.90408130E-906584710 Inexact Rounded xpow170 power 840258203 6 -> 3.51946431E+53 Inexact Rounded xrem170 remainder 840258203 58363.980E-906584723 -> NaN Division_impossible xsub170 subtract 840258203 58363.980E-906584723 -> 840258203 Inexact Rounded xadd171 add -205842096. -191342.721 -> -206033439 Inexact Rounded xcom171 compare -205842096. -191342.721 -> -1 xdiv171 divide -205842096. -191342.721 -> 1075.77699 Inexact Rounded xdvi171 divideint -205842096. -191342.721 -> 1075 xmul171 multiply -205842096. -191342.721 -> 3.93863867E+13 Inexact Rounded xpow171 power -205842096. -191343 -> -2.66955553E-1590737 Inexact Rounded xrem171 remainder -205842096. -191342.721 -> -148670.925 xsub171 subtract -205842096. -191342.721 -> -205650753 Inexact Rounded xadd172 add 42501124. 884.938498E+123341480 -> 8.84938498E+123341482 Inexact Rounded xcom172 compare 42501124. 884.938498E+123341480 -> -1 xdiv172 divide 42501124. 884.938498E+123341480 -> 4.80272065E-123341476 Inexact Rounded xdvi172 divideint 42501124. 884.938498E+123341480 -> 0 xmul172 multiply 42501124. 884.938498E+123341480 -> 3.76108808E+123341490 Inexact Rounded xpow172 power 42501124. 9 -> 4.52484536E+68 Inexact Rounded xrem172 remainder 42501124. 884.938498E+123341480 -> 42501124 xsub172 subtract 42501124. 884.938498E+123341480 -> -8.84938498E+123341482 Inexact Rounded xadd173 add -57809452. -620380746 -> -678190198 xcom173 compare -57809452. -620380746 -> 1 xdiv173 divide -57809452. -620380746 -> 0.0931838268 Inexact Rounded xdvi173 divideint -57809452. -620380746 -> 0 xmul173 multiply -57809452. -620380746 -> 3.58638710E+16 Inexact Rounded xpow173 power -57809452. -620380746 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem173 remainder -57809452. -620380746 -> -57809452 xsub173 subtract -57809452. -620380746 -> 562571294 xadd174 add -8022370.31 9858581.6 -> 1836211.29 xcom174 compare -8022370.31 9858581.6 -> -1 xdiv174 divide -8022370.31 9858581.6 -> -0.813744881 Inexact Rounded xdvi174 divideint -8022370.31 9858581.6 -> -0 xmul174 multiply -8022370.31 9858581.6 -> -7.90891923E+13 Inexact Rounded xpow174 power -8022370.31 9858582 -> 2.34458249E+68066634 Inexact Rounded xrem174 remainder -8022370.31 9858581.6 -> -8022370.31 xsub174 subtract -8022370.31 9858581.6 -> -17880951.9 Inexact Rounded xadd175 add 2.49065060E+592139141 -5432.72014E-419965357 -> 2.49065060E+592139141 Inexact Rounded xcom175 compare 2.49065060E+592139141 -5432.72014E-419965357 -> 1 xdiv175 divide 2.49065060E+592139141 -5432.72014E-419965357 -> -Infinity Inexact Overflow Rounded xdvi175 divideint 2.49065060E+592139141 -5432.72014E-419965357 -> NaN Division_impossible xmul175 multiply 2.49065060E+592139141 -5432.72014E-419965357 -> -1.35310077E+172173788 Inexact Rounded xpow175 power 2.49065060E+592139141 -5 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem175 remainder 2.49065060E+592139141 -5432.72014E-419965357 -> NaN Division_impossible xsub175 subtract 2.49065060E+592139141 -5432.72014E-419965357 -> 2.49065060E+592139141 Inexact Rounded xadd176 add -697273715E-242824870 -3.81757506 -> -3.81757506 Inexact Rounded xcom176 compare -697273715E-242824870 -3.81757506 -> 1 xdiv176 divide -697273715E-242824870 -3.81757506 -> 1.82648331E-242824862 Inexact Rounded xdvi176 divideint -697273715E-242824870 -3.81757506 -> 0 xmul176 multiply -697273715E-242824870 -3.81757506 -> 2.66189474E-242824861 Inexact Rounded xpow176 power -697273715E-242824870 -4 -> 4.23045251E+971299444 Inexact Rounded xrem176 remainder -697273715E-242824870 -3.81757506 -> -6.97273715E-242824862 xsub176 subtract -697273715E-242824870 -3.81757506 -> 3.81757506 Inexact Rounded xadd177 add -7.42204403E-315716280 -8156111.67E+283261636 -> -8.15611167E+283261642 Inexact Rounded xcom177 compare -7.42204403E-315716280 -8156111.67E+283261636 -> 1 xdiv177 divide -7.42204403E-315716280 -8156111.67E+283261636 -> 9.09997843E-598977923 Inexact Rounded xdvi177 divideint -7.42204403E-315716280 -8156111.67E+283261636 -> 0 xmul177 multiply -7.42204403E-315716280 -8156111.67E+283261636 -> 6.05350199E-32454637 Inexact Rounded xpow177 power -7.42204403E-315716280 -8 -> Infinity Overflow Inexact Rounded xrem177 remainder -7.42204403E-315716280 -8156111.67E+283261636 -> -7.42204403E-315716280 xsub177 subtract -7.42204403E-315716280 -8156111.67E+283261636 -> 8.15611167E+283261642 Inexact Rounded xadd178 add 738063892 89900467.8 -> 827964360 Inexact Rounded xcom178 compare 738063892 89900467.8 -> 1 xdiv178 divide 738063892 89900467.8 -> 8.20978923 Inexact Rounded xdvi178 divideint 738063892 89900467.8 -> 8 xmul178 multiply 738063892 89900467.8 -> 6.63522892E+16 Inexact Rounded xpow178 power 738063892 89900468 -> 1.53166723E+797245797 Inexact Rounded xrem178 remainder 738063892 89900467.8 -> 18860149.6 xsub178 subtract 738063892 89900467.8 -> 648163424 Inexact Rounded xadd179 add -630309366 -884783.338E-21595410 -> -630309366 Inexact Rounded xcom179 compare -630309366 -884783.338E-21595410 -> -1 xdiv179 divide -630309366 -884783.338E-21595410 -> 7.12388377E+21595412 Inexact Rounded xdvi179 divideint -630309366 -884783.338E-21595410 -> NaN Division_impossible xmul179 multiply -630309366 -884783.338E-21595410 -> 5.57687225E-21595396 Inexact Rounded xpow179 power -630309366 -9 -> -6.36819210E-80 Inexact Rounded xrem179 remainder -630309366 -884783.338E-21595410 -> NaN Division_impossible xsub179 subtract -630309366 -884783.338E-21595410 -> -630309366 Inexact Rounded xadd180 add 613.207774 -3007.78608 -> -2394.57831 Inexact Rounded xcom180 compare 613.207774 -3007.78608 -> 1 xdiv180 divide 613.207774 -3007.78608 -> -0.203873466 Inexact Rounded xdvi180 divideint 613.207774 -3007.78608 -> -0 xmul180 multiply 613.207774 -3007.78608 -> -1844397.81 Inexact Rounded xpow180 power 613.207774 -3008 -> 7.51939160E-8386 Inexact Rounded xrem180 remainder 613.207774 -3007.78608 -> 613.207774 xsub180 subtract 613.207774 -3007.78608 -> 3620.99385 Inexact Rounded xadd181 add -93006222.3 -3.08964619 -> -93006225.4 Inexact Rounded xcom181 compare -93006222.3 -3.08964619 -> -1 xdiv181 divide -93006222.3 -3.08964619 -> 30102547.9 Inexact Rounded xdvi181 divideint -93006222.3 -3.08964619 -> 30102547 xmul181 multiply -93006222.3 -3.08964619 -> 287356320 Inexact Rounded xpow181 power -93006222.3 -3 -> -1.24297956E-24 Inexact Rounded xrem181 remainder -93006222.3 -3.08964619 -> -2.65215407 xsub181 subtract -93006222.3 -3.08964619 -> -93006219.2 Inexact Rounded xadd182 add -18116.0621 34096.306E-270347092 -> -18116.0621 Inexact Rounded xcom182 compare -18116.0621 34096.306E-270347092 -> -1 xdiv182 divide -18116.0621 34096.306E-270347092 -> -5.31320375E+270347091 Inexact Rounded xdvi182 divideint -18116.0621 34096.306E-270347092 -> NaN Division_impossible xmul182 multiply -18116.0621 34096.306E-270347092 -> -6.17690797E-270347084 Inexact Rounded xpow182 power -18116.0621 3 -> -5.94554133E+12 Inexact Rounded xrem182 remainder -18116.0621 34096.306E-270347092 -> NaN Division_impossible xsub182 subtract -18116.0621 34096.306E-270347092 -> -18116.0621 Inexact Rounded xadd183 add 19272386.9 -410442379. -> -391169992 Inexact Rounded xcom183 compare 19272386.9 -410442379. -> 1 xdiv183 divide 19272386.9 -410442379. -> -0.0469551584 Inexact Rounded xdvi183 divideint 19272386.9 -410442379. -> -0 xmul183 multiply 19272386.9 -410442379. -> -7.91020433E+15 Inexact Rounded xpow183 power 19272386.9 -410442379 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem183 remainder 19272386.9 -410442379. -> 19272386.9 xsub183 subtract 19272386.9 -410442379. -> 429714766 Inexact Rounded xadd184 add 4180.30821 -1.6439543E-624759104 -> 4180.30821 Inexact Rounded xcom184 compare 4180.30821 -1.6439543E-624759104 -> 1 xdiv184 divide 4180.30821 -1.6439543E-624759104 -> -2.54283724E+624759107 Inexact Rounded xdvi184 divideint 4180.30821 -1.6439543E-624759104 -> NaN Division_impossible xmul184 multiply 4180.30821 -1.6439543E-624759104 -> -6.87223566E-624759101 Inexact Rounded xpow184 power 4180.30821 -2 -> 5.72246828E-8 Inexact Rounded xrem184 remainder 4180.30821 -1.6439543E-624759104 -> NaN Division_impossible xsub184 subtract 4180.30821 -1.6439543E-624759104 -> 4180.30821 Inexact Rounded xadd185 add 571.536725 389.899220 -> 961.435945 xcom185 compare 571.536725 389.899220 -> 1 xdiv185 divide 571.536725 389.899220 -> 1.46585757 Inexact Rounded xdvi185 divideint 571.536725 389.899220 -> 1 xmul185 multiply 571.536725 389.899220 -> 222841.723 Inexact Rounded xpow185 power 571.536725 390 -> 1.76691373E+1075 Inexact Rounded xrem185 remainder 571.536725 389.899220 -> 181.637505 xsub185 subtract 571.536725 389.899220 -> 181.637505 xadd186 add -622007306.E+159924886 -126.971745 -> -6.22007306E+159924894 Inexact Rounded xcom186 compare -622007306.E+159924886 -126.971745 -> -1 xdiv186 divide -622007306.E+159924886 -126.971745 -> 4.89878521E+159924892 Inexact Rounded xdvi186 divideint -622007306.E+159924886 -126.971745 -> NaN Division_impossible xmul186 multiply -622007306.E+159924886 -126.971745 -> 7.89773530E+159924896 Inexact Rounded xpow186 power -622007306.E+159924886 -127 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem186 remainder -622007306.E+159924886 -126.971745 -> NaN Division_impossible xsub186 subtract -622007306.E+159924886 -126.971745 -> -6.22007306E+159924894 Inexact Rounded xadd187 add -29.356551E-282816139 37141748E-903397821 -> -2.93565510E-282816138 Inexact Rounded xcom187 compare -29.356551E-282816139 37141748E-903397821 -> -1 xdiv187 divide -29.356551E-282816139 37141748E-903397821 -> -7.90392283E+620581675 Inexact Rounded xdvi187 divideint -29.356551E-282816139 37141748E-903397821 -> NaN Division_impossible xmul187 multiply -29.356551E-282816139 37141748E-903397821 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow187 power -29.356551E-282816139 4 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem187 remainder -29.356551E-282816139 37141748E-903397821 -> NaN Division_impossible xsub187 subtract -29.356551E-282816139 37141748E-903397821 -> -2.93565510E-282816138 Inexact Rounded xadd188 add 92427442.4 674334898. -> 766762340 Inexact Rounded xcom188 compare 92427442.4 674334898. -> -1 xdiv188 divide 92427442.4 674334898. -> 0.137064599 Inexact Rounded xdvi188 divideint 92427442.4 674334898. -> 0 xmul188 multiply 92427442.4 674334898. -> 6.23270499E+16 Inexact Rounded xpow188 power 92427442.4 674334898 -> Infinity Overflow Inexact Rounded xrem188 remainder 92427442.4 674334898. -> 92427442.4 xsub188 subtract 92427442.4 674334898. -> -581907456 Inexact Rounded xadd189 add 44651895.7 -910508.438 -> 43741387.3 Inexact Rounded xcom189 compare 44651895.7 -910508.438 -> 1 xdiv189 divide 44651895.7 -910508.438 -> -49.0406171 Inexact Rounded xdvi189 divideint 44651895.7 -910508.438 -> -49 xmul189 multiply 44651895.7 -910508.438 -> -4.06559278E+13 Inexact Rounded xpow189 power 44651895.7 -910508 -> 3.72264277E-6965241 Inexact Rounded xrem189 remainder 44651895.7 -910508.438 -> 36982.238 xsub189 subtract 44651895.7 -910508.438 -> 45562404.1 Inexact Rounded xadd190 add 647897872.E+374021790 -467.423029 -> 6.47897872E+374021798 Inexact Rounded xcom190 compare 647897872.E+374021790 -467.423029 -> 1 xdiv190 divide 647897872.E+374021790 -467.423029 -> -1.38610601E+374021796 Inexact Rounded xdvi190 divideint 647897872.E+374021790 -467.423029 -> NaN Division_impossible xmul190 multiply 647897872.E+374021790 -467.423029 -> -3.02842386E+374021801 Inexact Rounded xpow190 power 647897872.E+374021790 -467 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem190 remainder 647897872.E+374021790 -467.423029 -> NaN Division_impossible xsub190 subtract 647897872.E+374021790 -467.423029 -> 6.47897872E+374021798 Inexact Rounded xadd191 add 25.2592149 59.0436981 -> 84.3029130 xcom191 compare 25.2592149 59.0436981 -> -1 xdiv191 divide 25.2592149 59.0436981 -> 0.427805434 Inexact Rounded xdvi191 divideint 25.2592149 59.0436981 -> 0 xmul191 multiply 25.2592149 59.0436981 -> 1491.39746 Inexact Rounded xpow191 power 25.2592149 59 -> 5.53058435E+82 Inexact Rounded xrem191 remainder 25.2592149 59.0436981 -> 25.2592149 xsub191 subtract 25.2592149 59.0436981 -> -33.7844832 xadd192 add -6.850835 -1273.48240 -> -1280.33324 Inexact Rounded xcom192 compare -6.850835 -1273.48240 -> 1 xdiv192 divide -6.850835 -1273.48240 -> 0.00537960713 Inexact Rounded xdvi192 divideint -6.850835 -1273.48240 -> 0 xmul192 multiply -6.850835 -1273.48240 -> 8724.41780 Inexact Rounded xpow192 power -6.850835 -1273 -> -1.25462678E-1064 Inexact Rounded xrem192 remainder -6.850835 -1273.48240 -> -6.850835 xsub192 subtract -6.850835 -1273.48240 -> 1266.63157 Inexact Rounded xadd193 add 174.272325 5638.16229 -> 5812.43462 Inexact Rounded xcom193 compare 174.272325 5638.16229 -> -1 xdiv193 divide 174.272325 5638.16229 -> 0.0309094198 Inexact Rounded xdvi193 divideint 174.272325 5638.16229 -> 0 xmul193 multiply 174.272325 5638.16229 -> 982575.651 Inexact Rounded xpow193 power 174.272325 5638 -> 1.11137724E+12636 Inexact Rounded xrem193 remainder 174.272325 5638.16229 -> 174.272325 xsub193 subtract 174.272325 5638.16229 -> -5463.88997 Inexact Rounded xadd194 add 3455629.76 -8.27332322 -> 3455621.49 Inexact Rounded xcom194 compare 3455629.76 -8.27332322 -> 1 xdiv194 divide 3455629.76 -8.27332322 -> -417683.399 Inexact Rounded xdvi194 divideint 3455629.76 -8.27332322 -> -417683 xmul194 multiply 3455629.76 -8.27332322 -> -28589541.9 Inexact Rounded xpow194 power 3455629.76 -8 -> 4.91793015E-53 Inexact Rounded xrem194 remainder 3455629.76 -8.27332322 -> 3.29750074 xsub194 subtract 3455629.76 -8.27332322 -> 3455638.03 Inexact Rounded xadd195 add -924337723E-640771235 86639377.1 -> 86639377.1 Inexact Rounded xcom195 compare -924337723E-640771235 86639377.1 -> -1 xdiv195 divide -924337723E-640771235 86639377.1 -> -1.06687947E-640771234 Inexact Rounded xdvi195 divideint -924337723E-640771235 86639377.1 -> -0 xmul195 multiply -924337723E-640771235 86639377.1 -> -8.00840446E-640771219 Inexact Rounded xpow195 power -924337723E-640771235 86639377 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem195 remainder -924337723E-640771235 86639377.1 -> -9.24337723E-640771227 xsub195 subtract -924337723E-640771235 86639377.1 -> -86639377.1 Inexact Rounded xadd196 add -620236932.E+656823969 3364722.73 -> -6.20236932E+656823977 Inexact Rounded xcom196 compare -620236932.E+656823969 3364722.73 -> -1 xdiv196 divide -620236932.E+656823969 3364722.73 -> -1.84335228E+656823971 Inexact Rounded xdvi196 divideint -620236932.E+656823969 3364722.73 -> NaN Division_impossible xmul196 multiply -620236932.E+656823969 3364722.73 -> -2.08692530E+656823984 Inexact Rounded xpow196 power -620236932.E+656823969 3364723 -> -Infinity Overflow Inexact Rounded xrem196 remainder -620236932.E+656823969 3364722.73 -> NaN Division_impossible xsub196 subtract -620236932.E+656823969 3364722.73 -> -6.20236932E+656823977 Inexact Rounded xadd197 add 9.10025079 702777882E-8192234 -> 9.10025079 Inexact Rounded xcom197 compare 9.10025079 702777882E-8192234 -> 1 xdiv197 divide 9.10025079 702777882E-8192234 -> 1.29489715E+8192226 Inexact Rounded xdvi197 divideint 9.10025079 702777882E-8192234 -> NaN Division_impossible xmul197 multiply 9.10025079 702777882E-8192234 -> 6.39545498E-8192225 Inexact Rounded xpow197 power 9.10025079 7 -> 5168607.19 Inexact Rounded xrem197 remainder 9.10025079 702777882E-8192234 -> NaN Division_impossible xsub197 subtract 9.10025079 702777882E-8192234 -> 9.10025079 Inexact Rounded xadd198 add -18857539.9 813013129. -> 794155589 Inexact Rounded xcom198 compare -18857539.9 813013129. -> -1 xdiv198 divide -18857539.9 813013129. -> -0.0231946315 Inexact Rounded xdvi198 divideint -18857539.9 813013129. -> -0 xmul198 multiply -18857539.9 813013129. -> -1.53314275E+16 Inexact Rounded xpow198 power -18857539.9 813013129 -> -Infinity Overflow Inexact Rounded xrem198 remainder -18857539.9 813013129. -> -18857539.9 xsub198 subtract -18857539.9 813013129. -> -831870669 Inexact Rounded xadd199 add -8.29530327 3243419.57E+35688332 -> 3.24341957E+35688338 Inexact Rounded xcom199 compare -8.29530327 3243419.57E+35688332 -> -1 xdiv199 divide -8.29530327 3243419.57E+35688332 -> -2.55757946E-35688338 Inexact Rounded xdvi199 divideint -8.29530327 3243419.57E+35688332 -> -0 xmul199 multiply -8.29530327 3243419.57E+35688332 -> -2.69051490E+35688339 Inexact Rounded xpow199 power -8.29530327 3 -> -570.816876 Inexact Rounded xrem199 remainder -8.29530327 3243419.57E+35688332 -> -8.29530327 xsub199 subtract -8.29530327 3243419.57E+35688332 -> -3.24341957E+35688338 Inexact Rounded xadd200 add -57101683.5 763551341E+991491712 -> 7.63551341E+991491720 Inexact Rounded xcom200 compare -57101683.5 763551341E+991491712 -> -1 xdiv200 divide -57101683.5 763551341E+991491712 -> -7.47843405E-991491714 Inexact Rounded xdvi200 divideint -57101683.5 763551341E+991491712 -> -0 xmul200 multiply -57101683.5 763551341E+991491712 -> -4.36000670E+991491728 Inexact Rounded xpow200 power -57101683.5 8 -> 1.13029368E+62 Inexact Rounded xrem200 remainder -57101683.5 763551341E+991491712 -> -57101683.5 xsub200 subtract -57101683.5 763551341E+991491712 -> -7.63551341E+991491720 Inexact Rounded xadd201 add -603326.740 1710.95183 -> -601615.788 Inexact Rounded xcom201 compare -603326.740 1710.95183 -> -1 xdiv201 divide -603326.740 1710.95183 -> -352.626374 Inexact Rounded xdvi201 divideint -603326.740 1710.95183 -> -352 xmul201 multiply -603326.740 1710.95183 -> -1.03226299E+9 Inexact Rounded xpow201 power -603326.740 1711 -> -3.35315976E+9890 Inexact Rounded xrem201 remainder -603326.740 1710.95183 -> -1071.69584 xsub201 subtract -603326.740 1710.95183 -> -605037.692 Inexact Rounded xadd202 add -48142763.3 -943434114 -> -991576877 Inexact Rounded xcom202 compare -48142763.3 -943434114 -> 1 xdiv202 divide -48142763.3 -943434114 -> 0.0510292797 Inexact Rounded xdvi202 divideint -48142763.3 -943434114 -> 0 xmul202 multiply -48142763.3 -943434114 -> 4.54195252E+16 Inexact Rounded xpow202 power -48142763.3 -943434114 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem202 remainder -48142763.3 -943434114 -> -48142763.3 xsub202 subtract -48142763.3 -943434114 -> 895291351 Inexact Rounded xadd203 add -204.586767 -235.531847 -> -440.118614 xcom203 compare -204.586767 -235.531847 -> 1 xdiv203 divide -204.586767 -235.531847 -> 0.868616154 Inexact Rounded xdvi203 divideint -204.586767 -235.531847 -> 0 xmul203 multiply -204.586767 -235.531847 -> 48186.6991 Inexact Rounded xpow203 power -204.586767 -236 -> 4.29438222E-546 Inexact Rounded xrem203 remainder -204.586767 -235.531847 -> -204.586767 xsub203 subtract -204.586767 -235.531847 -> 30.945080 xadd204 add -70.3805581 830137.913 -> 830067.532 Inexact Rounded xcom204 compare -70.3805581 830137.913 -> -1 xdiv204 divide -70.3805581 830137.913 -> -0.0000847817658 Inexact Rounded xdvi204 divideint -70.3805581 830137.913 -> -0 xmul204 multiply -70.3805581 830137.913 -> -58425569.6 Inexact Rounded xpow204 power -70.3805581 830138 -> 4.95165841E+1533640 Inexact Rounded xrem204 remainder -70.3805581 830137.913 -> -70.3805581 xsub204 subtract -70.3805581 830137.913 -> -830208.294 Inexact Rounded xadd205 add -8818.47606 -60766.4571 -> -69584.9332 Inexact Rounded xcom205 compare -8818.47606 -60766.4571 -> 1 xdiv205 divide -8818.47606 -60766.4571 -> 0.145120787 Inexact Rounded xdvi205 divideint -8818.47606 -60766.4571 -> 0 xmul205 multiply -8818.47606 -60766.4571 -> 535867547 Inexact Rounded xpow205 power -8818.47606 -60766 -> 1.64487755E-239746 Inexact Rounded xrem205 remainder -8818.47606 -60766.4571 -> -8818.47606 xsub205 subtract -8818.47606 -60766.4571 -> 51947.9810 Inexact Rounded xadd206 add 37060929.3E-168439509 -79576717.1 -> -79576717.1 Inexact Rounded xcom206 compare 37060929.3E-168439509 -79576717.1 -> 1 xdiv206 divide 37060929.3E-168439509 -79576717.1 -> -4.65725788E-168439510 Inexact Rounded xdvi206 divideint 37060929.3E-168439509 -79576717.1 -> -0 xmul206 multiply 37060929.3E-168439509 -79576717.1 -> -2.94918709E-168439494 Inexact Rounded xpow206 power 37060929.3E-168439509 -79576717 -> Infinity Overflow Inexact Rounded xrem206 remainder 37060929.3E-168439509 -79576717.1 -> 3.70609293E-168439502 xsub206 subtract 37060929.3E-168439509 -79576717.1 -> 79576717.1 Inexact Rounded xadd207 add -656285310. -107221462. -> -763506772 xcom207 compare -656285310. -107221462. -> -1 xdiv207 divide -656285310. -107221462. -> 6.12083904 Inexact Rounded xdvi207 divideint -656285310. -107221462. -> 6 xmul207 multiply -656285310. -107221462. -> 7.03678704E+16 Inexact Rounded xpow207 power -656285310. -107221462 -> 8.05338080E-945381569 Inexact Rounded xrem207 remainder -656285310. -107221462. -> -12956538 xsub207 subtract -656285310. -107221462. -> -549063848 xadd208 add 653397.125 7195.30990 -> 660592.435 Inexact Rounded xcom208 compare 653397.125 7195.30990 -> 1 xdiv208 divide 653397.125 7195.30990 -> 90.8087538 Inexact Rounded xdvi208 divideint 653397.125 7195.30990 -> 90 xmul208 multiply 653397.125 7195.30990 -> 4.70139480E+9 Inexact Rounded xpow208 power 653397.125 7195 -> 1.58522983E+41840 Inexact Rounded xrem208 remainder 653397.125 7195.30990 -> 5819.23400 xsub208 subtract 653397.125 7195.30990 -> 646201.815 Inexact Rounded xadd209 add 56221910.0E+857909374 -58.7247929 -> 5.62219100E+857909381 Inexact Rounded xcom209 compare 56221910.0E+857909374 -58.7247929 -> 1 xdiv209 divide 56221910.0E+857909374 -58.7247929 -> -9.57379451E+857909379 Inexact Rounded xdvi209 divideint 56221910.0E+857909374 -58.7247929 -> NaN Division_impossible xmul209 multiply 56221910.0E+857909374 -58.7247929 -> -3.30162002E+857909383 Inexact Rounded xpow209 power 56221910.0E+857909374 -59 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem209 remainder 56221910.0E+857909374 -58.7247929 -> NaN Division_impossible xsub209 subtract 56221910.0E+857909374 -58.7247929 -> 5.62219100E+857909381 Inexact Rounded xadd210 add 809862859E+643769974 -5.06784016 -> 8.09862859E+643769982 Inexact Rounded xcom210 compare 809862859E+643769974 -5.06784016 -> 1 xdiv210 divide 809862859E+643769974 -5.06784016 -> -1.59804341E+643769982 Inexact Rounded xdvi210 divideint 809862859E+643769974 -5.06784016 -> NaN Division_impossible xmul210 multiply 809862859E+643769974 -5.06784016 -> -4.10425552E+643769983 Inexact Rounded xpow210 power 809862859E+643769974 -5 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem210 remainder 809862859E+643769974 -5.06784016 -> NaN Division_impossible xsub210 subtract 809862859E+643769974 -5.06784016 -> 8.09862859E+643769982 Inexact Rounded xadd211 add -62011.4563E-117563240 -57.1731586E+115657204 -> -5.71731586E+115657205 Inexact Rounded xcom211 compare -62011.4563E-117563240 -57.1731586E+115657204 -> 1 xdiv211 divide -62011.4563E-117563240 -57.1731586E+115657204 -> 1.08462534E-233220441 Inexact Rounded xdvi211 divideint -62011.4563E-117563240 -57.1731586E+115657204 -> 0 xmul211 multiply -62011.4563E-117563240 -57.1731586E+115657204 -> 3.54539083E-1906030 Inexact Rounded xpow211 power -62011.4563E-117563240 -6 -> 1.75860546E+705379411 Inexact Rounded xrem211 remainder -62011.4563E-117563240 -57.1731586E+115657204 -> -6.20114563E-117563236 xsub211 subtract -62011.4563E-117563240 -57.1731586E+115657204 -> 5.71731586E+115657205 Inexact Rounded xadd212 add 315.33351 91588.837E-536020149 -> 315.333510 Inexact Rounded xcom212 compare 315.33351 91588.837E-536020149 -> 1 xdiv212 divide 315.33351 91588.837E-536020149 -> 3.44292515E+536020146 Inexact Rounded xdvi212 divideint 315.33351 91588.837E-536020149 -> NaN Division_impossible xmul212 multiply 315.33351 91588.837E-536020149 -> 2.88810294E-536020142 Inexact Rounded xpow212 power 315.33351 9 -> 3.08269902E+22 Inexact Rounded xrem212 remainder 315.33351 91588.837E-536020149 -> NaN Division_impossible xsub212 subtract 315.33351 91588.837E-536020149 -> 315.333510 Inexact Rounded xadd213 add 739.944710 202949.175 -> 203689.120 Inexact Rounded xcom213 compare 739.944710 202949.175 -> -1 xdiv213 divide 739.944710 202949.175 -> 0.00364596067 Inexact Rounded xdvi213 divideint 739.944710 202949.175 -> 0 xmul213 multiply 739.944710 202949.175 -> 150171168 Inexact Rounded xpow213 power 739.944710 202949 -> 1.32611729E+582301 Inexact Rounded xrem213 remainder 739.944710 202949.175 -> 739.944710 xsub213 subtract 739.944710 202949.175 -> -202209.230 Inexact Rounded xadd214 add 87686.8016 4204890.40 -> 4292577.20 Inexact Rounded xcom214 compare 87686.8016 4204890.40 -> -1 xdiv214 divide 87686.8016 4204890.40 -> 0.0208535285 Inexact Rounded xdvi214 divideint 87686.8016 4204890.40 -> 0 xmul214 multiply 87686.8016 4204890.40 -> 3.68713390E+11 Inexact Rounded xpow214 power 87686.8016 4204890 -> 5.14846981E+20784494 Inexact Rounded xrem214 remainder 87686.8016 4204890.40 -> 87686.8016 xsub214 subtract 87686.8016 4204890.40 -> -4117203.60 Inexact Rounded xadd215 add 987126721.E-725794834 4874166.23 -> 4874166.23 Inexact Rounded xcom215 compare 987126721.E-725794834 4874166.23 -> -1 xdiv215 divide 987126721.E-725794834 4874166.23 -> 2.02522170E-725794832 Inexact Rounded xdvi215 divideint 987126721.E-725794834 4874166.23 -> 0 xmul215 multiply 987126721.E-725794834 4874166.23 -> 4.81141973E-725794819 Inexact Rounded xpow215 power 987126721.E-725794834 4874166 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem215 remainder 987126721.E-725794834 4874166.23 -> 9.87126721E-725794826 xsub215 subtract 987126721.E-725794834 4874166.23 -> -4874166.23 Inexact Rounded xadd216 add 728148726.E-661695938 32798.5202 -> 32798.5202 Inexact Rounded xcom216 compare 728148726.E-661695938 32798.5202 -> -1 xdiv216 divide 728148726.E-661695938 32798.5202 -> 2.22006579E-661695934 Inexact Rounded xdvi216 divideint 728148726.E-661695938 32798.5202 -> 0 xmul216 multiply 728148726.E-661695938 32798.5202 -> 2.38822007E-661695925 Inexact Rounded xpow216 power 728148726.E-661695938 32799 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem216 remainder 728148726.E-661695938 32798.5202 -> 7.28148726E-661695930 xsub216 subtract 728148726.E-661695938 32798.5202 -> -32798.5202 Inexact Rounded xadd217 add 7428219.97 667.326760 -> 7428887.30 Inexact Rounded xcom217 compare 7428219.97 667.326760 -> 1 xdiv217 divide 7428219.97 667.326760 -> 11131.3084 Inexact Rounded xdvi217 divideint 7428219.97 667.326760 -> 11131 xmul217 multiply 7428219.97 667.326760 -> 4.95704997E+9 Inexact Rounded xpow217 power 7428219.97 667 -> 7.58808509E+4582 Inexact Rounded xrem217 remainder 7428219.97 667.326760 -> 205.804440 xsub217 subtract 7428219.97 667.326760 -> 7427552.64 Inexact Rounded xadd218 add -7291.19212 209.64966E-588526476 -> -7291.19212 Inexact Rounded xcom218 compare -7291.19212 209.64966E-588526476 -> -1 xdiv218 divide -7291.19212 209.64966E-588526476 -> -3.47779821E+588526477 Inexact Rounded xdvi218 divideint -7291.19212 209.64966E-588526476 -> NaN Division_impossible xmul218 multiply -7291.19212 209.64966E-588526476 -> -1.52859595E-588526470 Inexact Rounded xpow218 power -7291.19212 2 -> 53161482.5 Inexact Rounded xrem218 remainder -7291.19212 209.64966E-588526476 -> NaN Division_impossible xsub218 subtract -7291.19212 209.64966E-588526476 -> -7291.19212 Inexact Rounded xadd219 add -358.24550 -4447.78675E+601402509 -> -4.44778675E+601402512 Inexact Rounded xcom219 compare -358.24550 -4447.78675E+601402509 -> 1 xdiv219 divide -358.24550 -4447.78675E+601402509 -> 8.05446664E-601402511 Inexact Rounded xdvi219 divideint -358.24550 -4447.78675E+601402509 -> 0 xmul219 multiply -358.24550 -4447.78675E+601402509 -> 1.59339959E+601402515 Inexact Rounded xpow219 power -358.24550 -4 -> 6.07123474E-11 Inexact Rounded xrem219 remainder -358.24550 -4447.78675E+601402509 -> -358.24550 xsub219 subtract -358.24550 -4447.78675E+601402509 -> 4.44778675E+601402512 Inexact Rounded xadd220 add 118.621826 -2.72010038 -> 115.901726 Inexact Rounded xcom220 compare 118.621826 -2.72010038 -> 1 xdiv220 divide 118.621826 -2.72010038 -> -43.6093561 Inexact Rounded xdvi220 divideint 118.621826 -2.72010038 -> -43 xmul220 multiply 118.621826 -2.72010038 -> -322.663274 Inexact Rounded xpow220 power 118.621826 -3 -> 5.99109471E-7 Inexact Rounded xrem220 remainder 118.621826 -2.72010038 -> 1.65750966 xsub220 subtract 118.621826 -2.72010038 -> 121.341926 Inexact Rounded xadd221 add 8071961.94 -135533740.E-102451543 -> 8071961.94 Inexact Rounded xcom221 compare 8071961.94 -135533740.E-102451543 -> 1 xdiv221 divide 8071961.94 -135533740.E-102451543 -> -5.95568450E+102451541 Inexact Rounded xdvi221 divideint 8071961.94 -135533740.E-102451543 -> NaN Division_impossible xmul221 multiply 8071961.94 -135533740.E-102451543 -> -1.09402319E-102451528 Inexact Rounded xpow221 power 8071961.94 -1 -> 1.23885619E-7 Inexact Rounded xrem221 remainder 8071961.94 -135533740.E-102451543 -> NaN Division_impossible xsub221 subtract 8071961.94 -135533740.E-102451543 -> 8071961.94 Inexact Rounded xadd222 add 64262528.5E+812118682 -8692.94447E-732186947 -> 6.42625285E+812118689 Inexact Rounded xcom222 compare 64262528.5E+812118682 -8692.94447E-732186947 -> 1 xdiv222 divide 64262528.5E+812118682 -8692.94447E-732186947 -> -Infinity Inexact Overflow Rounded xdvi222 divideint 64262528.5E+812118682 -8692.94447E-732186947 -> NaN Division_impossible xmul222 multiply 64262528.5E+812118682 -8692.94447E-732186947 -> -5.58630592E+79931746 Inexact Rounded xpow222 power 64262528.5E+812118682 -9 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem222 remainder 64262528.5E+812118682 -8692.94447E-732186947 -> NaN Division_impossible xsub222 subtract 64262528.5E+812118682 -8692.94447E-732186947 -> 6.42625285E+812118689 Inexact Rounded xadd223 add -35544.4029 -567830.130 -> -603374.533 Inexact Rounded xcom223 compare -35544.4029 -567830.130 -> 1 xdiv223 divide -35544.4029 -567830.130 -> 0.0625968948 Inexact Rounded xdvi223 divideint -35544.4029 -567830.130 -> 0 xmul223 multiply -35544.4029 -567830.130 -> 2.01831829E+10 Inexact Rounded xpow223 power -35544.4029 -567830 -> 3.77069368E-2584065 Inexact Rounded xrem223 remainder -35544.4029 -567830.130 -> -35544.4029 xsub223 subtract -35544.4029 -567830.130 -> 532285.727 Inexact Rounded xadd224 add -7.16513047E+59297103 87767.8211 -> -7.16513047E+59297103 Inexact Rounded xcom224 compare -7.16513047E+59297103 87767.8211 -> -1 xdiv224 divide -7.16513047E+59297103 87767.8211 -> -8.16373288E+59297098 Inexact Rounded xdvi224 divideint -7.16513047E+59297103 87767.8211 -> NaN Division_impossible xmul224 multiply -7.16513047E+59297103 87767.8211 -> -6.28867889E+59297108 Inexact Rounded xpow224 power -7.16513047E+59297103 87768 -> Infinity Overflow Inexact Rounded xrem224 remainder -7.16513047E+59297103 87767.8211 -> NaN Division_impossible xsub224 subtract -7.16513047E+59297103 87767.8211 -> -7.16513047E+59297103 Inexact Rounded xadd225 add -509.483395 -147242915. -> -147243424 Inexact Rounded xcom225 compare -509.483395 -147242915. -> 1 xdiv225 divide -509.483395 -147242915. -> 0.00000346015559 Inexact Rounded xdvi225 divideint -509.483395 -147242915. -> 0 xmul225 multiply -509.483395 -147242915. -> 7.50178202E+10 Inexact Rounded xpow225 power -509.483395 -147242915 -> -3.10760519E-398605718 Inexact Rounded xrem225 remainder -509.483395 -147242915. -> -509.483395 xsub225 subtract -509.483395 -147242915. -> 147242406 Inexact Rounded xadd226 add -7919047.28E+956041629 -367667329 -> -7.91904728E+956041635 Inexact Rounded xcom226 compare -7919047.28E+956041629 -367667329 -> -1 xdiv226 divide -7919047.28E+956041629 -367667329 -> 2.15386211E+956041627 Inexact Rounded xdvi226 divideint -7919047.28E+956041629 -367667329 -> NaN Division_impossible xmul226 multiply -7919047.28E+956041629 -367667329 -> 2.91157496E+956041644 Inexact Rounded xpow226 power -7919047.28E+956041629 -367667329 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem226 remainder -7919047.28E+956041629 -367667329 -> NaN Division_impossible xsub226 subtract -7919047.28E+956041629 -367667329 -> -7.91904728E+956041635 Inexact Rounded xadd227 add 895612630. -36.4104040 -> 895612594 Inexact Rounded xcom227 compare 895612630. -36.4104040 -> 1 xdiv227 divide 895612630. -36.4104040 -> -24597712.0 Inexact Rounded xdvi227 divideint 895612630. -36.4104040 -> -24597711 xmul227 multiply 895612630. -36.4104040 -> -3.26096177E+10 Inexact Rounded xpow227 power 895612630. -36 -> 5.29264130E-323 Inexact Rounded xrem227 remainder 895612630. -36.4104040 -> 35.0147560 xsub227 subtract 895612630. -36.4104040 -> 895612666 Inexact Rounded xadd228 add 25455.4973 2955.00006E+528196218 -> 2.95500006E+528196221 Inexact Rounded xcom228 compare 25455.4973 2955.00006E+528196218 -> -1 xdiv228 divide 25455.4973 2955.00006E+528196218 -> 8.61438131E-528196218 Inexact Rounded xdvi228 divideint 25455.4973 2955.00006E+528196218 -> 0 xmul228 multiply 25455.4973 2955.00006E+528196218 -> 7.52209960E+528196225 Inexact Rounded xpow228 power 25455.4973 3 -> 1.64947128E+13 Inexact Rounded xrem228 remainder 25455.4973 2955.00006E+528196218 -> 25455.4973 xsub228 subtract 25455.4973 2955.00006E+528196218 -> -2.95500006E+528196221 Inexact Rounded xadd229 add -112.294144E+273414172 -71448007.7 -> -1.12294144E+273414174 Inexact Rounded xcom229 compare -112.294144E+273414172 -71448007.7 -> -1 xdiv229 divide -112.294144E+273414172 -71448007.7 -> 1.57169035E+273414166 Inexact Rounded xdvi229 divideint -112.294144E+273414172 -71448007.7 -> NaN Division_impossible xmul229 multiply -112.294144E+273414172 -71448007.7 -> 8.02319287E+273414181 Inexact Rounded xpow229 power -112.294144E+273414172 -71448008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem229 remainder -112.294144E+273414172 -71448007.7 -> NaN Division_impossible xsub229 subtract -112.294144E+273414172 -71448007.7 -> -1.12294144E+273414174 Inexact Rounded xadd230 add 62871.2202 2484.0382E+211662557 -> 2.48403820E+211662560 Inexact Rounded xcom230 compare 62871.2202 2484.0382E+211662557 -> -1 xdiv230 divide 62871.2202 2484.0382E+211662557 -> 2.53100859E-211662556 Inexact Rounded xdvi230 divideint 62871.2202 2484.0382E+211662557 -> 0 xmul230 multiply 62871.2202 2484.0382E+211662557 -> 1.56174513E+211662565 Inexact Rounded xpow230 power 62871.2202 2 -> 3.95279033E+9 Inexact Rounded xrem230 remainder 62871.2202 2484.0382E+211662557 -> 62871.2202 xsub230 subtract 62871.2202 2484.0382E+211662557 -> -2.48403820E+211662560 Inexact Rounded xadd231 add 71.9281575 -9810012.5 -> -9809940.57 Inexact Rounded xcom231 compare 71.9281575 -9810012.5 -> 1 xdiv231 divide 71.9281575 -9810012.5 -> -0.00000733211680 Inexact Rounded xdvi231 divideint 71.9281575 -9810012.5 -> -0 xmul231 multiply 71.9281575 -9810012.5 -> -705616124 Inexact Rounded xpow231 power 71.9281575 -9810013 -> 2.00363798E-18216203 Inexact Rounded xrem231 remainder 71.9281575 -9810012.5 -> 71.9281575 xsub231 subtract 71.9281575 -9810012.5 -> 9810084.43 Inexact Rounded xadd232 add -6388022. -88.042967 -> -6388110.04 Inexact Rounded xcom232 compare -6388022. -88.042967 -> -1 xdiv232 divide -6388022. -88.042967 -> 72555.7329 Inexact Rounded xdvi232 divideint -6388022. -88.042967 -> 72555 xmul232 multiply -6388022. -88.042967 -> 562420410 Inexact Rounded xpow232 power -6388022. -88 -> 1.34201238E-599 Inexact Rounded xrem232 remainder -6388022. -88.042967 -> -64.529315 xsub232 subtract -6388022. -88.042967 -> -6387933.96 Inexact Rounded xadd233 add 372567445. 96.0992141 -> 372567541 Inexact Rounded xcom233 compare 372567445. 96.0992141 -> 1 xdiv233 divide 372567445. 96.0992141 -> 3876904.18 Inexact Rounded xdvi233 divideint 372567445. 96.0992141 -> 3876904 xmul233 multiply 372567445. 96.0992141 -> 3.58034387E+10 Inexact Rounded xpow233 power 372567445. 96 -> 6.84968715E+822 Inexact Rounded xrem233 remainder 372567445. 96.0992141 -> 17.4588536 xsub233 subtract 372567445. 96.0992141 -> 372567349 Inexact Rounded xadd234 add 802.156517 -174409310.E-255338020 -> 802.156517 Inexact Rounded xcom234 compare 802.156517 -174409310.E-255338020 -> 1 xdiv234 divide 802.156517 -174409310.E-255338020 -> -4.59927579E+255338014 Inexact Rounded xdvi234 divideint 802.156517 -174409310.E-255338020 -> NaN Division_impossible xmul234 multiply 802.156517 -174409310.E-255338020 -> -1.39903565E-255338009 Inexact Rounded xpow234 power 802.156517 -2 -> 0.00000155411005 Inexact Rounded xrem234 remainder 802.156517 -174409310.E-255338020 -> NaN Division_impossible xsub234 subtract 802.156517 -174409310.E-255338020 -> 802.156517 Inexact Rounded xadd235 add -3.65207541 74501982.0 -> 74501978.3 Inexact Rounded xcom235 compare -3.65207541 74501982.0 -> -1 xdiv235 divide -3.65207541 74501982.0 -> -4.90198423E-8 Inexact Rounded xdvi235 divideint -3.65207541 74501982.0 -> -0 xmul235 multiply -3.65207541 74501982.0 -> -272086856 Inexact Rounded xpow235 power -3.65207541 74501982 -> 2.10339452E+41910325 Inexact Rounded xrem235 remainder -3.65207541 74501982.0 -> -3.65207541 xsub235 subtract -3.65207541 74501982.0 -> -74501985.7 Inexact Rounded xadd236 add -5297.76981 -859.719404 -> -6157.48921 Inexact Rounded xcom236 compare -5297.76981 -859.719404 -> -1 xdiv236 divide -5297.76981 -859.719404 -> 6.16220802 Inexact Rounded xdvi236 divideint -5297.76981 -859.719404 -> 6 xmul236 multiply -5297.76981 -859.719404 -> 4554595.50 Inexact Rounded xpow236 power -5297.76981 -860 -> 1.90523108E-3203 Inexact Rounded xrem236 remainder -5297.76981 -859.719404 -> -139.453386 xsub236 subtract -5297.76981 -859.719404 -> -4438.05041 Inexact Rounded xadd237 add -684172.592 766.448597E+288361959 -> 7.66448597E+288361961 Inexact Rounded xcom237 compare -684172.592 766.448597E+288361959 -> -1 xdiv237 divide -684172.592 766.448597E+288361959 -> -8.92652938E-288361957 Inexact Rounded xdvi237 divideint -684172.592 766.448597E+288361959 -> -0 xmul237 multiply -684172.592 766.448597E+288361959 -> -5.24383123E+288361967 Inexact Rounded xpow237 power -684172.592 8 -> 4.80093005E+46 Inexact Rounded xrem237 remainder -684172.592 766.448597E+288361959 -> -684172.592 xsub237 subtract -684172.592 766.448597E+288361959 -> -7.66448597E+288361961 Inexact Rounded xadd238 add 626919.219 57469.8727E+13188610 -> 5.74698727E+13188614 Inexact Rounded xcom238 compare 626919.219 57469.8727E+13188610 -> -1 xdiv238 divide 626919.219 57469.8727E+13188610 -> 1.09086586E-13188609 Inexact Rounded xdvi238 divideint 626919.219 57469.8727E+13188610 -> 0 xmul238 multiply 626919.219 57469.8727E+13188610 -> 3.60289677E+13188620 Inexact Rounded xpow238 power 626919.219 6 -> 6.07112959E+34 Inexact Rounded xrem238 remainder 626919.219 57469.8727E+13188610 -> 626919.219 xsub238 subtract 626919.219 57469.8727E+13188610 -> -5.74698727E+13188614 Inexact Rounded xadd239 add -77480.5840 893265.594E+287982552 -> 8.93265594E+287982557 Inexact Rounded xcom239 compare -77480.5840 893265.594E+287982552 -> -1 xdiv239 divide -77480.5840 893265.594E+287982552 -> -8.67385742E-287982554 Inexact Rounded xdvi239 divideint -77480.5840 893265.594E+287982552 -> -0 xmul239 multiply -77480.5840 893265.594E+287982552 -> -6.92107399E+287982562 Inexact Rounded xpow239 power -77480.5840 9 -> -1.00631969E+44 Inexact Rounded xrem239 remainder -77480.5840 893265.594E+287982552 -> -77480.5840 xsub239 subtract -77480.5840 893265.594E+287982552 -> -8.93265594E+287982557 Inexact Rounded xadd240 add -7177620.29 7786343.83 -> 608723.54 xcom240 compare -7177620.29 7786343.83 -> -1 xdiv240 divide -7177620.29 7786343.83 -> -0.921821647 Inexact Rounded xdvi240 divideint -7177620.29 7786343.83 -> -0 xmul240 multiply -7177620.29 7786343.83 -> -5.58874195E+13 Inexact Rounded xpow240 power -7177620.29 7786344 -> 2.96037074E+53383022 Inexact Rounded xrem240 remainder -7177620.29 7786343.83 -> -7177620.29 xsub240 subtract -7177620.29 7786343.83 -> -14963964.1 Inexact Rounded xadd241 add 9.6224130 4.50355112 -> 14.1259641 Inexact Rounded xcom241 compare 9.6224130 4.50355112 -> 1 xdiv241 divide 9.6224130 4.50355112 -> 2.13662791 Inexact Rounded xdvi241 divideint 9.6224130 4.50355112 -> 2 xmul241 multiply 9.6224130 4.50355112 -> 43.3350288 Inexact Rounded xpow241 power 9.6224130 5 -> 82493.5448 Inexact Rounded xrem241 remainder 9.6224130 4.50355112 -> 0.61531076 xsub241 subtract 9.6224130 4.50355112 -> 5.11886188 xadd242 add -66.6337347E-597410086 -818812885 -> -818812885 Inexact Rounded xcom242 compare -66.6337347E-597410086 -818812885 -> 1 xdiv242 divide -66.6337347E-597410086 -818812885 -> 8.13784638E-597410094 Inexact Rounded xdvi242 divideint -66.6337347E-597410086 -818812885 -> 0 xmul242 multiply -66.6337347E-597410086 -818812885 -> 5.45605605E-597410076 Inexact Rounded xpow242 power -66.6337347E-597410086 -818812885 -> -Infinity Overflow Inexact Rounded xrem242 remainder -66.6337347E-597410086 -818812885 -> -6.66337347E-597410085 xsub242 subtract -66.6337347E-597410086 -818812885 -> 818812885 Inexact Rounded xadd243 add 65587553.7 600574.736 -> 66188128.4 Inexact Rounded xcom243 compare 65587553.7 600574.736 -> 1 xdiv243 divide 65587553.7 600574.736 -> 109.207980 Inexact Rounded xdvi243 divideint 65587553.7 600574.736 -> 109 xmul243 multiply 65587553.7 600574.736 -> 3.93902277E+13 Inexact Rounded xpow243 power 65587553.7 600575 -> 3.40404817E+4694587 Inexact Rounded xrem243 remainder 65587553.7 600574.736 -> 124907.476 xsub243 subtract 65587553.7 600574.736 -> 64986979.0 Inexact Rounded xadd244 add -32401.939 -585200217. -> -585232619 Inexact Rounded xcom244 compare -32401.939 -585200217. -> 1 xdiv244 divide -32401.939 -585200217. -> 0.0000553689798 Inexact Rounded xdvi244 divideint -32401.939 -585200217. -> 0 xmul244 multiply -32401.939 -585200217. -> 1.89616217E+13 Inexact Rounded xpow244 power -32401.939 -585200217 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem244 remainder -32401.939 -585200217. -> -32401.939 xsub244 subtract -32401.939 -585200217. -> 585167815 Inexact Rounded xadd245 add 69573.988 -9.77003465E+740933668 -> -9.77003465E+740933668 Inexact Rounded xcom245 compare 69573.988 -9.77003465E+740933668 -> 1 xdiv245 divide 69573.988 -9.77003465E+740933668 -> -7.12116082E-740933665 Inexact Rounded xdvi245 divideint 69573.988 -9.77003465E+740933668 -> -0 xmul245 multiply 69573.988 -9.77003465E+740933668 -> -6.79740273E+740933673 Inexact Rounded xpow245 power 69573.988 -10 -> 3.76297229E-49 Inexact Rounded xrem245 remainder 69573.988 -9.77003465E+740933668 -> 69573.988 xsub245 subtract 69573.988 -9.77003465E+740933668 -> 9.77003465E+740933668 Inexact Rounded xadd246 add 2362.06251 -433149546.E-152643629 -> 2362.06251 Inexact Rounded xcom246 compare 2362.06251 -433149546.E-152643629 -> 1 xdiv246 divide 2362.06251 -433149546.E-152643629 -> -5.45322633E+152643623 Inexact Rounded xdvi246 divideint 2362.06251 -433149546.E-152643629 -> NaN Division_impossible xmul246 multiply 2362.06251 -433149546.E-152643629 -> -1.02312630E-152643617 Inexact Rounded xpow246 power 2362.06251 -4 -> 3.21243577E-14 Inexact Rounded xrem246 remainder 2362.06251 -433149546.E-152643629 -> NaN Division_impossible xsub246 subtract 2362.06251 -433149546.E-152643629 -> 2362.06251 Inexact Rounded xadd247 add -615.23488E+249953452 -21437483.7 -> -6.15234880E+249953454 Inexact Rounded xcom247 compare -615.23488E+249953452 -21437483.7 -> -1 xdiv247 divide -615.23488E+249953452 -21437483.7 -> 2.86990250E+249953447 Inexact Rounded xdvi247 divideint -615.23488E+249953452 -21437483.7 -> NaN Division_impossible xmul247 multiply -615.23488E+249953452 -21437483.7 -> 1.31890877E+249953462 Inexact Rounded xpow247 power -615.23488E+249953452 -21437484 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem247 remainder -615.23488E+249953452 -21437483.7 -> NaN Division_impossible xsub247 subtract -615.23488E+249953452 -21437483.7 -> -6.15234880E+249953454 Inexact Rounded xadd248 add 216741082. 250290244 -> 467031326 xcom248 compare 216741082. 250290244 -> -1 xdiv248 divide 216741082. 250290244 -> 0.865958970 Inexact Rounded xdvi248 divideint 216741082. 250290244 -> 0 xmul248 multiply 216741082. 250290244 -> 5.42481783E+16 Inexact Rounded xpow248 power 216741082. 250290244 -> Infinity Overflow Inexact Rounded xrem248 remainder 216741082. 250290244 -> 216741082 xsub248 subtract 216741082. 250290244 -> -33549162 xadd249 add -6364720.49 5539245.64 -> -825474.85 xcom249 compare -6364720.49 5539245.64 -> -1 xdiv249 divide -6364720.49 5539245.64 -> -1.14902297 Inexact Rounded xdvi249 divideint -6364720.49 5539245.64 -> -1 xmul249 multiply -6364720.49 5539245.64 -> -3.52557502E+13 Inexact Rounded xpow249 power -6364720.49 5539246 -> 2.96894641E+37687807 Inexact Rounded xrem249 remainder -6364720.49 5539245.64 -> -825474.85 xsub249 subtract -6364720.49 5539245.64 -> -11903966.1 Inexact Rounded xadd250 add -814599.475 -14.5431191 -> -814614.018 Inexact Rounded xcom250 compare -814599.475 -14.5431191 -> -1 xdiv250 divide -814599.475 -14.5431191 -> 56012.7074 Inexact Rounded xdvi250 divideint -814599.475 -14.5431191 -> 56012 xmul250 multiply -814599.475 -14.5431191 -> 11846817.2 Inexact Rounded xpow250 power -814599.475 -15 -> -2.16689622E-89 Inexact Rounded xrem250 remainder -814599.475 -14.5431191 -> -10.2879708 xsub250 subtract -814599.475 -14.5431191 -> -814584.932 Inexact Rounded xadd251 add -877498.755 507408724E-168628106 -> -877498.755 Inexact Rounded xcom251 compare -877498.755 507408724E-168628106 -> -1 xdiv251 divide -877498.755 507408724E-168628106 -> -1.72937262E+168628103 Inexact Rounded xdvi251 divideint -877498.755 507408724E-168628106 -> NaN Division_impossible xmul251 multiply -877498.755 507408724E-168628106 -> -4.45250524E-168628092 Inexact Rounded xpow251 power -877498.755 5 -> -5.20274505E+29 Inexact Rounded xrem251 remainder -877498.755 507408724E-168628106 -> NaN Division_impossible xsub251 subtract -877498.755 507408724E-168628106 -> -877498.755 Inexact Rounded xadd252 add 10634446.5E+475783861 50.7213056E+17807809 -> 1.06344465E+475783868 Inexact Rounded xcom252 compare 10634446.5E+475783861 50.7213056E+17807809 -> 1 xdiv252 divide 10634446.5E+475783861 50.7213056E+17807809 -> 2.09664289E+457976057 Inexact Rounded xdvi252 divideint 10634446.5E+475783861 50.7213056E+17807809 -> NaN Division_impossible xmul252 multiply 10634446.5E+475783861 50.7213056E+17807809 -> 5.39393011E+493591678 Inexact Rounded xpow252 power 10634446.5E+475783861 5 -> Infinity Overflow Inexact Rounded xrem252 remainder 10634446.5E+475783861 50.7213056E+17807809 -> NaN Division_impossible xsub252 subtract 10634446.5E+475783861 50.7213056E+17807809 -> 1.06344465E+475783868 Inexact Rounded xadd253 add -162726.257E-597285918 -4391.54799 -> -4391.54799 Inexact Rounded xcom253 compare -162726.257E-597285918 -4391.54799 -> 1 xdiv253 divide -162726.257E-597285918 -4391.54799 -> 3.70544185E-597285917 Inexact Rounded xdvi253 divideint -162726.257E-597285918 -4391.54799 -> 0 xmul253 multiply -162726.257E-597285918 -4391.54799 -> 7.14620167E-597285910 Inexact Rounded xpow253 power -162726.257E-597285918 -4392 -> Infinity Overflow Inexact Rounded xrem253 remainder -162726.257E-597285918 -4391.54799 -> -1.62726257E-597285913 xsub253 subtract -162726.257E-597285918 -4391.54799 -> 4391.54799 Inexact Rounded xadd254 add 700354586.E-99856707 7198.0493E+436250299 -> 7.19804930E+436250302 Inexact Rounded xcom254 compare 700354586.E-99856707 7198.0493E+436250299 -> -1 xdiv254 divide 700354586.E-99856707 7198.0493E+436250299 -> 9.72978312E-536107002 Inexact Rounded xdvi254 divideint 700354586.E-99856707 7198.0493E+436250299 -> 0 xmul254 multiply 700354586.E-99856707 7198.0493E+436250299 -> 5.04118684E+336393604 Inexact Rounded xpow254 power 700354586.E-99856707 7 -> 8.26467610E-698996888 Inexact Rounded xrem254 remainder 700354586.E-99856707 7198.0493E+436250299 -> 7.00354586E-99856699 xsub254 subtract 700354586.E-99856707 7198.0493E+436250299 -> -7.19804930E+436250302 Inexact Rounded xadd255 add 39617663E-463704664 -895.290346 -> -895.290346 Inexact Rounded xcom255 compare 39617663E-463704664 -895.290346 -> 1 xdiv255 divide 39617663E-463704664 -895.290346 -> -4.42511898E-463704660 Inexact Rounded xdvi255 divideint 39617663E-463704664 -895.290346 -> -0 xmul255 multiply 39617663E-463704664 -895.290346 -> -3.54693112E-463704654 Inexact Rounded xpow255 power 39617663E-463704664 -895 -> Infinity Overflow Inexact Rounded xrem255 remainder 39617663E-463704664 -895.290346 -> 3.9617663E-463704657 xsub255 subtract 39617663E-463704664 -895.290346 -> 895.290346 Inexact Rounded xadd256 add 5350882.59 -36329829 -> -30978946.4 Inexact Rounded xcom256 compare 5350882.59 -36329829 -> 1 xdiv256 divide 5350882.59 -36329829 -> -0.147286204 Inexact Rounded xdvi256 divideint 5350882.59 -36329829 -> -0 xmul256 multiply 5350882.59 -36329829 -> -1.94396649E+14 Inexact Rounded xpow256 power 5350882.59 -36329829 -> 9.77006107E-244442546 Inexact Rounded xrem256 remainder 5350882.59 -36329829 -> 5350882.59 xsub256 subtract 5350882.59 -36329829 -> 41680711.6 Inexact Rounded xadd257 add 91966.4084E+210382952 166740.46E-42001390 -> 9.19664084E+210382956 Inexact Rounded xcom257 compare 91966.4084E+210382952 166740.46E-42001390 -> 1 xdiv257 divide 91966.4084E+210382952 166740.46E-42001390 -> 5.51554244E+252384341 Inexact Rounded xdvi257 divideint 91966.4084E+210382952 166740.46E-42001390 -> NaN Division_impossible xmul257 multiply 91966.4084E+210382952 166740.46E-42001390 -> 1.53345212E+168381572 Inexact Rounded xpow257 power 91966.4084E+210382952 2 -> 8.45782027E+420765913 Inexact Rounded xrem257 remainder 91966.4084E+210382952 166740.46E-42001390 -> NaN Division_impossible xsub257 subtract 91966.4084E+210382952 166740.46E-42001390 -> 9.19664084E+210382956 Inexact Rounded xadd258 add 231899031.E-481759076 726.337100 -> 726.337100 Inexact Rounded xcom258 compare 231899031.E-481759076 726.337100 -> -1 xdiv258 divide 231899031.E-481759076 726.337100 -> 3.19271907E-481759071 Inexact Rounded xdvi258 divideint 231899031.E-481759076 726.337100 -> 0 xmul258 multiply 231899031.E-481759076 726.337100 -> 1.68436870E-481759065 Inexact Rounded xpow258 power 231899031.E-481759076 726 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem258 remainder 231899031.E-481759076 726.337100 -> 2.31899031E-481759068 xsub258 subtract 231899031.E-481759076 726.337100 -> -726.337100 Inexact Rounded xadd259 add -9611312.33 22109735.9 -> 12498423.6 Inexact Rounded xcom259 compare -9611312.33 22109735.9 -> -1 xdiv259 divide -9611312.33 22109735.9 -> -0.434709504 Inexact Rounded xdvi259 divideint -9611312.33 22109735.9 -> -0 xmul259 multiply -9611312.33 22109735.9 -> -2.12503577E+14 Inexact Rounded xpow259 power -9611312.33 22109736 -> 6.74530828E+154387481 Inexact Rounded xrem259 remainder -9611312.33 22109735.9 -> -9611312.33 xsub259 subtract -9611312.33 22109735.9 -> -31721048.2 Inexact Rounded xadd260 add -5604938.15E-36812542 735937577. -> 735937577 Inexact Rounded xcom260 compare -5604938.15E-36812542 735937577. -> -1 xdiv260 divide -5604938.15E-36812542 735937577. -> -7.61605104E-36812545 Inexact Rounded xdvi260 divideint -5604938.15E-36812542 735937577. -> -0 xmul260 multiply -5604938.15E-36812542 735937577. -> -4.12488460E-36812527 Inexact Rounded xpow260 power -5604938.15E-36812542 735937577 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem260 remainder -5604938.15E-36812542 735937577. -> -5.60493815E-36812536 xsub260 subtract -5604938.15E-36812542 735937577. -> -735937577 Inexact Rounded xadd261 add 693881413. 260547224E-480281418 -> 693881413 Inexact Rounded xcom261 compare 693881413. 260547224E-480281418 -> 1 xdiv261 divide 693881413. 260547224E-480281418 -> 2.66316947E+480281418 Inexact Rounded xdvi261 divideint 693881413. 260547224E-480281418 -> NaN Division_impossible xmul261 multiply 693881413. 260547224E-480281418 -> 1.80788876E-480281401 Inexact Rounded xpow261 power 693881413. 3 -> 3.34084066E+26 Inexact Rounded xrem261 remainder 693881413. 260547224E-480281418 -> NaN Division_impossible xsub261 subtract 693881413. 260547224E-480281418 -> 693881413 Inexact Rounded xadd262 add -34865.7378E-368768024 2297117.88 -> 2297117.88 Inexact Rounded xcom262 compare -34865.7378E-368768024 2297117.88 -> -1 xdiv262 divide -34865.7378E-368768024 2297117.88 -> -1.51780360E-368768026 Inexact Rounded xdvi262 divideint -34865.7378E-368768024 2297117.88 -> -0 xmul262 multiply -34865.7378E-368768024 2297117.88 -> -8.00907097E-368768014 Inexact Rounded xpow262 power -34865.7378E-368768024 2297118 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem262 remainder -34865.7378E-368768024 2297117.88 -> -3.48657378E-368768020 xsub262 subtract -34865.7378E-368768024 2297117.88 -> -2297117.88 Inexact Rounded xadd263 add 1123.32456 7.86747918E+930888796 -> 7.86747918E+930888796 Inexact Rounded xcom263 compare 1123.32456 7.86747918E+930888796 -> -1 xdiv263 divide 1123.32456 7.86747918E+930888796 -> 1.42780748E-930888794 Inexact Rounded xdvi263 divideint 1123.32456 7.86747918E+930888796 -> 0 xmul263 multiply 1123.32456 7.86747918E+930888796 -> 8.83773259E+930888799 Inexact Rounded xpow263 power 1123.32456 8 -> 2.53537401E+24 Inexact Rounded xrem263 remainder 1123.32456 7.86747918E+930888796 -> 1123.32456 xsub263 subtract 1123.32456 7.86747918E+930888796 -> -7.86747918E+930888796 Inexact Rounded xadd264 add 56.6607465E+467812565 909552512E+764516200 -> 9.09552512E+764516208 Inexact Rounded xcom264 compare 56.6607465E+467812565 909552512E+764516200 -> -1 xdiv264 divide 56.6607465E+467812565 909552512E+764516200 -> 6.22951899E-296703643 Inexact Rounded xdvi264 divideint 56.6607465E+467812565 909552512E+764516200 -> 0 xmul264 multiply 56.6607465E+467812565 909552512E+764516200 -> Infinity Inexact Overflow Rounded xpow264 power 56.6607465E+467812565 9 -> Infinity Overflow Inexact Rounded xrem264 remainder 56.6607465E+467812565 909552512E+764516200 -> 5.66607465E+467812566 xsub264 subtract 56.6607465E+467812565 909552512E+764516200 -> -9.09552512E+764516208 Inexact Rounded xadd265 add -1.85771840E+365552540 -73028339.7 -> -1.85771840E+365552540 Inexact Rounded xcom265 compare -1.85771840E+365552540 -73028339.7 -> -1 xdiv265 divide -1.85771840E+365552540 -73028339.7 -> 2.54383217E+365552532 Inexact Rounded xdvi265 divideint -1.85771840E+365552540 -73028339.7 -> NaN Division_impossible xmul265 multiply -1.85771840E+365552540 -73028339.7 -> 1.35666090E+365552548 Inexact Rounded xpow265 power -1.85771840E+365552540 -73028340 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem265 remainder -1.85771840E+365552540 -73028339.7 -> NaN Division_impossible xsub265 subtract -1.85771840E+365552540 -73028339.7 -> -1.85771840E+365552540 Inexact Rounded xadd266 add 34.1935525 -40767.6450 -> -40733.4514 Inexact Rounded xcom266 compare 34.1935525 -40767.6450 -> 1 xdiv266 divide 34.1935525 -40767.6450 -> -0.000838742402 Inexact Rounded xdvi266 divideint 34.1935525 -40767.6450 -> -0 xmul266 multiply 34.1935525 -40767.6450 -> -1393990.61 Inexact Rounded xpow266 power 34.1935525 -40768 -> 1.45174210E-62536 Inexact Rounded xrem266 remainder 34.1935525 -40767.6450 -> 34.1935525 xsub266 subtract 34.1935525 -40767.6450 -> 40801.8386 Inexact Rounded xadd267 add 26.0009168E+751618294 -304019.929 -> 2.60009168E+751618295 Inexact Rounded xcom267 compare 26.0009168E+751618294 -304019.929 -> 1 xdiv267 divide 26.0009168E+751618294 -304019.929 -> -8.55237250E+751618289 Inexact Rounded xdvi267 divideint 26.0009168E+751618294 -304019.929 -> NaN Division_impossible xmul267 multiply 26.0009168E+751618294 -304019.929 -> -7.90479688E+751618300 Inexact Rounded xpow267 power 26.0009168E+751618294 -304020 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem267 remainder 26.0009168E+751618294 -304019.929 -> NaN Division_impossible xsub267 subtract 26.0009168E+751618294 -304019.929 -> 2.60009168E+751618295 Inexact Rounded xadd268 add -58.4853072E+588540055 -4647.3205 -> -5.84853072E+588540056 Inexact Rounded xcom268 compare -58.4853072E+588540055 -4647.3205 -> -1 xdiv268 divide -58.4853072E+588540055 -4647.3205 -> 1.25847372E+588540053 Inexact Rounded xdvi268 divideint -58.4853072E+588540055 -4647.3205 -> NaN Division_impossible xmul268 multiply -58.4853072E+588540055 -4647.3205 -> 2.71799967E+588540060 Inexact Rounded xpow268 power -58.4853072E+588540055 -4647 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem268 remainder -58.4853072E+588540055 -4647.3205 -> NaN Division_impossible xsub268 subtract -58.4853072E+588540055 -4647.3205 -> -5.84853072E+588540056 Inexact Rounded xadd269 add 51.025101 -4467691.57 -> -4467640.54 Inexact Rounded xcom269 compare 51.025101 -4467691.57 -> 1 xdiv269 divide 51.025101 -4467691.57 -> -0.0000114209095 Inexact Rounded xdvi269 divideint 51.025101 -4467691.57 -> -0 xmul269 multiply 51.025101 -4467691.57 -> -227964414 Inexact Rounded xpow269 power 51.025101 -4467692 -> 4.49462589E-7629853 Inexact Rounded xrem269 remainder 51.025101 -4467691.57 -> 51.025101 xsub269 subtract 51.025101 -4467691.57 -> 4467742.60 Inexact Rounded xadd270 add -2214.76582 379785372E+223117572 -> 3.79785372E+223117580 Inexact Rounded xcom270 compare -2214.76582 379785372E+223117572 -> -1 xdiv270 divide -2214.76582 379785372E+223117572 -> -5.83162487E-223117578 Inexact Rounded xdvi270 divideint -2214.76582 379785372E+223117572 -> -0 xmul270 multiply -2214.76582 379785372E+223117572 -> -8.41135661E+223117583 Inexact Rounded xpow270 power -2214.76582 4 -> 2.40608658E+13 Inexact Rounded xrem270 remainder -2214.76582 379785372E+223117572 -> -2214.76582 xsub270 subtract -2214.76582 379785372E+223117572 -> -3.79785372E+223117580 Inexact Rounded xadd271 add -2564.75207E-841443929 -653498187 -> -653498187 Inexact Rounded xcom271 compare -2564.75207E-841443929 -653498187 -> 1 xdiv271 divide -2564.75207E-841443929 -653498187 -> 3.92465063E-841443935 Inexact Rounded xdvi271 divideint -2564.75207E-841443929 -653498187 -> 0 xmul271 multiply -2564.75207E-841443929 -653498187 -> 1.67606083E-841443917 Inexact Rounded xpow271 power -2564.75207E-841443929 -653498187 -> -Infinity Overflow Inexact Rounded xrem271 remainder -2564.75207E-841443929 -653498187 -> -2.56475207E-841443926 xsub271 subtract -2564.75207E-841443929 -653498187 -> 653498187 Inexact Rounded xadd272 add 513115529. 27775075.6E+217133352 -> 2.77750756E+217133359 Inexact Rounded xcom272 compare 513115529. 27775075.6E+217133352 -> -1 xdiv272 divide 513115529. 27775075.6E+217133352 -> 1.84739562E-217133351 Inexact Rounded xdvi272 divideint 513115529. 27775075.6E+217133352 -> 0 xmul272 multiply 513115529. 27775075.6E+217133352 -> 1.42518226E+217133368 Inexact Rounded xpow272 power 513115529. 3 -> 1.35096928E+26 Inexact Rounded xrem272 remainder 513115529. 27775075.6E+217133352 -> 513115529 xsub272 subtract 513115529. 27775075.6E+217133352 -> -2.77750756E+217133359 Inexact Rounded xadd273 add -247157.208 -532990.453 -> -780147.661 xcom273 compare -247157.208 -532990.453 -> 1 xdiv273 divide -247157.208 -532990.453 -> 0.463717890 Inexact Rounded xdvi273 divideint -247157.208 -532990.453 -> 0 xmul273 multiply -247157.208 -532990.453 -> 1.31732432E+11 Inexact Rounded xpow273 power -247157.208 -532990 -> 1.48314033E-2874401 Inexact Rounded xrem273 remainder -247157.208 -532990.453 -> -247157.208 xsub273 subtract -247157.208 -532990.453 -> 285833.245 xadd274 add 40.2490764E-339482253 7626.85442E+594264540 -> 7.62685442E+594264543 Inexact Rounded xcom274 compare 40.2490764E-339482253 7626.85442E+594264540 -> -1 xdiv274 divide 40.2490764E-339482253 7626.85442E+594264540 -> 5.27728395E-933746796 Inexact Rounded xdvi274 divideint 40.2490764E-339482253 7626.85442E+594264540 -> 0 xmul274 multiply 40.2490764E-339482253 7626.85442E+594264540 -> 3.06973846E+254782292 Inexact Rounded xpow274 power 40.2490764E-339482253 8 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem274 remainder 40.2490764E-339482253 7626.85442E+594264540 -> 4.02490764E-339482252 xsub274 subtract 40.2490764E-339482253 7626.85442E+594264540 -> -7.62685442E+594264543 Inexact Rounded xadd275 add -1156008.8 -8870382.36 -> -10026391.2 Inexact Rounded xcom275 compare -1156008.8 -8870382.36 -> 1 xdiv275 divide -1156008.8 -8870382.36 -> 0.130322319 Inexact Rounded xdvi275 divideint -1156008.8 -8870382.36 -> 0 xmul275 multiply -1156008.8 -8870382.36 -> 1.02542401E+13 Inexact Rounded xpow275 power -1156008.8 -8870382 -> 4.32494996E-53780782 Inexact Rounded xrem275 remainder -1156008.8 -8870382.36 -> -1156008.80 xsub275 subtract -1156008.8 -8870382.36 -> 7714373.56 xadd276 add 880097928. -52455011.1E+204538218 -> -5.24550111E+204538225 Inexact Rounded xcom276 compare 880097928. -52455011.1E+204538218 -> 1 xdiv276 divide 880097928. -52455011.1E+204538218 -> -1.67781478E-204538217 Inexact Rounded xdvi276 divideint 880097928. -52455011.1E+204538218 -> -0 xmul276 multiply 880097928. -52455011.1E+204538218 -> -4.61655466E+204538234 Inexact Rounded xpow276 power 880097928. -5 -> 1.89384751E-45 Inexact Rounded xrem276 remainder 880097928. -52455011.1E+204538218 -> 880097928 xsub276 subtract 880097928. -52455011.1E+204538218 -> 5.24550111E+204538225 Inexact Rounded xadd277 add 5796.2524 34458329.7E+832129426 -> 3.44583297E+832129433 Inexact Rounded xcom277 compare 5796.2524 34458329.7E+832129426 -> -1 xdiv277 divide 5796.2524 34458329.7E+832129426 -> 1.68210486E-832129430 Inexact Rounded xdvi277 divideint 5796.2524 34458329.7E+832129426 -> 0 xmul277 multiply 5796.2524 34458329.7E+832129426 -> 1.99729176E+832129437 Inexact Rounded xpow277 power 5796.2524 3 -> 1.94734037E+11 Inexact Rounded xrem277 remainder 5796.2524 34458329.7E+832129426 -> 5796.2524 xsub277 subtract 5796.2524 34458329.7E+832129426 -> -3.44583297E+832129433 Inexact Rounded xadd278 add 27.1000923E-218032223 -45.0198341 -> -45.0198341 Inexact Rounded xcom278 compare 27.1000923E-218032223 -45.0198341 -> 1 xdiv278 divide 27.1000923E-218032223 -45.0198341 -> -6.01958955E-218032224 Inexact Rounded xdvi278 divideint 27.1000923E-218032223 -45.0198341 -> -0 xmul278 multiply 27.1000923E-218032223 -45.0198341 -> -1.22004166E-218032220 Inexact Rounded xpow278 power 27.1000923E-218032223 -45 -> Infinity Overflow Inexact Rounded xrem278 remainder 27.1000923E-218032223 -45.0198341 -> 2.71000923E-218032222 xsub278 subtract 27.1000923E-218032223 -45.0198341 -> 45.0198341 Inexact Rounded xadd279 add 42643477.8 26118465E-730390549 -> 42643477.8 Inexact Rounded xcom279 compare 42643477.8 26118465E-730390549 -> 1 xdiv279 divide 42643477.8 26118465E-730390549 -> 1.63269464E+730390549 Inexact Rounded xdvi279 divideint 42643477.8 26118465E-730390549 -> NaN Division_impossible xmul279 multiply 42643477.8 26118465E-730390549 -> 1.11378218E-730390534 Inexact Rounded xpow279 power 42643477.8 3 -> 7.75457230E+22 Inexact Rounded xrem279 remainder 42643477.8 26118465E-730390549 -> NaN Division_impossible xsub279 subtract 42643477.8 26118465E-730390549 -> 42643477.8 Inexact Rounded xadd280 add -31918.9176E-163031657 -21.5422824E-807317258 -> -3.19189176E-163031653 Inexact Rounded xcom280 compare -31918.9176E-163031657 -21.5422824E-807317258 -> -1 xdiv280 divide -31918.9176E-163031657 -21.5422824E-807317258 -> 1.48168690E+644285604 Inexact Rounded xdvi280 divideint -31918.9176E-163031657 -21.5422824E-807317258 -> NaN Division_impossible xmul280 multiply -31918.9176E-163031657 -21.5422824E-807317258 -> 6.87606337E-970348910 Inexact Rounded xpow280 power -31918.9176E-163031657 -2 -> 9.81530250E+326063304 Inexact Rounded xrem280 remainder -31918.9176E-163031657 -21.5422824E-807317258 -> NaN Division_impossible xsub280 subtract -31918.9176E-163031657 -21.5422824E-807317258 -> -3.19189176E-163031653 Inexact Rounded xadd281 add 84224841.0 2.62548255E+647087608 -> 2.62548255E+647087608 Inexact Rounded xcom281 compare 84224841.0 2.62548255E+647087608 -> -1 xdiv281 divide 84224841.0 2.62548255E+647087608 -> 3.20797565E-647087601 Inexact Rounded xdvi281 divideint 84224841.0 2.62548255E+647087608 -> 0 xmul281 multiply 84224841.0 2.62548255E+647087608 -> 2.21130850E+647087616 Inexact Rounded xpow281 power 84224841.0 3 -> 5.97476185E+23 Inexact Rounded xrem281 remainder 84224841.0 2.62548255E+647087608 -> 84224841.0 xsub281 subtract 84224841.0 2.62548255E+647087608 -> -2.62548255E+647087608 Inexact Rounded xadd282 add -64413698.9 -6674.1055E-701047852 -> -64413698.9 Inexact Rounded xcom282 compare -64413698.9 -6674.1055E-701047852 -> -1 xdiv282 divide -64413698.9 -6674.1055E-701047852 -> 9.65128569E+701047855 Inexact Rounded xdvi282 divideint -64413698.9 -6674.1055E-701047852 -> NaN Division_impossible xmul282 multiply -64413698.9 -6674.1055E-701047852 -> 4.29903822E-701047841 Inexact Rounded xpow282 power -64413698.9 -7 -> -2.17346338E-55 Inexact Rounded xrem282 remainder -64413698.9 -6674.1055E-701047852 -> NaN Division_impossible xsub282 subtract -64413698.9 -6674.1055E-701047852 -> -64413698.9 Inexact Rounded xadd283 add -62.5059208 9.5795779E-898350012 -> -62.5059208 Inexact Rounded xcom283 compare -62.5059208 9.5795779E-898350012 -> -1 xdiv283 divide -62.5059208 9.5795779E-898350012 -> -6.52491388E+898350012 Inexact Rounded xdvi283 divideint -62.5059208 9.5795779E-898350012 -> NaN Division_impossible xmul283 multiply -62.5059208 9.5795779E-898350012 -> -5.98780338E-898350010 Inexact Rounded xpow283 power -62.5059208 10 -> 9.10356659E+17 Inexact Rounded xrem283 remainder -62.5059208 9.5795779E-898350012 -> NaN Division_impossible xsub283 subtract -62.5059208 9.5795779E-898350012 -> -62.5059208 Inexact Rounded xadd284 add 9090950.80 436.400932 -> 9091387.20 Inexact Rounded xcom284 compare 9090950.80 436.400932 -> 1 xdiv284 divide 9090950.80 436.400932 -> 20831.6485 Inexact Rounded xdvi284 divideint 9090950.80 436.400932 -> 20831 xmul284 multiply 9090950.80 436.400932 -> 3.96729940E+9 Inexact Rounded xpow284 power 9090950.80 436 -> 8.98789557E+3033 Inexact Rounded xrem284 remainder 9090950.80 436.400932 -> 282.985508 xsub284 subtract 9090950.80 436.400932 -> 9090514.40 Inexact Rounded xadd285 add -89833825.7E+329205393 -779430.194 -> -8.98338257E+329205400 Inexact Rounded xcom285 compare -89833825.7E+329205393 -779430.194 -> -1 xdiv285 divide -89833825.7E+329205393 -779430.194 -> 1.15255768E+329205395 Inexact Rounded xdvi285 divideint -89833825.7E+329205393 -779430.194 -> NaN Division_impossible xmul285 multiply -89833825.7E+329205393 -779430.194 -> 7.00191962E+329205406 Inexact Rounded xpow285 power -89833825.7E+329205393 -779430 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem285 remainder -89833825.7E+329205393 -779430.194 -> NaN Division_impossible xsub285 subtract -89833825.7E+329205393 -779430.194 -> -8.98338257E+329205400 Inexact Rounded xadd286 add -714562.019E+750205688 704079764 -> -7.14562019E+750205693 Inexact Rounded xcom286 compare -714562.019E+750205688 704079764 -> -1 xdiv286 divide -714562.019E+750205688 704079764 -> -1.01488788E+750205685 Inexact Rounded xdvi286 divideint -714562.019E+750205688 704079764 -> NaN Division_impossible xmul286 multiply -714562.019E+750205688 704079764 -> -5.03108658E+750205702 Inexact Rounded xpow286 power -714562.019E+750205688 704079764 -> Infinity Overflow Inexact Rounded xrem286 remainder -714562.019E+750205688 704079764 -> NaN Division_impossible xsub286 subtract -714562.019E+750205688 704079764 -> -7.14562019E+750205693 Inexact Rounded xadd287 add -584537670. 31139.7737E-146687560 -> -584537670 Inexact Rounded xcom287 compare -584537670. 31139.7737E-146687560 -> -1 xdiv287 divide -584537670. 31139.7737E-146687560 -> -1.87714168E+146687564 Inexact Rounded xdvi287 divideint -584537670. 31139.7737E-146687560 -> NaN Division_impossible xmul287 multiply -584537670. 31139.7737E-146687560 -> -1.82023708E-146687547 Inexact Rounded xpow287 power -584537670. 3 -> -1.99727337E+26 Inexact Rounded xrem287 remainder -584537670. 31139.7737E-146687560 -> NaN Division_impossible xsub287 subtract -584537670. 31139.7737E-146687560 -> -584537670 Inexact Rounded xadd288 add -4.18074650E-858746879 571035.277E-279409165 -> 5.71035277E-279409160 Inexact Rounded xcom288 compare -4.18074650E-858746879 571035.277E-279409165 -> -1 xdiv288 divide -4.18074650E-858746879 571035.277E-279409165 -> -7.32134540E-579337720 Inexact Rounded xdvi288 divideint -4.18074650E-858746879 571035.277E-279409165 -> -0 xmul288 multiply -4.18074650E-858746879 571035.277E-279409165 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow288 power -4.18074650E-858746879 6 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem288 remainder -4.18074650E-858746879 571035.277E-279409165 -> -4.18074650E-858746879 xsub288 subtract -4.18074650E-858746879 571035.277E-279409165 -> -5.71035277E-279409160 Inexact Rounded xadd289 add 5.15309635 -695649.219E+451948183 -> -6.95649219E+451948188 Inexact Rounded xcom289 compare 5.15309635 -695649.219E+451948183 -> 1 xdiv289 divide 5.15309635 -695649.219E+451948183 -> -7.40760747E-451948189 Inexact Rounded xdvi289 divideint 5.15309635 -695649.219E+451948183 -> -0 xmul289 multiply 5.15309635 -695649.219E+451948183 -> -3.58474745E+451948189 Inexact Rounded xpow289 power 5.15309635 -7 -> 0.0000103638749 Inexact Rounded xrem289 remainder 5.15309635 -695649.219E+451948183 -> 5.15309635 xsub289 subtract 5.15309635 -695649.219E+451948183 -> 6.95649219E+451948188 Inexact Rounded xadd290 add -940030153.E+83797657 -4.11510193 -> -9.40030153E+83797665 Inexact Rounded xcom290 compare -940030153.E+83797657 -4.11510193 -> -1 xdiv290 divide -940030153.E+83797657 -4.11510193 -> 2.28434233E+83797665 Inexact Rounded xdvi290 divideint -940030153.E+83797657 -4.11510193 -> NaN Division_impossible xmul290 multiply -940030153.E+83797657 -4.11510193 -> 3.86831990E+83797666 Inexact Rounded xpow290 power -940030153.E+83797657 -4 -> 1.28065710E-335190664 Inexact Rounded xrem290 remainder -940030153.E+83797657 -4.11510193 -> NaN Division_impossible xsub290 subtract -940030153.E+83797657 -4.11510193 -> -9.40030153E+83797665 Inexact Rounded xadd291 add 89088.9683E+587739290 1.31932110 -> 8.90889683E+587739294 Inexact Rounded xcom291 compare 89088.9683E+587739290 1.31932110 -> 1 xdiv291 divide 89088.9683E+587739290 1.31932110 -> 6.75263727E+587739294 Inexact Rounded xdvi291 divideint 89088.9683E+587739290 1.31932110 -> NaN Division_impossible xmul291 multiply 89088.9683E+587739290 1.31932110 -> 1.17536956E+587739295 Inexact Rounded xpow291 power 89088.9683E+587739290 1 -> 8.90889683E+587739294 xrem291 remainder 89088.9683E+587739290 1.31932110 -> NaN Division_impossible xsub291 subtract 89088.9683E+587739290 1.31932110 -> 8.90889683E+587739294 Inexact Rounded xadd292 add 3336750 6.47961126 -> 3336756.48 Inexact Rounded xcom292 compare 3336750 6.47961126 -> 1 xdiv292 divide 3336750 6.47961126 -> 514961.448 Inexact Rounded xdvi292 divideint 3336750 6.47961126 -> 514961 xmul292 multiply 3336750 6.47961126 -> 21620842.9 Inexact Rounded xpow292 power 3336750 6 -> 1.38019997E+39 Inexact Rounded xrem292 remainder 3336750 6.47961126 -> 2.90593914 xsub292 subtract 3336750 6.47961126 -> 3336743.52 Inexact Rounded xadd293 add 904654622. 692065270.E+329081915 -> 6.92065270E+329081923 Inexact Rounded xcom293 compare 904654622. 692065270.E+329081915 -> -1 xdiv293 divide 904654622. 692065270.E+329081915 -> 1.30718107E-329081915 Inexact Rounded xdvi293 divideint 904654622. 692065270.E+329081915 -> 0 xmul293 multiply 904654622. 692065270.E+329081915 -> 6.26080045E+329081932 Inexact Rounded xpow293 power 904654622. 7 -> 4.95883485E+62 Inexact Rounded xrem293 remainder 904654622. 692065270.E+329081915 -> 904654622 xsub293 subtract 904654622. 692065270.E+329081915 -> -6.92065270E+329081923 Inexact Rounded xadd294 add 304804380 -4681.23698 -> 304799699 Inexact Rounded xcom294 compare 304804380 -4681.23698 -> 1 xdiv294 divide 304804380 -4681.23698 -> -65111.9312 Inexact Rounded xdvi294 divideint 304804380 -4681.23698 -> -65111 xmul294 multiply 304804380 -4681.23698 -> -1.42686154E+12 Inexact Rounded xpow294 power 304804380 -4681 -> 1.98037102E-39714 Inexact Rounded xrem294 remainder 304804380 -4681.23698 -> 4358.99522 xsub294 subtract 304804380 -4681.23698 -> 304809061 Inexact Rounded xadd295 add 674.55569 -82981.2684E+852890752 -> -8.29812684E+852890756 Inexact Rounded xcom295 compare 674.55569 -82981.2684E+852890752 -> 1 xdiv295 divide 674.55569 -82981.2684E+852890752 -> -8.12901156E-852890755 Inexact Rounded xdvi295 divideint 674.55569 -82981.2684E+852890752 -> -0 xmul295 multiply 674.55569 -82981.2684E+852890752 -> -5.59754868E+852890759 Inexact Rounded xpow295 power 674.55569 -8 -> 2.33269265E-23 Inexact Rounded xrem295 remainder 674.55569 -82981.2684E+852890752 -> 674.55569 xsub295 subtract 674.55569 -82981.2684E+852890752 -> 8.29812684E+852890756 Inexact Rounded xadd296 add -5111.51025E-108006096 5448870.4E+279212255 -> 5.44887040E+279212261 Inexact Rounded xcom296 compare -5111.51025E-108006096 5448870.4E+279212255 -> -1 xdiv296 divide -5111.51025E-108006096 5448870.4E+279212255 -> -9.38086222E-387218355 Inexact Rounded xdvi296 divideint -5111.51025E-108006096 5448870.4E+279212255 -> -0 xmul296 multiply -5111.51025E-108006096 5448870.4E+279212255 -> -2.78519569E+171206169 Inexact Rounded xpow296 power -5111.51025E-108006096 5 -> -3.48936323E-540030462 Inexact Rounded xrem296 remainder -5111.51025E-108006096 5448870.4E+279212255 -> -5.11151025E-108006093 xsub296 subtract -5111.51025E-108006096 5448870.4E+279212255 -> -5.44887040E+279212261 Inexact Rounded xadd297 add -2623.45068 -466463938. -> -466466561 Inexact Rounded xcom297 compare -2623.45068 -466463938. -> 1 xdiv297 divide -2623.45068 -466463938. -> 0.00000562412325 Inexact Rounded xdvi297 divideint -2623.45068 -466463938. -> 0 xmul297 multiply -2623.45068 -466463938. -> 1.22374514E+12 Inexact Rounded xpow297 power -2623.45068 -466463938 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem297 remainder -2623.45068 -466463938. -> -2623.45068 xsub297 subtract -2623.45068 -466463938. -> 466461315 Inexact Rounded xadd298 add 299350.435 3373.33551 -> 302723.771 Inexact Rounded xcom298 compare 299350.435 3373.33551 -> 1 xdiv298 divide 299350.435 3373.33551 -> 88.7401903 Inexact Rounded xdvi298 divideint 299350.435 3373.33551 -> 88 xmul298 multiply 299350.435 3373.33551 -> 1.00980945E+9 Inexact Rounded xpow298 power 299350.435 3373 -> 1.42817370E+18471 Inexact Rounded xrem298 remainder 299350.435 3373.33551 -> 2496.91012 xsub298 subtract 299350.435 3373.33551 -> 295977.099 Inexact Rounded xadd299 add -6589947.80 -2448.75933E-591549734 -> -6589947.80 Inexact Rounded xcom299 compare -6589947.80 -2448.75933E-591549734 -> -1 xdiv299 divide -6589947.80 -2448.75933E-591549734 -> 2.69113739E+591549737 Inexact Rounded xdvi299 divideint -6589947.80 -2448.75933E-591549734 -> NaN Division_impossible xmul299 multiply -6589947.80 -2448.75933E-591549734 -> 1.61371962E-591549724 Inexact Rounded xpow299 power -6589947.80 -2 -> 2.30269305E-14 Inexact Rounded xrem299 remainder -6589947.80 -2448.75933E-591549734 -> NaN Division_impossible xsub299 subtract -6589947.80 -2448.75933E-591549734 -> -6589947.80 Inexact Rounded xadd300 add 3774.5358E-491090520 173.060090 -> 173.060090 Inexact Rounded xcom300 compare 3774.5358E-491090520 173.060090 -> -1 xdiv300 divide 3774.5358E-491090520 173.060090 -> 2.18105503E-491090519 Inexact Rounded xdvi300 divideint 3774.5358E-491090520 173.060090 -> 0 xmul300 multiply 3774.5358E-491090520 173.060090 -> 6.53221505E-491090515 Inexact Rounded xpow300 power 3774.5358E-491090520 173 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem300 remainder 3774.5358E-491090520 173.060090 -> 3.7745358E-491090517 xsub300 subtract 3774.5358E-491090520 173.060090 -> -173.060090 Inexact Rounded xadd301 add -13.6783690 -453.610117 -> -467.288486 Rounded xcom301 compare -13.6783690 -453.610117 -> 1 xdiv301 divide -13.6783690 -453.610117 -> 0.0301544619 Inexact Rounded xdvi301 divideint -13.6783690 -453.610117 -> 0 xmul301 multiply -13.6783690 -453.610117 -> 6204.64656 Inexact Rounded xpow301 power -13.6783690 -454 -> 1.73948535E-516 Inexact Rounded xrem301 remainder -13.6783690 -453.610117 -> -13.6783690 xsub301 subtract -13.6783690 -453.610117 -> 439.931748 Rounded xadd302 add -990100927.E-615244634 223801.421E+247632618 -> 2.23801421E+247632623 Inexact Rounded xcom302 compare -990100927.E-615244634 223801.421E+247632618 -> -1 xdiv302 divide -990100927.E-615244634 223801.421E+247632618 -> -4.42401537E-862877249 Inexact Rounded xdvi302 divideint -990100927.E-615244634 223801.421E+247632618 -> -0 xmul302 multiply -990100927.E-615244634 223801.421E+247632618 -> -2.21585994E-367612002 Inexact Rounded xpow302 power -990100927.E-615244634 2 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem302 remainder -990100927.E-615244634 223801.421E+247632618 -> -9.90100927E-615244626 xsub302 subtract -990100927.E-615244634 223801.421E+247632618 -> -2.23801421E+247632623 Inexact Rounded xadd303 add 1275.10292 -667965353 -> -667964078 Inexact Rounded xcom303 compare 1275.10292 -667965353 -> 1 xdiv303 divide 1275.10292 -667965353 -> -0.00000190893572 Inexact Rounded xdvi303 divideint 1275.10292 -667965353 -> -0 xmul303 multiply 1275.10292 -667965353 -> -8.51724572E+11 Inexact Rounded xpow303 power 1275.10292 -667965353 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem303 remainder 1275.10292 -667965353 -> 1275.10292 xsub303 subtract 1275.10292 -667965353 -> 667966628 Inexact Rounded xadd304 add -8.76375480E-596792197 992.077361 -> 992.077361 Inexact Rounded xcom304 compare -8.76375480E-596792197 992.077361 -> -1 xdiv304 divide -8.76375480E-596792197 992.077361 -> -8.83374134E-596792200 Inexact Rounded xdvi304 divideint -8.76375480E-596792197 992.077361 -> -0 xmul304 multiply -8.76375480E-596792197 992.077361 -> -8.69432273E-596792194 Inexact Rounded xpow304 power -8.76375480E-596792197 992 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem304 remainder -8.76375480E-596792197 992.077361 -> -8.76375480E-596792197 xsub304 subtract -8.76375480E-596792197 992.077361 -> -992.077361 Inexact Rounded xadd305 add 953.976935E+385444720 96503.3378 -> 9.53976935E+385444722 Inexact Rounded xcom305 compare 953.976935E+385444720 96503.3378 -> 1 xdiv305 divide 953.976935E+385444720 96503.3378 -> 9.88542942E+385444717 Inexact Rounded xdvi305 divideint 953.976935E+385444720 96503.3378 -> NaN Division_impossible xmul305 multiply 953.976935E+385444720 96503.3378 -> 9.20619584E+385444727 Inexact Rounded xpow305 power 953.976935E+385444720 96503 -> Infinity Overflow Inexact Rounded xrem305 remainder 953.976935E+385444720 96503.3378 -> NaN Division_impossible xsub305 subtract 953.976935E+385444720 96503.3378 -> 9.53976935E+385444722 Inexact Rounded xadd306 add 213577152 -986710073E+31900046 -> -9.86710073E+31900054 Inexact Rounded xcom306 compare 213577152 -986710073E+31900046 -> 1 xdiv306 divide 213577152 -986710073E+31900046 -> -2.16453807E-31900047 Inexact Rounded xdvi306 divideint 213577152 -986710073E+31900046 -> -0 xmul306 multiply 213577152 -986710073E+31900046 -> -2.10738727E+31900063 Inexact Rounded xpow306 power 213577152 -10 -> 5.06351487E-84 Inexact Rounded xrem306 remainder 213577152 -986710073E+31900046 -> 213577152 xsub306 subtract 213577152 -986710073E+31900046 -> 9.86710073E+31900054 Inexact Rounded xadd307 add 91393.9398E-323439228 -135.701000 -> -135.701000 Inexact Rounded xcom307 compare 91393.9398E-323439228 -135.701000 -> 1 xdiv307 divide 91393.9398E-323439228 -135.701000 -> -6.73494962E-323439226 Inexact Rounded xdvi307 divideint 91393.9398E-323439228 -135.701000 -> -0 xmul307 multiply 91393.9398E-323439228 -135.701000 -> -1.24022490E-323439221 Inexact Rounded xpow307 power 91393.9398E-323439228 -136 -> Infinity Overflow Inexact Rounded xrem307 remainder 91393.9398E-323439228 -135.701000 -> 9.13939398E-323439224 xsub307 subtract 91393.9398E-323439228 -135.701000 -> 135.701000 Inexact Rounded xadd308 add -396.503557 45757264.E-254363788 -> -396.503557 Inexact Rounded xcom308 compare -396.503557 45757264.E-254363788 -> -1 xdiv308 divide -396.503557 45757264.E-254363788 -> -8.66536856E+254363782 Inexact Rounded xdvi308 divideint -396.503557 45757264.E-254363788 -> NaN Division_impossible xmul308 multiply -396.503557 45757264.E-254363788 -> -1.81429179E-254363778 Inexact Rounded xpow308 power -396.503557 5 -> -9.80021128E+12 Inexact Rounded xrem308 remainder -396.503557 45757264.E-254363788 -> NaN Division_impossible xsub308 subtract -396.503557 45757264.E-254363788 -> -396.503557 Inexact Rounded xadd309 add 59807846.1 1.53345254 -> 59807847.6 Inexact Rounded xcom309 compare 59807846.1 1.53345254 -> 1 xdiv309 divide 59807846.1 1.53345254 -> 39002084.9 Inexact Rounded xdvi309 divideint 59807846.1 1.53345254 -> 39002084 xmul309 multiply 59807846.1 1.53345254 -> 91712493.5 Inexact Rounded xpow309 power 59807846.1 2 -> 3.57697846E+15 Inexact Rounded xrem309 remainder 59807846.1 1.53345254 -> 1.32490664 xsub309 subtract 59807846.1 1.53345254 -> 59807844.6 Inexact Rounded xadd310 add -8046158.45 8.3635397 -> -8046150.09 Inexact Rounded xcom310 compare -8046158.45 8.3635397 -> -1 xdiv310 divide -8046158.45 8.3635397 -> -962051.803 Inexact Rounded xdvi310 divideint -8046158.45 8.3635397 -> -962051 xmul310 multiply -8046158.45 8.3635397 -> -67294365.6 Inexact Rounded xpow310 power -8046158.45 8 -> 1.75674467E+55 Inexact Rounded xrem310 remainder -8046158.45 8.3635397 -> -6.7180753 xsub310 subtract -8046158.45 8.3635397 -> -8046166.81 Inexact Rounded xadd311 add 55.1123381E+50627250 -94.0355047E-162540316 -> 5.51123381E+50627251 Inexact Rounded xcom311 compare 55.1123381E+50627250 -94.0355047E-162540316 -> 1 xdiv311 divide 55.1123381E+50627250 -94.0355047E-162540316 -> -5.86080101E+213167565 Inexact Rounded xdvi311 divideint 55.1123381E+50627250 -94.0355047E-162540316 -> NaN Division_impossible xmul311 multiply 55.1123381E+50627250 -94.0355047E-162540316 -> -5.18251653E-111913063 Inexact Rounded xpow311 power 55.1123381E+50627250 -9 -> 2.13186881E-455645266 Inexact Rounded xrem311 remainder 55.1123381E+50627250 -94.0355047E-162540316 -> NaN Division_impossible xsub311 subtract 55.1123381E+50627250 -94.0355047E-162540316 -> 5.51123381E+50627251 Inexact Rounded xadd312 add -948.038054 3580.84510 -> 2632.80705 Inexact Rounded xcom312 compare -948.038054 3580.84510 -> -1 xdiv312 divide -948.038054 3580.84510 -> -0.264752601 Inexact Rounded xdvi312 divideint -948.038054 3580.84510 -> -0 xmul312 multiply -948.038054 3580.84510 -> -3394777.42 Inexact Rounded xpow312 power -948.038054 3581 -> -1.03058288E+10660 Inexact Rounded xrem312 remainder -948.038054 3580.84510 -> -948.038054 xsub312 subtract -948.038054 3580.84510 -> -4528.88315 Inexact Rounded xadd313 add -6026.42752 -14.2286406E-334921364 -> -6026.42752 Inexact Rounded xcom313 compare -6026.42752 -14.2286406E-334921364 -> -1 xdiv313 divide -6026.42752 -14.2286406E-334921364 -> 4.23542044E+334921366 Inexact Rounded xdvi313 divideint -6026.42752 -14.2286406E-334921364 -> NaN Division_impossible xmul313 multiply -6026.42752 -14.2286406E-334921364 -> 8.57478713E-334921360 Inexact Rounded xpow313 power -6026.42752 -1 -> -0.000165935788 Inexact Rounded xrem313 remainder -6026.42752 -14.2286406E-334921364 -> NaN Division_impossible xsub313 subtract -6026.42752 -14.2286406E-334921364 -> -6026.42752 Inexact Rounded xadd314 add 79551.5014 -538.186229 -> 79013.3152 Inexact Rounded xcom314 compare 79551.5014 -538.186229 -> 1 xdiv314 divide 79551.5014 -538.186229 -> -147.814078 Inexact Rounded xdvi314 divideint 79551.5014 -538.186229 -> -147 xmul314 multiply 79551.5014 -538.186229 -> -42813522.5 Inexact Rounded xpow314 power 79551.5014 -538 -> 2.82599389E-2637 Inexact Rounded xrem314 remainder 79551.5014 -538.186229 -> 438.125737 xsub314 subtract 79551.5014 -538.186229 -> 80089.6876 Inexact Rounded xadd315 add 42706056.E+623578292 -690.327745 -> 4.27060560E+623578299 Inexact Rounded xcom315 compare 42706056.E+623578292 -690.327745 -> 1 xdiv315 divide 42706056.E+623578292 -690.327745 -> -6.18634501E+623578296 Inexact Rounded xdvi315 divideint 42706056.E+623578292 -690.327745 -> NaN Division_impossible xmul315 multiply 42706056.E+623578292 -690.327745 -> -2.94811753E+623578302 Inexact Rounded xpow315 power 42706056.E+623578292 -690 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem315 remainder 42706056.E+623578292 -690.327745 -> NaN Division_impossible xsub315 subtract 42706056.E+623578292 -690.327745 -> 4.27060560E+623578299 Inexact Rounded xadd316 add 2454136.08E+502374077 856268.795E-356664934 -> 2.45413608E+502374083 Inexact Rounded xcom316 compare 2454136.08E+502374077 856268.795E-356664934 -> 1 xdiv316 divide 2454136.08E+502374077 856268.795E-356664934 -> 2.86608142E+859039011 Inexact Rounded xdvi316 divideint 2454136.08E+502374077 856268.795E-356664934 -> NaN Division_impossible xmul316 multiply 2454136.08E+502374077 856268.795E-356664934 -> 2.10140014E+145709155 Inexact Rounded xpow316 power 2454136.08E+502374077 9 -> Infinity Overflow Inexact Rounded xrem316 remainder 2454136.08E+502374077 856268.795E-356664934 -> NaN Division_impossible xsub316 subtract 2454136.08E+502374077 856268.795E-356664934 -> 2.45413608E+502374083 Inexact Rounded xadd317 add -3264204.54 -42704.501 -> -3306909.04 Inexact Rounded xcom317 compare -3264204.54 -42704.501 -> -1 xdiv317 divide -3264204.54 -42704.501 -> 76.4370140 Inexact Rounded xdvi317 divideint -3264204.54 -42704.501 -> 76 xmul317 multiply -3264204.54 -42704.501 -> 1.39396226E+11 Inexact Rounded xpow317 power -3264204.54 -42705 -> -1.37293410E-278171 Inexact Rounded xrem317 remainder -3264204.54 -42704.501 -> -18662.464 xsub317 subtract -3264204.54 -42704.501 -> -3221500.04 Inexact Rounded xadd318 add 1.21265492 44102.6073 -> 44103.8200 Inexact Rounded xcom318 compare 1.21265492 44102.6073 -> -1 xdiv318 divide 1.21265492 44102.6073 -> 0.0000274962183 Inexact Rounded xdvi318 divideint 1.21265492 44102.6073 -> 0 xmul318 multiply 1.21265492 44102.6073 -> 53481.2437 Inexact Rounded xpow318 power 1.21265492 44103 -> 1.15662573E+3693 Inexact Rounded xrem318 remainder 1.21265492 44102.6073 -> 1.21265492 xsub318 subtract 1.21265492 44102.6073 -> -44101.3946 Inexact Rounded xadd319 add -19.054711E+975514652 -22144.0822 -> -1.90547110E+975514653 Inexact Rounded xcom319 compare -19.054711E+975514652 -22144.0822 -> -1 xdiv319 divide -19.054711E+975514652 -22144.0822 -> 8.60487729E+975514648 Inexact Rounded xdvi319 divideint -19.054711E+975514652 -22144.0822 -> NaN Division_impossible xmul319 multiply -19.054711E+975514652 -22144.0822 -> 4.21949087E+975514657 Inexact Rounded xpow319 power -19.054711E+975514652 -22144 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem319 remainder -19.054711E+975514652 -22144.0822 -> NaN Division_impossible xsub319 subtract -19.054711E+975514652 -22144.0822 -> -1.90547110E+975514653 Inexact Rounded xadd320 add 745.78452 -1922.00670E+375923302 -> -1.92200670E+375923305 Inexact Rounded xcom320 compare 745.78452 -1922.00670E+375923302 -> 1 xdiv320 divide 745.78452 -1922.00670E+375923302 -> -3.88023892E-375923303 Inexact Rounded xdvi320 divideint 745.78452 -1922.00670E+375923302 -> -0 xmul320 multiply 745.78452 -1922.00670E+375923302 -> -1.43340284E+375923308 Inexact Rounded xpow320 power 745.78452 -2 -> 0.00000179793204 Inexact Rounded xrem320 remainder 745.78452 -1922.00670E+375923302 -> 745.78452 xsub320 subtract 745.78452 -1922.00670E+375923302 -> 1.92200670E+375923305 Inexact Rounded xadd321 add -963717836 -823989308 -> -1.78770714E+9 Inexact Rounded xcom321 compare -963717836 -823989308 -> -1 xdiv321 divide -963717836 -823989308 -> 1.16957566 Inexact Rounded xdvi321 divideint -963717836 -823989308 -> 1 xmul321 multiply -963717836 -823989308 -> 7.94093193E+17 Inexact Rounded xpow321 power -963717836 -823989308 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem321 remainder -963717836 -823989308 -> -139728528 xsub321 subtract -963717836 -823989308 -> -139728528 xadd322 add 82.4185291E-321919303 -215747737.E-995147400 -> 8.24185291E-321919302 Inexact Rounded xcom322 compare 82.4185291E-321919303 -215747737.E-995147400 -> 1 xdiv322 divide 82.4185291E-321919303 -215747737.E-995147400 -> -3.82013412E+673228090 Inexact Rounded xdvi322 divideint 82.4185291E-321919303 -215747737.E-995147400 -> NaN Division_impossible xmul322 multiply 82.4185291E-321919303 -215747737.E-995147400 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow322 power 82.4185291E-321919303 -2 -> 1.47214396E+643838602 Inexact Rounded xrem322 remainder 82.4185291E-321919303 -215747737.E-995147400 -> NaN Division_impossible xsub322 subtract 82.4185291E-321919303 -215747737.E-995147400 -> 8.24185291E-321919302 Inexact Rounded xadd323 add -808328.607E-790810342 53075.7082 -> 53075.7082 Inexact Rounded xcom323 compare -808328.607E-790810342 53075.7082 -> -1 xdiv323 divide -808328.607E-790810342 53075.7082 -> -1.52297281E-790810341 Inexact Rounded xdvi323 divideint -808328.607E-790810342 53075.7082 -> -0 xmul323 multiply -808328.607E-790810342 53075.7082 -> -4.29026133E-790810332 Inexact Rounded xpow323 power -808328.607E-790810342 53076 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem323 remainder -808328.607E-790810342 53075.7082 -> -8.08328607E-790810337 xsub323 subtract -808328.607E-790810342 53075.7082 -> -53075.7082 Inexact Rounded xadd324 add 700592.720 -698485.085 -> 2107.635 xcom324 compare 700592.720 -698485.085 -> 1 xdiv324 divide 700592.720 -698485.085 -> -1.00301744 Inexact Rounded xdvi324 divideint 700592.720 -698485.085 -> -1 xmul324 multiply 700592.720 -698485.085 -> -4.89353566E+11 Inexact Rounded xpow324 power 700592.720 -698485 -> 8.83690000E-4082971 Inexact Rounded xrem324 remainder 700592.720 -698485.085 -> 2107.635 xsub324 subtract 700592.720 -698485.085 -> 1399077.81 Inexact Rounded xadd325 add -80273928.0 661346.239 -> -79612581.8 Inexact Rounded xcom325 compare -80273928.0 661346.239 -> -1 xdiv325 divide -80273928.0 661346.239 -> -121.379579 Inexact Rounded xdvi325 divideint -80273928.0 661346.239 -> -121 xmul325 multiply -80273928.0 661346.239 -> -5.30888604E+13 Inexact Rounded xpow325 power -80273928.0 661346 -> 5.45664856E+5227658 Inexact Rounded xrem325 remainder -80273928.0 661346.239 -> -251033.081 xsub325 subtract -80273928.0 661346.239 -> -80935274.2 Inexact Rounded xadd326 add -24018251.0E+819786764 59141.9600E-167165065 -> -2.40182510E+819786771 Inexact Rounded xcom326 compare -24018251.0E+819786764 59141.9600E-167165065 -> -1 xdiv326 divide -24018251.0E+819786764 59141.9600E-167165065 -> -4.06111854E+986951831 Inexact Rounded xdvi326 divideint -24018251.0E+819786764 59141.9600E-167165065 -> NaN Division_impossible xmul326 multiply -24018251.0E+819786764 59141.9600E-167165065 -> -1.42048644E+652621711 Inexact Rounded xpow326 power -24018251.0E+819786764 6 -> Infinity Overflow Inexact Rounded xrem326 remainder -24018251.0E+819786764 59141.9600E-167165065 -> NaN Division_impossible xsub326 subtract -24018251.0E+819786764 59141.9600E-167165065 -> -2.40182510E+819786771 Inexact Rounded xadd327 add 2512953.3 -3769170.35E-993621645 -> 2512953.30 Inexact Rounded xcom327 compare 2512953.3 -3769170.35E-993621645 -> 1 xdiv327 divide 2512953.3 -3769170.35E-993621645 -> -6.66712583E+993621644 Inexact Rounded xdvi327 divideint 2512953.3 -3769170.35E-993621645 -> NaN Division_impossible xmul327 multiply 2512953.3 -3769170.35E-993621645 -> -9.47174907E-993621633 Inexact Rounded xpow327 power 2512953.3 -4 -> 2.50762348E-26 Inexact Rounded xrem327 remainder 2512953.3 -3769170.35E-993621645 -> NaN Division_impossible xsub327 subtract 2512953.3 -3769170.35E-993621645 -> 2512953.30 Inexact Rounded xadd328 add -682.796370 71131.0224 -> 70448.2260 Inexact Rounded xcom328 compare -682.796370 71131.0224 -> -1 xdiv328 divide -682.796370 71131.0224 -> -0.00959913617 Inexact Rounded xdvi328 divideint -682.796370 71131.0224 -> -0 xmul328 multiply -682.796370 71131.0224 -> -48568003.9 Inexact Rounded xpow328 power -682.796370 71131 -> -9.28114741E+201605 Inexact Rounded xrem328 remainder -682.796370 71131.0224 -> -682.796370 xsub328 subtract -682.796370 71131.0224 -> -71813.8188 Inexact Rounded xadd329 add 89.9997490 -4993.69831 -> -4903.69856 Inexact Rounded xcom329 compare 89.9997490 -4993.69831 -> 1 xdiv329 divide 89.9997490 -4993.69831 -> -0.0180226644 Inexact Rounded xdvi329 divideint 89.9997490 -4993.69831 -> -0 xmul329 multiply 89.9997490 -4993.69831 -> -449431.594 Inexact Rounded xpow329 power 89.9997490 -4994 -> 3.30336525E-9760 Inexact Rounded xrem329 remainder 89.9997490 -4993.69831 -> 89.9997490 xsub329 subtract 89.9997490 -4993.69831 -> 5083.69806 Inexact Rounded xadd330 add 76563354.6E-112338836 278271.585E-511481095 -> 7.65633546E-112338829 Inexact Rounded xcom330 compare 76563354.6E-112338836 278271.585E-511481095 -> 1 xdiv330 divide 76563354.6E-112338836 278271.585E-511481095 -> 2.75138960E+399142261 Inexact Rounded xdvi330 divideint 76563354.6E-112338836 278271.585E-511481095 -> NaN Division_impossible xmul330 multiply 76563354.6E-112338836 278271.585E-511481095 -> 2.13054060E-623819918 Inexact Rounded xpow330 power 76563354.6E-112338836 3 -> 4.48810347E-337016485 Inexact Rounded xrem330 remainder 76563354.6E-112338836 278271.585E-511481095 -> NaN Division_impossible xsub330 subtract 76563354.6E-112338836 278271.585E-511481095 -> 7.65633546E-112338829 Inexact Rounded xadd331 add -932499.010 873.377701E-502190452 -> -932499.010 Inexact Rounded xcom331 compare -932499.010 873.377701E-502190452 -> -1 xdiv331 divide -932499.010 873.377701E-502190452 -> -1.06769272E+502190455 Inexact Rounded xdvi331 divideint -932499.010 873.377701E-502190452 -> NaN Division_impossible xmul331 multiply -932499.010 873.377701E-502190452 -> -8.14423842E-502190444 Inexact Rounded xpow331 power -932499.010 9 -> -5.33132815E+53 Inexact Rounded xrem331 remainder -932499.010 873.377701E-502190452 -> NaN Division_impossible xsub331 subtract -932499.010 873.377701E-502190452 -> -932499.010 Inexact Rounded xadd332 add -7735918.21E+799514797 -7748.78023 -> -7.73591821E+799514803 Inexact Rounded xcom332 compare -7735918.21E+799514797 -7748.78023 -> -1 xdiv332 divide -7735918.21E+799514797 -7748.78023 -> 9.98340123E+799514799 Inexact Rounded xdvi332 divideint -7735918.21E+799514797 -7748.78023 -> NaN Division_impossible xmul332 multiply -7735918.21E+799514797 -7748.78023 -> 5.99439301E+799514807 Inexact Rounded xpow332 power -7735918.21E+799514797 -7749 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem332 remainder -7735918.21E+799514797 -7748.78023 -> NaN Division_impossible xsub332 subtract -7735918.21E+799514797 -7748.78023 -> -7.73591821E+799514803 Inexact Rounded xadd333 add -3708780.75E+445232787 980.006567E-780728623 -> -3.70878075E+445232793 Inexact Rounded xcom333 compare -3708780.75E+445232787 980.006567E-780728623 -> -1 xdiv333 divide -3708780.75E+445232787 980.006567E-780728623 -> -Infinity Inexact Overflow Rounded xdvi333 divideint -3708780.75E+445232787 980.006567E-780728623 -> NaN Division_impossible xmul333 multiply -3708780.75E+445232787 980.006567E-780728623 -> -3.63462949E-335495827 Inexact Rounded xpow333 power -3708780.75E+445232787 10 -> Infinity Overflow Inexact Rounded xrem333 remainder -3708780.75E+445232787 980.006567E-780728623 -> NaN Division_impossible xsub333 subtract -3708780.75E+445232787 980.006567E-780728623 -> -3.70878075E+445232793 Inexact Rounded xadd334 add -5205124.44E-140588661 -495394029.E-620856313 -> -5.20512444E-140588655 Inexact Rounded xcom334 compare -5205124.44E-140588661 -495394029.E-620856313 -> -1 xdiv334 divide -5205124.44E-140588661 -495394029.E-620856313 -> 1.05070391E+480267650 Inexact Rounded xdvi334 divideint -5205124.44E-140588661 -495394029.E-620856313 -> NaN Division_impossible xmul334 multiply -5205124.44E-140588661 -495394029.E-620856313 -> 2.57858757E-761444959 Inexact Rounded xpow334 power -5205124.44E-140588661 -5 -> -2.61724523E+702943271 Inexact Rounded xrem334 remainder -5205124.44E-140588661 -495394029.E-620856313 -> NaN Division_impossible xsub334 subtract -5205124.44E-140588661 -495394029.E-620856313 -> -5.20512444E-140588655 Inexact Rounded xadd335 add -8868.72074 5592399.93 -> 5583531.21 Inexact Rounded xcom335 compare -8868.72074 5592399.93 -> -1 xdiv335 divide -8868.72074 5592399.93 -> -0.00158585238 Inexact Rounded xdvi335 divideint -8868.72074 5592399.93 -> -0 xmul335 multiply -8868.72074 5592399.93 -> -4.95974332E+10 Inexact Rounded xpow335 power -8868.72074 5592400 -> 5.55074142E+22078017 Inexact Rounded xrem335 remainder -8868.72074 5592399.93 -> -8868.72074 xsub335 subtract -8868.72074 5592399.93 -> -5601268.65 Inexact Rounded xadd336 add -74.7852037E-175205809 4.14316542 -> 4.14316542 Inexact Rounded xcom336 compare -74.7852037E-175205809 4.14316542 -> -1 xdiv336 divide -74.7852037E-175205809 4.14316542 -> -1.80502577E-175205808 Inexact Rounded xdvi336 divideint -74.7852037E-175205809 4.14316542 -> -0 xmul336 multiply -74.7852037E-175205809 4.14316542 -> -3.09847470E-175205807 Inexact Rounded xpow336 power -74.7852037E-175205809 4 -> 3.12797104E-700823229 Inexact Rounded xrem336 remainder -74.7852037E-175205809 4.14316542 -> -7.47852037E-175205808 xsub336 subtract -74.7852037E-175205809 4.14316542 -> -4.14316542 Inexact Rounded xadd337 add 84196.1091E+242628748 8.07523036E-288231467 -> 8.41961091E+242628752 Inexact Rounded xcom337 compare 84196.1091E+242628748 8.07523036E-288231467 -> 1 xdiv337 divide 84196.1091E+242628748 8.07523036E-288231467 -> 1.04264653E+530860219 Inexact Rounded xdvi337 divideint 84196.1091E+242628748 8.07523036E-288231467 -> NaN Division_impossible xmul337 multiply 84196.1091E+242628748 8.07523036E-288231467 -> 6.79902976E-45602714 Inexact Rounded xpow337 power 84196.1091E+242628748 8 -> Infinity Overflow Inexact Rounded xrem337 remainder 84196.1091E+242628748 8.07523036E-288231467 -> NaN Division_impossible xsub337 subtract 84196.1091E+242628748 8.07523036E-288231467 -> 8.41961091E+242628752 Inexact Rounded xadd338 add 38660103.1 -6671.73085E+900998477 -> -6.67173085E+900998480 Inexact Rounded xcom338 compare 38660103.1 -6671.73085E+900998477 -> 1 xdiv338 divide 38660103.1 -6671.73085E+900998477 -> -5.79461372E-900998474 Inexact Rounded xdvi338 divideint 38660103.1 -6671.73085E+900998477 -> -0 xmul338 multiply 38660103.1 -6671.73085E+900998477 -> -2.57929803E+900998488 Inexact Rounded xpow338 power 38660103.1 -7 -> 7.74745290E-54 Inexact Rounded xrem338 remainder 38660103.1 -6671.73085E+900998477 -> 38660103.1 xsub338 subtract 38660103.1 -6671.73085E+900998477 -> 6.67173085E+900998480 Inexact Rounded xadd339 add -52.2659460 -296404199E+372050476 -> -2.96404199E+372050484 Inexact Rounded xcom339 compare -52.2659460 -296404199E+372050476 -> 1 xdiv339 divide -52.2659460 -296404199E+372050476 -> 1.76333352E-372050483 Inexact Rounded xdvi339 divideint -52.2659460 -296404199E+372050476 -> 0 xmul339 multiply -52.2659460 -296404199E+372050476 -> 1.54918459E+372050486 Inexact Rounded xpow339 power -52.2659460 -3 -> -0.00000700395833 Inexact Rounded xrem339 remainder -52.2659460 -296404199E+372050476 -> -52.2659460 xsub339 subtract -52.2659460 -296404199E+372050476 -> 2.96404199E+372050484 Inexact Rounded xadd340 add 6.06625013 -276.359186 -> -270.292936 Inexact Rounded xcom340 compare 6.06625013 -276.359186 -> 1 xdiv340 divide 6.06625013 -276.359186 -> -0.0219506007 Inexact Rounded xdvi340 divideint 6.06625013 -276.359186 -> -0 xmul340 multiply 6.06625013 -276.359186 -> -1676.46395 Inexact Rounded xpow340 power 6.06625013 -276 -> 8.20339149E-217 Inexact Rounded xrem340 remainder 6.06625013 -276.359186 -> 6.06625013 xsub340 subtract 6.06625013 -276.359186 -> 282.425436 Inexact Rounded xadd341 add -62971617.5E-241444744 46266799.3 -> 46266799.3 Inexact Rounded xcom341 compare -62971617.5E-241444744 46266799.3 -> -1 xdiv341 divide -62971617.5E-241444744 46266799.3 -> -1.36105411E-241444744 Inexact Rounded xdvi341 divideint -62971617.5E-241444744 46266799.3 -> -0 xmul341 multiply -62971617.5E-241444744 46266799.3 -> -2.91349519E-241444729 Inexact Rounded xpow341 power -62971617.5E-241444744 46266799 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem341 remainder -62971617.5E-241444744 46266799.3 -> -6.29716175E-241444737 xsub341 subtract -62971617.5E-241444744 46266799.3 -> -46266799.3 Inexact Rounded xadd342 add -5.36917800 -311124593.E-976066491 -> -5.36917800 Inexact Rounded xcom342 compare -5.36917800 -311124593.E-976066491 -> -1 xdiv342 divide -5.36917800 -311124593.E-976066491 -> 1.72573243E+976066483 Inexact Rounded xdvi342 divideint -5.36917800 -311124593.E-976066491 -> NaN Division_impossible xmul342 multiply -5.36917800 -311124593.E-976066491 -> 1.67048332E-976066482 Inexact Rounded xpow342 power -5.36917800 -3 -> -0.00646065565 Inexact Rounded xrem342 remainder -5.36917800 -311124593.E-976066491 -> NaN Division_impossible xsub342 subtract -5.36917800 -311124593.E-976066491 -> -5.36917800 Inexact Rounded xadd343 add 2467915.01 -92.5558322 -> 2467822.45 Inexact Rounded xcom343 compare 2467915.01 -92.5558322 -> 1 xdiv343 divide 2467915.01 -92.5558322 -> -26664.0681 Inexact Rounded xdvi343 divideint 2467915.01 -92.5558322 -> -26664 xmul343 multiply 2467915.01 -92.5558322 -> -228419928 Inexact Rounded xpow343 power 2467915.01 -93 -> 3.26055444E-595 Inexact Rounded xrem343 remainder 2467915.01 -92.5558322 -> 6.3002192 xsub343 subtract 2467915.01 -92.5558322 -> 2468007.57 Inexact Rounded xadd344 add 187.232671 -840.469347 -> -653.236676 xcom344 compare 187.232671 -840.469347 -> 1 xdiv344 divide 187.232671 -840.469347 -> -0.222771564 Inexact Rounded xdvi344 divideint 187.232671 -840.469347 -> -0 xmul344 multiply 187.232671 -840.469347 -> -157363.321 Inexact Rounded xpow344 power 187.232671 -840 -> 1.58280862E-1909 Inexact Rounded xrem344 remainder 187.232671 -840.469347 -> 187.232671 xsub344 subtract 187.232671 -840.469347 -> 1027.70202 Inexact Rounded xadd345 add 81233.6823 -5192.21666E+309315093 -> -5.19221666E+309315096 Inexact Rounded xcom345 compare 81233.6823 -5192.21666E+309315093 -> 1 xdiv345 divide 81233.6823 -5192.21666E+309315093 -> -1.56452798E-309315092 Inexact Rounded xdvi345 divideint 81233.6823 -5192.21666E+309315093 -> -0 xmul345 multiply 81233.6823 -5192.21666E+309315093 -> -4.21782879E+309315101 Inexact Rounded xpow345 power 81233.6823 -5 -> 2.82695763E-25 Inexact Rounded xrem345 remainder 81233.6823 -5192.21666E+309315093 -> 81233.6823 xsub345 subtract 81233.6823 -5192.21666E+309315093 -> 5.19221666E+309315096 Inexact Rounded xadd346 add -854.586113 -79.8715762E-853065103 -> -854.586113 Inexact Rounded xcom346 compare -854.586113 -79.8715762E-853065103 -> -1 xdiv346 divide -854.586113 -79.8715762E-853065103 -> 1.06995023E+853065104 Inexact Rounded xdvi346 divideint -854.586113 -79.8715762E-853065103 -> NaN Division_impossible xmul346 multiply -854.586113 -79.8715762E-853065103 -> 6.82571398E-853065099 Inexact Rounded xpow346 power -854.586113 -8 -> 3.51522679E-24 Inexact Rounded xrem346 remainder -854.586113 -79.8715762E-853065103 -> NaN Division_impossible xsub346 subtract -854.586113 -79.8715762E-853065103 -> -854.586113 Inexact Rounded xadd347 add 78872665.3 172.102119 -> 78872837.4 Inexact Rounded xcom347 compare 78872665.3 172.102119 -> 1 xdiv347 divide 78872665.3 172.102119 -> 458289.914 Inexact Rounded xdvi347 divideint 78872665.3 172.102119 -> 458289 xmul347 multiply 78872665.3 172.102119 -> 1.35741528E+10 Inexact Rounded xpow347 power 78872665.3 172 -> 1.86793137E+1358 Inexact Rounded xrem347 remainder 78872665.3 172.102119 -> 157.285609 xsub347 subtract 78872665.3 172.102119 -> 78872493.2 Inexact Rounded xadd348 add 328268.1E-436315617 -204.522245 -> -204.522245 Inexact Rounded xcom348 compare 328268.1E-436315617 -204.522245 -> 1 xdiv348 divide 328268.1E-436315617 -204.522245 -> -1.60504839E-436315614 Inexact Rounded xdvi348 divideint 328268.1E-436315617 -204.522245 -> -0 xmul348 multiply 328268.1E-436315617 -204.522245 -> -6.71381288E-436315610 Inexact Rounded xpow348 power 328268.1E-436315617 -205 -> Infinity Overflow Inexact Rounded xrem348 remainder 328268.1E-436315617 -204.522245 -> 3.282681E-436315612 xsub348 subtract 328268.1E-436315617 -204.522245 -> 204.522245 Inexact Rounded xadd349 add -4037911.02E+641367645 29.5713010 -> -4.03791102E+641367651 Inexact Rounded xcom349 compare -4037911.02E+641367645 29.5713010 -> -1 xdiv349 divide -4037911.02E+641367645 29.5713010 -> -1.36548305E+641367650 Inexact Rounded xdvi349 divideint -4037911.02E+641367645 29.5713010 -> NaN Division_impossible xmul349 multiply -4037911.02E+641367645 29.5713010 -> -1.19406282E+641367653 Inexact Rounded xpow349 power -4037911.02E+641367645 30 -> Infinity Overflow Inexact Rounded xrem349 remainder -4037911.02E+641367645 29.5713010 -> NaN Division_impossible xsub349 subtract -4037911.02E+641367645 29.5713010 -> -4.03791102E+641367651 Inexact Rounded xadd350 add -688755561.E-95301699 978.275312E+913812609 -> 9.78275312E+913812611 Inexact Rounded xcom350 compare -688755561.E-95301699 978.275312E+913812609 -> -1 xdiv350 divide -688755561.E-95301699 978.275312E+913812609 -> -0E-1000000007 Inexact Rounded Underflow Subnormal Clamped xdvi350 divideint -688755561.E-95301699 978.275312E+913812609 -> -0 xmul350 multiply -688755561.E-95301699 978.275312E+913812609 -> -6.73792561E+818510921 Inexact Rounded xpow350 power -688755561.E-95301699 10 -> 2.40243244E-953016902 Inexact Rounded xrem350 remainder -688755561.E-95301699 978.275312E+913812609 -> -6.88755561E-95301691 xsub350 subtract -688755561.E-95301699 978.275312E+913812609 -> -9.78275312E+913812611 Inexact Rounded xadd351 add -5.47345502 59818.7580 -> 59813.2845 Inexact Rounded xcom351 compare -5.47345502 59818.7580 -> -1 xdiv351 divide -5.47345502 59818.7580 -> -0.0000915006463 Inexact Rounded xdvi351 divideint -5.47345502 59818.7580 -> -0 xmul351 multiply -5.47345502 59818.7580 -> -327415.281 Inexact Rounded xpow351 power -5.47345502 59819 -> -1.16914146E+44162 Inexact Rounded xrem351 remainder -5.47345502 59818.7580 -> -5.47345502 xsub351 subtract -5.47345502 59818.7580 -> -59824.2315 Inexact Rounded xadd352 add 563891620E-361354567 -845900362. -> -845900362 Inexact Rounded xcom352 compare 563891620E-361354567 -845900362. -> 1 xdiv352 divide 563891620E-361354567 -845900362. -> -6.66617069E-361354568 Inexact Rounded xdvi352 divideint 563891620E-361354567 -845900362. -> -0 xmul352 multiply 563891620E-361354567 -845900362. -> -4.76996125E-361354550 Inexact Rounded xpow352 power 563891620E-361354567 -845900362 -> Infinity Overflow Inexact Rounded xrem352 remainder 563891620E-361354567 -845900362. -> 5.63891620E-361354559 xsub352 subtract 563891620E-361354567 -845900362. -> 845900362 Inexact Rounded xadd353 add -69.7231286 85773.7504 -> 85704.0273 Inexact Rounded xcom353 compare -69.7231286 85773.7504 -> -1 xdiv353 divide -69.7231286 85773.7504 -> -0.000812872566 Inexact Rounded xdvi353 divideint -69.7231286 85773.7504 -> -0 xmul353 multiply -69.7231286 85773.7504 -> -5980414.23 Inexact Rounded xpow353 power -69.7231286 85774 -> 6.41714261E+158113 Inexact Rounded xrem353 remainder -69.7231286 85773.7504 -> -69.7231286 xsub353 subtract -69.7231286 85773.7504 -> -85843.4735 Inexact Rounded xadd354 add 5125.51188 73814638.4E-500934741 -> 5125.51188 Inexact Rounded xcom354 compare 5125.51188 73814638.4E-500934741 -> 1 xdiv354 divide 5125.51188 73814638.4E-500934741 -> 6.94376074E+500934736 Inexact Rounded xdvi354 divideint 5125.51188 73814638.4E-500934741 -> NaN Division_impossible xmul354 multiply 5125.51188 73814638.4E-500934741 -> 3.78337806E-500934730 Inexact Rounded xpow354 power 5125.51188 7 -> 9.29310216E+25 Inexact Rounded xrem354 remainder 5125.51188 73814638.4E-500934741 -> NaN Division_impossible xsub354 subtract 5125.51188 73814638.4E-500934741 -> 5125.51188 Inexact Rounded xadd355 add -54.6254096 -332921899. -> -332921954 Inexact Rounded xcom355 compare -54.6254096 -332921899. -> 1 xdiv355 divide -54.6254096 -332921899. -> 1.64078752E-7 Inexact Rounded xdvi355 divideint -54.6254096 -332921899. -> 0 xmul355 multiply -54.6254096 -332921899. -> 1.81859951E+10 Inexact Rounded xpow355 power -54.6254096 -332921899 -> -1.01482569E-578416745 Inexact Rounded xrem355 remainder -54.6254096 -332921899. -> -54.6254096 xsub355 subtract -54.6254096 -332921899. -> 332921844 Inexact Rounded xadd356 add -9.04778095E-591874079 8719.40286 -> 8719.40286 Inexact Rounded xcom356 compare -9.04778095E-591874079 8719.40286 -> -1 xdiv356 divide -9.04778095E-591874079 8719.40286 -> -1.03766062E-591874082 Inexact Rounded xdvi356 divideint -9.04778095E-591874079 8719.40286 -> -0 xmul356 multiply -9.04778095E-591874079 8719.40286 -> -7.88912471E-591874075 Inexact Rounded xpow356 power -9.04778095E-591874079 8719 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem356 remainder -9.04778095E-591874079 8719.40286 -> -9.04778095E-591874079 xsub356 subtract -9.04778095E-591874079 8719.40286 -> -8719.40286 Inexact Rounded xadd357 add -21006.1733E+884684431 -48872.9175 -> -2.10061733E+884684435 Inexact Rounded xcom357 compare -21006.1733E+884684431 -48872.9175 -> -1 xdiv357 divide -21006.1733E+884684431 -48872.9175 -> 4.29812141E+884684430 Inexact Rounded xdvi357 divideint -21006.1733E+884684431 -48872.9175 -> NaN Division_impossible xmul357 multiply -21006.1733E+884684431 -48872.9175 -> 1.02663297E+884684440 Inexact Rounded xpow357 power -21006.1733E+884684431 -48873 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem357 remainder -21006.1733E+884684431 -48872.9175 -> NaN Division_impossible xsub357 subtract -21006.1733E+884684431 -48872.9175 -> -2.10061733E+884684435 Inexact Rounded xadd358 add -1546783 -51935370.4 -> -53482153.4 xcom358 compare -1546783 -51935370.4 -> 1 xdiv358 divide -1546783 -51935370.4 -> 0.0297828433 Inexact Rounded xdvi358 divideint -1546783 -51935370.4 -> 0 xmul358 multiply -1546783 -51935370.4 -> 8.03327480E+13 Inexact Rounded xpow358 power -1546783 -51935370 -> 3.36022461E-321450306 Inexact Rounded xrem358 remainder -1546783 -51935370.4 -> -1546783.0 xsub358 subtract -1546783 -51935370.4 -> 50388587.4 xadd359 add 61302486.8 205.490417 -> 61302692.3 Inexact Rounded xcom359 compare 61302486.8 205.490417 -> 1 xdiv359 divide 61302486.8 205.490417 -> 298322.850 Inexact Rounded xdvi359 divideint 61302486.8 205.490417 -> 298322 xmul359 multiply 61302486.8 205.490417 -> 1.25970736E+10 Inexact Rounded xpow359 power 61302486.8 205 -> 2.71024755E+1596 Inexact Rounded xrem359 remainder 61302486.8 205.490417 -> 174.619726 xsub359 subtract 61302486.8 205.490417 -> 61302281.3 Inexact Rounded xadd360 add -318180109. -54008744.6E-170931002 -> -318180109 Inexact Rounded xcom360 compare -318180109. -54008744.6E-170931002 -> -1 xdiv360 divide -318180109. -54008744.6E-170931002 -> 5.89127023E+170931002 Inexact Rounded xdvi360 divideint -318180109. -54008744.6E-170931002 -> NaN Division_impossible xmul360 multiply -318180109. -54008744.6E-170931002 -> 1.71845082E-170930986 Inexact Rounded xpow360 power -318180109. -5 -> -3.06644280E-43 Inexact Rounded xrem360 remainder -318180109. -54008744.6E-170931002 -> NaN Division_impossible xsub360 subtract -318180109. -54008744.6E-170931002 -> -318180109 Inexact Rounded xadd361 add -28486137.1E+901441714 -42454.940 -> -2.84861371E+901441721 Inexact Rounded xcom361 compare -28486137.1E+901441714 -42454.940 -> -1 xdiv361 divide -28486137.1E+901441714 -42454.940 -> 6.70973439E+901441716 Inexact Rounded xdvi361 divideint -28486137.1E+901441714 -42454.940 -> NaN Division_impossible xmul361 multiply -28486137.1E+901441714 -42454.940 -> 1.20937724E+901441726 Inexact Rounded xpow361 power -28486137.1E+901441714 -42455 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem361 remainder -28486137.1E+901441714 -42454.940 -> NaN Division_impossible xsub361 subtract -28486137.1E+901441714 -42454.940 -> -2.84861371E+901441721 Inexact Rounded xadd362 add -546398328. -27.9149712 -> -546398356 Inexact Rounded xcom362 compare -546398328. -27.9149712 -> -1 xdiv362 divide -546398328. -27.9149712 -> 19573666.2 Inexact Rounded xdvi362 divideint -546398328. -27.9149712 -> 19573666 xmul362 multiply -546398328. -27.9149712 -> 1.52526936E+10 Inexact Rounded xpow362 power -546398328. -28 -> 2.23737032E-245 Inexact Rounded xrem362 remainder -546398328. -27.9149712 -> -5.3315808 xsub362 subtract -546398328. -27.9149712 -> -546398300 Inexact Rounded xadd363 add 5402066.1E-284978216 622.751128 -> 622.751128 Inexact Rounded xcom363 compare 5402066.1E-284978216 622.751128 -> -1 xdiv363 divide 5402066.1E-284978216 622.751128 -> 8.67451837E-284978213 Inexact Rounded xdvi363 divideint 5402066.1E-284978216 622.751128 -> 0 xmul363 multiply 5402066.1E-284978216 622.751128 -> 3.36414276E-284978207 Inexact Rounded xpow363 power 5402066.1E-284978216 623 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem363 remainder 5402066.1E-284978216 622.751128 -> 5.4020661E-284978210 xsub363 subtract 5402066.1E-284978216 622.751128 -> -622.751128 Inexact Rounded xadd364 add 18845620 3129.43753 -> 18848749.4 Inexact Rounded xcom364 compare 18845620 3129.43753 -> 1 xdiv364 divide 18845620 3129.43753 -> 6022.04704 Inexact Rounded xdvi364 divideint 18845620 3129.43753 -> 6022 xmul364 multiply 18845620 3129.43753 -> 5.89761905E+10 Inexact Rounded xpow364 power 18845620 3129 -> 1.35967443E+22764 Inexact Rounded xrem364 remainder 18845620 3129.43753 -> 147.19434 xsub364 subtract 18845620 3129.43753 -> 18842490.6 Inexact Rounded xadd365 add 50707.1412E+912475670 -198098.186E+701407524 -> 5.07071412E+912475674 Inexact Rounded xcom365 compare 50707.1412E+912475670 -198098.186E+701407524 -> 1 xdiv365 divide 50707.1412E+912475670 -198098.186E+701407524 -> -2.55969740E+211068145 Inexact Rounded xdvi365 divideint 50707.1412E+912475670 -198098.186E+701407524 -> NaN Division_impossible xmul365 multiply 50707.1412E+912475670 -198098.186E+701407524 -> -Infinity Inexact Overflow Rounded xpow365 power 50707.1412E+912475670 -2 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem365 remainder 50707.1412E+912475670 -198098.186E+701407524 -> NaN Division_impossible xsub365 subtract 50707.1412E+912475670 -198098.186E+701407524 -> 5.07071412E+912475674 Inexact Rounded xadd366 add 55.8245006E+928885991 99170843.9E-47402167 -> 5.58245006E+928885992 Inexact Rounded xcom366 compare 55.8245006E+928885991 99170843.9E-47402167 -> 1 xdiv366 divide 55.8245006E+928885991 99170843.9E-47402167 -> 5.62912429E+976288151 Inexact Rounded xdvi366 divideint 55.8245006E+928885991 99170843.9E-47402167 -> NaN Division_impossible xmul366 multiply 55.8245006E+928885991 99170843.9E-47402167 -> 5.53616283E+881483833 Inexact Rounded xpow366 power 55.8245006E+928885991 10 -> Infinity Overflow Inexact Rounded xrem366 remainder 55.8245006E+928885991 99170843.9E-47402167 -> NaN Division_impossible xsub366 subtract 55.8245006E+928885991 99170843.9E-47402167 -> 5.58245006E+928885992 Inexact Rounded xadd367 add 13.8003883E-386224921 -84126481.9E-296378341 -> -8.41264819E-296378334 Inexact Rounded xcom367 compare 13.8003883E-386224921 -84126481.9E-296378341 -> 1 xdiv367 divide 13.8003883E-386224921 -84126481.9E-296378341 -> -1.64043331E-89846587 Inexact Rounded xdvi367 divideint 13.8003883E-386224921 -84126481.9E-296378341 -> -0 xmul367 multiply 13.8003883E-386224921 -84126481.9E-296378341 -> -1.16097812E-682603253 Inexact Rounded xpow367 power 13.8003883E-386224921 -8 -> Infinity Overflow Inexact Rounded xrem367 remainder 13.8003883E-386224921 -84126481.9E-296378341 -> 1.38003883E-386224920 xsub367 subtract 13.8003883E-386224921 -84126481.9E-296378341 -> 8.41264819E-296378334 Inexact Rounded xadd368 add 9820.90457 46671.5915 -> 56492.4961 Inexact Rounded xcom368 compare 9820.90457 46671.5915 -> -1 xdiv368 divide 9820.90457 46671.5915 -> 0.210425748 Inexact Rounded xdvi368 divideint 9820.90457 46671.5915 -> 0 xmul368 multiply 9820.90457 46671.5915 -> 458357246 Inexact Rounded xpow368 power 9820.90457 46672 -> 4.94753070E+186321 Inexact Rounded xrem368 remainder 9820.90457 46671.5915 -> 9820.90457 xsub368 subtract 9820.90457 46671.5915 -> -36850.6869 Inexact Rounded xadd369 add 7.22436006E+831949153 -11168830E+322331045 -> 7.22436006E+831949153 Inexact Rounded xcom369 compare 7.22436006E+831949153 -11168830E+322331045 -> 1 xdiv369 divide 7.22436006E+831949153 -11168830E+322331045 -> -6.46832306E+509618101 Inexact Rounded xdvi369 divideint 7.22436006E+831949153 -11168830E+322331045 -> NaN Division_impossible xmul369 multiply 7.22436006E+831949153 -11168830E+322331045 -> -Infinity Inexact Overflow Rounded xpow369 power 7.22436006E+831949153 -1 -> 1.38420565E-831949154 Inexact Rounded xrem369 remainder 7.22436006E+831949153 -11168830E+322331045 -> NaN Division_impossible xsub369 subtract 7.22436006E+831949153 -11168830E+322331045 -> 7.22436006E+831949153 Inexact Rounded xadd370 add 472648900 -207.784153 -> 472648692 Inexact Rounded xcom370 compare 472648900 -207.784153 -> 1 xdiv370 divide 472648900 -207.784153 -> -2274711.01 Inexact Rounded xdvi370 divideint 472648900 -207.784153 -> -2274711 xmul370 multiply 472648900 -207.784153 -> -9.82089514E+10 Inexact Rounded xpow370 power 472648900 -208 -> 4.96547145E-1805 Inexact Rounded xrem370 remainder 472648900 -207.784153 -> 1.545217 xsub370 subtract 472648900 -207.784153 -> 472649108 Inexact Rounded xadd371 add -8754.49306 -818.165153E+631475457 -> -8.18165153E+631475459 Inexact Rounded xcom371 compare -8754.49306 -818.165153E+631475457 -> 1 xdiv371 divide -8754.49306 -818.165153E+631475457 -> 1.07001539E-631475456 Inexact Rounded xdvi371 divideint -8754.49306 -818.165153E+631475457 -> 0 xmul371 multiply -8754.49306 -818.165153E+631475457 -> 7.16262115E+631475463 Inexact Rounded xpow371 power -8754.49306 -8 -> 2.89835767E-32 Inexact Rounded xrem371 remainder -8754.49306 -818.165153E+631475457 -> -8754.49306 xsub371 subtract -8754.49306 -818.165153E+631475457 -> 8.18165153E+631475459 Inexact Rounded xadd372 add 98750864 191380.551 -> 98942244.6 Inexact Rounded xcom372 compare 98750864 191380.551 -> 1 xdiv372 divide 98750864 191380.551 -> 515.992161 Inexact Rounded xdvi372 divideint 98750864 191380.551 -> 515 xmul372 multiply 98750864 191380.551 -> 1.88989948E+13 Inexact Rounded xpow372 power 98750864 191381 -> 1.70908809E+1530003 Inexact Rounded xrem372 remainder 98750864 191380.551 -> 189880.235 xsub372 subtract 98750864 191380.551 -> 98559483.4 Inexact Rounded xadd373 add 725292561. -768963606.E+340762986 -> -7.68963606E+340762994 Inexact Rounded xcom373 compare 725292561. -768963606.E+340762986 -> 1 xdiv373 divide 725292561. -768963606.E+340762986 -> -9.43207917E-340762987 Inexact Rounded xdvi373 divideint 725292561. -768963606.E+340762986 -> -0 xmul373 multiply 725292561. -768963606.E+340762986 -> -5.57723583E+340763003 Inexact Rounded xpow373 power 725292561. -8 -> 1.30585277E-71 Inexact Rounded xrem373 remainder 725292561. -768963606.E+340762986 -> 725292561 xsub373 subtract 725292561. -768963606.E+340762986 -> 7.68963606E+340762994 Inexact Rounded xadd374 add 1862.80445 648254483. -> 648256346 Inexact Rounded xcom374 compare 1862.80445 648254483. -> -1 xdiv374 divide 1862.80445 648254483. -> 0.00000287356972 Inexact Rounded xdvi374 divideint 1862.80445 648254483. -> 0 xmul374 multiply 1862.80445 648254483. -> 1.20757134E+12 Inexact Rounded xpow374 power 1862.80445 648254483 -> Infinity Overflow Inexact Rounded xrem374 remainder 1862.80445 648254483. -> 1862.80445 xsub374 subtract 1862.80445 648254483. -> -648252620 Inexact Rounded xadd375 add -5549320.1 -93580684.1 -> -99130004.2 xcom375 compare -5549320.1 -93580684.1 -> 1 xdiv375 divide -5549320.1 -93580684.1 -> 0.0592998454 Inexact Rounded xdvi375 divideint -5549320.1 -93580684.1 -> 0 xmul375 multiply -5549320.1 -93580684.1 -> 5.19309171E+14 Inexact Rounded xpow375 power -5549320.1 -93580684 -> 4.20662079E-631130572 Inexact Rounded xrem375 remainder -5549320.1 -93580684.1 -> -5549320.1 xsub375 subtract -5549320.1 -93580684.1 -> 88031364.0 xadd376 add -14677053.1 -25784.7358 -> -14702837.8 Inexact Rounded xcom376 compare -14677053.1 -25784.7358 -> -1 xdiv376 divide -14677053.1 -25784.7358 -> 569.214795 Inexact Rounded xdvi376 divideint -14677053.1 -25784.7358 -> 569 xmul376 multiply -14677053.1 -25784.7358 -> 3.78443937E+11 Inexact Rounded xpow376 power -14677053.1 -25785 -> -1.64760831E-184792 Inexact Rounded xrem376 remainder -14677053.1 -25784.7358 -> -5538.4298 xsub376 subtract -14677053.1 -25784.7358 -> -14651268.4 Inexact Rounded xadd377 add 547402.308E+571687617 -7835797.01E+500067364 -> 5.47402308E+571687622 Inexact Rounded xcom377 compare 547402.308E+571687617 -7835797.01E+500067364 -> 1 xdiv377 divide 547402.308E+571687617 -7835797.01E+500067364 -> -6.98591742E+71620251 Inexact Rounded xdvi377 divideint 547402.308E+571687617 -7835797.01E+500067364 -> NaN Division_impossible xmul377 multiply 547402.308E+571687617 -7835797.01E+500067364 -> -Infinity Inexact Overflow Rounded xpow377 power 547402.308E+571687617 -8 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem377 remainder 547402.308E+571687617 -7835797.01E+500067364 -> NaN Division_impossible xsub377 subtract 547402.308E+571687617 -7835797.01E+500067364 -> 5.47402308E+571687622 Inexact Rounded xadd378 add -4131738.09 7579.07566 -> -4124159.01 Inexact Rounded xcom378 compare -4131738.09 7579.07566 -> -1 xdiv378 divide -4131738.09 7579.07566 -> -545.150659 Inexact Rounded xdvi378 divideint -4131738.09 7579.07566 -> -545 xmul378 multiply -4131738.09 7579.07566 -> -3.13147556E+10 Inexact Rounded xpow378 power -4131738.09 7579 -> -4.68132794E+50143 Inexact Rounded xrem378 remainder -4131738.09 7579.07566 -> -1141.85530 xsub378 subtract -4131738.09 7579.07566 -> -4139317.17 Inexact Rounded xadd379 add 504544.648 -7678.96133E-662143268 -> 504544.648 Inexact Rounded xcom379 compare 504544.648 -7678.96133E-662143268 -> 1 xdiv379 divide 504544.648 -7678.96133E-662143268 -> -6.57048039E+662143269 Inexact Rounded xdvi379 divideint 504544.648 -7678.96133E-662143268 -> NaN Division_impossible xmul379 multiply 504544.648 -7678.96133E-662143268 -> -3.87437884E-662143259 Inexact Rounded xpow379 power 504544.648 -8 -> 2.38124001E-46 Inexact Rounded xrem379 remainder 504544.648 -7678.96133E-662143268 -> NaN Division_impossible xsub379 subtract 504544.648 -7678.96133E-662143268 -> 504544.648 Inexact Rounded xadd380 add 829898241 8912.99114E+929228149 -> 8.91299114E+929228152 Inexact Rounded xcom380 compare 829898241 8912.99114E+929228149 -> -1 xdiv380 divide 829898241 8912.99114E+929228149 -> 9.31110811E-929228145 Inexact Rounded xdvi380 divideint 829898241 8912.99114E+929228149 -> 0 xmul380 multiply 829898241 8912.99114E+929228149 -> 7.39687567E+929228161 Inexact Rounded xpow380 power 829898241 9 -> 1.86734084E+80 Inexact Rounded xrem380 remainder 829898241 8912.99114E+929228149 -> 829898241 xsub380 subtract 829898241 8912.99114E+929228149 -> -8.91299114E+929228152 Inexact Rounded xadd381 add 53.6891691 -11.2371140 -> 42.4520551 xcom381 compare 53.6891691 -11.2371140 -> 1 xdiv381 divide 53.6891691 -11.2371140 -> -4.77784323 Inexact Rounded xdvi381 divideint 53.6891691 -11.2371140 -> -4 xmul381 multiply 53.6891691 -11.2371140 -> -603.311314 Inexact Rounded xpow381 power 53.6891691 -11 -> 9.35936725E-20 Inexact Rounded xrem381 remainder 53.6891691 -11.2371140 -> 8.7407131 xsub381 subtract 53.6891691 -11.2371140 -> 64.9262831 xadd382 add -93951823.4 -25317.8645 -> -93977141.3 Inexact Rounded xcom382 compare -93951823.4 -25317.8645 -> -1 xdiv382 divide -93951823.4 -25317.8645 -> 3710.89052 Inexact Rounded xdvi382 divideint -93951823.4 -25317.8645 -> 3710 xmul382 multiply -93951823.4 -25317.8645 -> 2.37865953E+12 Inexact Rounded xpow382 power -93951823.4 -25318 -> 9.67857714E-201859 Inexact Rounded xrem382 remainder -93951823.4 -25317.8645 -> -22546.1050 xsub382 subtract -93951823.4 -25317.8645 -> -93926505.5 Inexact Rounded xadd383 add 446919.123 951338490. -> 951785409 Inexact Rounded xcom383 compare 446919.123 951338490. -> -1 xdiv383 divide 446919.123 951338490. -> 0.000469779293 Inexact Rounded xdvi383 divideint 446919.123 951338490. -> 0 xmul383 multiply 446919.123 951338490. -> 4.25171364E+14 Inexact Rounded xpow383 power 446919.123 951338490 -> Infinity Overflow Inexact Rounded xrem383 remainder 446919.123 951338490. -> 446919.123 xsub383 subtract 446919.123 951338490. -> -950891571 Inexact Rounded xadd384 add -8.01787748 -88.3076852 -> -96.3255627 Inexact Rounded xcom384 compare -8.01787748 -88.3076852 -> 1 xdiv384 divide -8.01787748 -88.3076852 -> 0.0907947871 Inexact Rounded xdvi384 divideint -8.01787748 -88.3076852 -> 0 xmul384 multiply -8.01787748 -88.3076852 -> 708.040200 Inexact Rounded xpow384 power -8.01787748 -88 -> 2.77186088E-80 Inexact Rounded xrem384 remainder -8.01787748 -88.3076852 -> -8.01787748 xsub384 subtract -8.01787748 -88.3076852 -> 80.2898077 Inexact Rounded xadd385 add 517458139 -999731.548 -> 516458407 Inexact Rounded xcom385 compare 517458139 -999731.548 -> 1 xdiv385 divide 517458139 -999731.548 -> -517.597089 Inexact Rounded xdvi385 divideint 517458139 -999731.548 -> -517 xmul385 multiply 517458139 -999731.548 -> -5.17319226E+14 Inexact Rounded xpow385 power 517458139 -999732 -> 1.24821346E-8711540 Inexact Rounded xrem385 remainder 517458139 -999731.548 -> 596928.684 xsub385 subtract 517458139 -999731.548 -> 518457871 Inexact Rounded xadd386 add -405543440 -4013.18295 -> -405547453 Inexact Rounded xcom386 compare -405543440 -4013.18295 -> -1 xdiv386 divide -405543440 -4013.18295 -> 101052.816 Inexact Rounded xdvi386 divideint -405543440 -4013.18295 -> 101052 xmul386 multiply -405543440 -4013.18295 -> 1.62752002E+12 Inexact Rounded xpow386 power -405543440 -4013 -> -8.83061932E-34545 Inexact Rounded xrem386 remainder -405543440 -4013.18295 -> -3276.53660 xsub386 subtract -405543440 -4013.18295 -> -405539427 Inexact Rounded xadd387 add -49245250.1E+682760825 -848776.637 -> -4.92452501E+682760832 Inexact Rounded xcom387 compare -49245250.1E+682760825 -848776.637 -> -1 xdiv387 divide -49245250.1E+682760825 -848776.637 -> 5.80190924E+682760826 Inexact Rounded xdvi387 divideint -49245250.1E+682760825 -848776.637 -> NaN Division_impossible xmul387 multiply -49245250.1E+682760825 -848776.637 -> 4.17982178E+682760838 Inexact Rounded xpow387 power -49245250.1E+682760825 -848777 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem387 remainder -49245250.1E+682760825 -848776.637 -> NaN Division_impossible xsub387 subtract -49245250.1E+682760825 -848776.637 -> -4.92452501E+682760832 Inexact Rounded xadd388 add -151144455 -170371.29 -> -151314826 Inexact Rounded xcom388 compare -151144455 -170371.29 -> -1 xdiv388 divide -151144455 -170371.29 -> 887.147447 Inexact Rounded xdvi388 divideint -151144455 -170371.29 -> 887 xmul388 multiply -151144455 -170371.29 -> 2.57506758E+13 Inexact Rounded xpow388 power -151144455 -170371 -> -5.86496369E-1393532 Inexact Rounded xrem388 remainder -151144455 -170371.29 -> -25120.77 xsub388 subtract -151144455 -170371.29 -> -150974084 Inexact Rounded xadd389 add -729236746.E+662737067 9.10823602 -> -7.29236746E+662737075 Inexact Rounded xcom389 compare -729236746.E+662737067 9.10823602 -> -1 xdiv389 divide -729236746.E+662737067 9.10823602 -> -8.00634442E+662737074 Inexact Rounded xdvi389 divideint -729236746.E+662737067 9.10823602 -> NaN Division_impossible xmul389 multiply -729236746.E+662737067 9.10823602 -> -6.64206040E+662737076 Inexact Rounded xpow389 power -729236746.E+662737067 9 -> -Infinity Overflow Inexact Rounded xrem389 remainder -729236746.E+662737067 9.10823602 -> NaN Division_impossible xsub389 subtract -729236746.E+662737067 9.10823602 -> -7.29236746E+662737075 Inexact Rounded xadd390 add 534.394729 -2369839.37 -> -2369304.98 Inexact Rounded xcom390 compare 534.394729 -2369839.37 -> 1 xdiv390 divide 534.394729 -2369839.37 -> -0.000225498291 Inexact Rounded xdvi390 divideint 534.394729 -2369839.37 -> -0 xmul390 multiply 534.394729 -2369839.37 -> -1.26642967E+9 Inexact Rounded xpow390 power 534.394729 -2369839 -> 7.12522896E-6464595 Inexact Rounded xrem390 remainder 534.394729 -2369839.37 -> 534.394729 xsub390 subtract 534.394729 -2369839.37 -> 2370373.76 Inexact Rounded xadd391 add 89100.1797 224.370309 -> 89324.5500 Inexact Rounded xcom391 compare 89100.1797 224.370309 -> 1 xdiv391 divide 89100.1797 224.370309 -> 397.112167 Inexact Rounded xdvi391 divideint 89100.1797 224.370309 -> 397 xmul391 multiply 89100.1797 224.370309 -> 19991434.9 Inexact Rounded xpow391 power 89100.1797 224 -> 5.92654936E+1108 Inexact Rounded xrem391 remainder 89100.1797 224.370309 -> 25.167027 xsub391 subtract 89100.1797 224.370309 -> 88875.8094 Inexact Rounded xadd392 add -821377.777 38.552821 -> -821339.224 Inexact Rounded xcom392 compare -821377.777 38.552821 -> -1 xdiv392 divide -821377.777 38.552821 -> -21305.2575 Inexact Rounded xdvi392 divideint -821377.777 38.552821 -> -21305 xmul392 multiply -821377.777 38.552821 -> -31666430.4 Inexact Rounded xpow392 power -821377.777 39 -> -4.64702482E+230 Inexact Rounded xrem392 remainder -821377.777 38.552821 -> -9.925595 xsub392 subtract -821377.777 38.552821 -> -821416.330 Inexact Rounded xadd393 add -392640.782 -2571619.5E+113237865 -> -2.57161950E+113237871 Inexact Rounded xcom393 compare -392640.782 -2571619.5E+113237865 -> 1 xdiv393 divide -392640.782 -2571619.5E+113237865 -> 1.52682301E-113237866 Inexact Rounded xdvi393 divideint -392640.782 -2571619.5E+113237865 -> 0 xmul393 multiply -392640.782 -2571619.5E+113237865 -> 1.00972269E+113237877 Inexact Rounded xpow393 power -392640.782 -3 -> -1.65201422E-17 Inexact Rounded xrem393 remainder -392640.782 -2571619.5E+113237865 -> -392640.782 xsub393 subtract -392640.782 -2571619.5E+113237865 -> 2.57161950E+113237871 Inexact Rounded xadd394 add -651397.712 -723.59673 -> -652121.309 Inexact Rounded xcom394 compare -651397.712 -723.59673 -> -1 xdiv394 divide -651397.712 -723.59673 -> 900.222023 Inexact Rounded xdvi394 divideint -651397.712 -723.59673 -> 900 xmul394 multiply -651397.712 -723.59673 -> 471349254 Inexact Rounded xpow394 power -651397.712 -724 -> 5.96115415E-4210 Inexact Rounded xrem394 remainder -651397.712 -723.59673 -> -160.65500 xsub394 subtract -651397.712 -723.59673 -> -650674.115 Inexact Rounded xadd395 add 86.6890892 940380864 -> 940380951 Inexact Rounded xcom395 compare 86.6890892 940380864 -> -1 xdiv395 divide 86.6890892 940380864 -> 9.21850843E-8 Inexact Rounded xdvi395 divideint 86.6890892 940380864 -> 0 xmul395 multiply 86.6890892 940380864 -> 8.15207606E+10 Inexact Rounded xpow395 power 86.6890892 940380864 -> Infinity Overflow Inexact Rounded xrem395 remainder 86.6890892 940380864 -> 86.6890892 xsub395 subtract 86.6890892 940380864 -> -940380777 Inexact Rounded xadd396 add 4880.06442E-382222621 -115627239E-912834031 -> 4.88006442E-382222618 Inexact Rounded xcom396 compare 4880.06442E-382222621 -115627239E-912834031 -> 1 xdiv396 divide 4880.06442E-382222621 -115627239E-912834031 -> -4.22051453E+530611405 Inexact Rounded xdvi396 divideint 4880.06442E-382222621 -115627239E-912834031 -> NaN Division_impossible xmul396 multiply 4880.06442E-382222621 -115627239E-912834031 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow396 power 4880.06442E-382222621 -1 -> 2.04915328E+382222617 Inexact Rounded xrem396 remainder 4880.06442E-382222621 -115627239E-912834031 -> NaN Division_impossible xsub396 subtract 4880.06442E-382222621 -115627239E-912834031 -> 4.88006442E-382222618 Inexact Rounded xadd397 add 173398265E-532383158 3462.51450E+80986915 -> 3.46251450E+80986918 Inexact Rounded xcom397 compare 173398265E-532383158 3462.51450E+80986915 -> -1 xdiv397 divide 173398265E-532383158 3462.51450E+80986915 -> 5.00787116E-613370069 Inexact Rounded xdvi397 divideint 173398265E-532383158 3462.51450E+80986915 -> 0 xmul397 multiply 173398265E-532383158 3462.51450E+80986915 -> 6.00394007E-451396232 Inexact Rounded xpow397 power 173398265E-532383158 3 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem397 remainder 173398265E-532383158 3462.51450E+80986915 -> 1.73398265E-532383150 xsub397 subtract 173398265E-532383158 3462.51450E+80986915 -> -3.46251450E+80986918 Inexact Rounded xadd398 add -1522176.78 -6631061.77 -> -8153238.55 xcom398 compare -1522176.78 -6631061.77 -> 1 xdiv398 divide -1522176.78 -6631061.77 -> 0.229552496 Inexact Rounded xdvi398 divideint -1522176.78 -6631061.77 -> 0 xmul398 multiply -1522176.78 -6631061.77 -> 1.00936483E+13 Inexact Rounded xpow398 power -1522176.78 -6631062 -> 4.54268854E-40996310 Inexact Rounded xrem398 remainder -1522176.78 -6631061.77 -> -1522176.78 xsub398 subtract -1522176.78 -6631061.77 -> 5108884.99 xadd399 add 538.10453 522934310 -> 522934848 Inexact Rounded xcom399 compare 538.10453 522934310 -> -1 xdiv399 divide 538.10453 522934310 -> 0.00000102900980 Inexact Rounded xdvi399 divideint 538.10453 522934310 -> 0 xmul399 multiply 538.10453 522934310 -> 2.81393321E+11 Inexact Rounded xpow399 power 538.10453 522934310 -> Infinity Overflow Inexact Rounded xrem399 remainder 538.10453 522934310 -> 538.10453 xsub399 subtract 538.10453 522934310 -> -522933772 Inexact Rounded xadd400 add 880243.444E-750940977 -354.601578E-204943740 -> -3.54601578E-204943738 Inexact Rounded xcom400 compare 880243.444E-750940977 -354.601578E-204943740 -> 1 xdiv400 divide 880243.444E-750940977 -354.601578E-204943740 -> -2.48234497E-545997234 Inexact Rounded xdvi400 divideint 880243.444E-750940977 -354.601578E-204943740 -> -0 xmul400 multiply 880243.444E-750940977 -354.601578E-204943740 -> -3.12135714E-955884709 Inexact Rounded xpow400 power 880243.444E-750940977 -4 -> Infinity Overflow Inexact Rounded xrem400 remainder 880243.444E-750940977 -354.601578E-204943740 -> 8.80243444E-750940972 xsub400 subtract 880243.444E-750940977 -354.601578E-204943740 -> 3.54601578E-204943738 Inexact Rounded xadd401 add 968370.780 6677268.73 -> 7645639.51 Rounded xcom401 compare 968370.780 6677268.73 -> -1 xdiv401 divide 968370.780 6677268.73 -> 0.145024982 Inexact Rounded xdvi401 divideint 968370.780 6677268.73 -> 0 xmul401 multiply 968370.780 6677268.73 -> 6.46607193E+12 Inexact Rounded xpow401 power 968370.780 6677269 -> 3.29990931E+39970410 Inexact Rounded xrem401 remainder 968370.780 6677268.73 -> 968370.780 xsub401 subtract 968370.780 6677268.73 -> -5708897.95 Rounded xadd402 add -97.7474945 31248241.5 -> 31248143.8 Inexact Rounded xcom402 compare -97.7474945 31248241.5 -> -1 xdiv402 divide -97.7474945 31248241.5 -> -0.00000312809585 Inexact Rounded xdvi402 divideint -97.7474945 31248241.5 -> -0 xmul402 multiply -97.7474945 31248241.5 -> -3.05443731E+9 Inexact Rounded xpow402 power -97.7474945 31248242 -> 2.90714257E+62187302 Inexact Rounded xrem402 remainder -97.7474945 31248241.5 -> -97.7474945 xsub402 subtract -97.7474945 31248241.5 -> -31248339.2 Inexact Rounded xadd403 add -187582786.E+369916952 957840435E+744365567 -> 9.57840435E+744365575 Inexact Rounded xcom403 compare -187582786.E+369916952 957840435E+744365567 -> -1 xdiv403 divide -187582786.E+369916952 957840435E+744365567 -> -1.95839285E-374448616 Inexact Rounded xdvi403 divideint -187582786.E+369916952 957840435E+744365567 -> -0 xmul403 multiply -187582786.E+369916952 957840435E+744365567 -> -Infinity Inexact Overflow Rounded xpow403 power -187582786.E+369916952 10 -> Infinity Overflow Inexact Rounded xrem403 remainder -187582786.E+369916952 957840435E+744365567 -> -1.87582786E+369916960 xsub403 subtract -187582786.E+369916952 957840435E+744365567 -> -9.57840435E+744365575 Inexact Rounded xadd404 add -328026144. -125499735. -> -453525879 xcom404 compare -328026144. -125499735. -> -1 xdiv404 divide -328026144. -125499735. -> 2.61375965 Inexact Rounded xdvi404 divideint -328026144. -125499735. -> 2 xmul404 multiply -328026144. -125499735. -> 4.11671941E+16 Inexact Rounded xpow404 power -328026144. -125499735 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem404 remainder -328026144. -125499735. -> -77026674 xsub404 subtract -328026144. -125499735. -> -202526409 xadd405 add -99424150.2E-523662102 3712.35030 -> 3712.35030 Inexact Rounded xcom405 compare -99424150.2E-523662102 3712.35030 -> -1 xdiv405 divide -99424150.2E-523662102 3712.35030 -> -2.67819958E-523662098 Inexact Rounded xdvi405 divideint -99424150.2E-523662102 3712.35030 -> -0 xmul405 multiply -99424150.2E-523662102 3712.35030 -> -3.69097274E-523662091 Inexact Rounded xpow405 power -99424150.2E-523662102 3712 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem405 remainder -99424150.2E-523662102 3712.35030 -> -9.94241502E-523662095 xsub405 subtract -99424150.2E-523662102 3712.35030 -> -3712.35030 Inexact Rounded xadd406 add 14838.0718 9489893.28E+830631266 -> 9.48989328E+830631272 Inexact Rounded xcom406 compare 14838.0718 9489893.28E+830631266 -> -1 xdiv406 divide 14838.0718 9489893.28E+830631266 -> 1.56356572E-830631269 Inexact Rounded xdvi406 divideint 14838.0718 9489893.28E+830631266 -> 0 xmul406 multiply 14838.0718 9489893.28E+830631266 -> 1.40811718E+830631277 Inexact Rounded xpow406 power 14838.0718 9 -> 3.48656057E+37 Inexact Rounded xrem406 remainder 14838.0718 9489893.28E+830631266 -> 14838.0718 xsub406 subtract 14838.0718 9489893.28E+830631266 -> -9.48989328E+830631272 Inexact Rounded xadd407 add 71207472.8 -31835.0809 -> 71175637.7 Inexact Rounded xcom407 compare 71207472.8 -31835.0809 -> 1 xdiv407 divide 71207472.8 -31835.0809 -> -2236.76117 Inexact Rounded xdvi407 divideint 71207472.8 -31835.0809 -> -2236 xmul407 multiply 71207472.8 -31835.0809 -> -2.26689566E+12 Inexact Rounded xpow407 power 71207472.8 -31835 -> 7.05333953E-249986 Inexact Rounded xrem407 remainder 71207472.8 -31835.0809 -> 24231.9076 xsub407 subtract 71207472.8 -31835.0809 -> 71239307.9 Inexact Rounded xadd408 add -20440.4394 -44.4064328E+511085806 -> -4.44064328E+511085807 Inexact Rounded xcom408 compare -20440.4394 -44.4064328E+511085806 -> 1 xdiv408 divide -20440.4394 -44.4064328E+511085806 -> 4.60303567E-511085804 Inexact Rounded xdvi408 divideint -20440.4394 -44.4064328E+511085806 -> 0 xmul408 multiply -20440.4394 -44.4064328E+511085806 -> 9.07686999E+511085811 Inexact Rounded xpow408 power -20440.4394 -4 -> 5.72847590E-18 Inexact Rounded xrem408 remainder -20440.4394 -44.4064328E+511085806 -> -20440.4394 xsub408 subtract -20440.4394 -44.4064328E+511085806 -> 4.44064328E+511085807 Inexact Rounded xadd409 add -54.3684171E-807210192 1.04592973E-984041807 -> -5.43684171E-807210191 Inexact Rounded xcom409 compare -54.3684171E-807210192 1.04592973E-984041807 -> -1 xdiv409 divide -54.3684171E-807210192 1.04592973E-984041807 -> -5.19809463E+176831616 Inexact Rounded xdvi409 divideint -54.3684171E-807210192 1.04592973E-984041807 -> NaN Division_impossible xmul409 multiply -54.3684171E-807210192 1.04592973E-984041807 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow409 power -54.3684171E-807210192 1 -> -5.43684171E-807210191 xrem409 remainder -54.3684171E-807210192 1.04592973E-984041807 -> NaN Division_impossible xsub409 subtract -54.3684171E-807210192 1.04592973E-984041807 -> -5.43684171E-807210191 Inexact Rounded xadd410 add 54310060.5E+948159739 274320701.E+205880484 -> 5.43100605E+948159746 Inexact Rounded xcom410 compare 54310060.5E+948159739 274320701.E+205880484 -> 1 xdiv410 divide 54310060.5E+948159739 274320701.E+205880484 -> 1.97980175E+742279254 Inexact Rounded xdvi410 divideint 54310060.5E+948159739 274320701.E+205880484 -> NaN Division_impossible xmul410 multiply 54310060.5E+948159739 274320701.E+205880484 -> Infinity Inexact Overflow Rounded xpow410 power 54310060.5E+948159739 3 -> Infinity Overflow Inexact Rounded xrem410 remainder 54310060.5E+948159739 274320701.E+205880484 -> NaN Division_impossible xsub410 subtract 54310060.5E+948159739 274320701.E+205880484 -> 5.43100605E+948159746 Inexact Rounded xadd411 add -657.186702 426844.39 -> 426187.203 Inexact Rounded xcom411 compare -657.186702 426844.39 -> -1 xdiv411 divide -657.186702 426844.39 -> -0.00153964001 Inexact Rounded xdvi411 divideint -657.186702 426844.39 -> -0 xmul411 multiply -657.186702 426844.39 -> -280516457 Inexact Rounded xpow411 power -657.186702 426844 -> 3.50000575E+1202713 Inexact Rounded xrem411 remainder -657.186702 426844.39 -> -657.186702 xsub411 subtract -657.186702 426844.39 -> -427501.577 Inexact Rounded xadd412 add -41593077.0 -688607.564 -> -42281684.6 Inexact Rounded xcom412 compare -41593077.0 -688607.564 -> -1 xdiv412 divide -41593077.0 -688607.564 -> 60.4017138 Inexact Rounded xdvi412 divideint -41593077.0 -688607.564 -> 60 xmul412 multiply -41593077.0 -688607.564 -> 2.86413074E+13 Inexact Rounded xpow412 power -41593077.0 -688608 -> 1.42150750E-5246519 Inexact Rounded xrem412 remainder -41593077.0 -688607.564 -> -276623.160 xsub412 subtract -41593077.0 -688607.564 -> -40904469.4 Inexact Rounded xadd413 add -5786.38132 190556652.E+177045877 -> 1.90556652E+177045885 Inexact Rounded xcom413 compare -5786.38132 190556652.E+177045877 -> -1 xdiv413 divide -5786.38132 190556652.E+177045877 -> -3.03656748E-177045882 Inexact Rounded xdvi413 divideint -5786.38132 190556652.E+177045877 -> -0 xmul413 multiply -5786.38132 190556652.E+177045877 -> -1.10263345E+177045889 Inexact Rounded xpow413 power -5786.38132 2 -> 33482208.8 Inexact Rounded xrem413 remainder -5786.38132 190556652.E+177045877 -> -5786.38132 xsub413 subtract -5786.38132 190556652.E+177045877 -> -1.90556652E+177045885 Inexact Rounded xadd414 add 737622.974 -241560693E+249506565 -> -2.41560693E+249506573 Inexact Rounded xcom414 compare 737622.974 -241560693E+249506565 -> 1 xdiv414 divide 737622.974 -241560693E+249506565 -> -3.05357202E-249506568 Inexact Rounded xdvi414 divideint 737622.974 -241560693E+249506565 -> -0 xmul414 multiply 737622.974 -241560693E+249506565 -> -1.78180717E+249506579 Inexact Rounded xpow414 power 737622.974 -2 -> 1.83793916E-12 Inexact Rounded xrem414 remainder 737622.974 -241560693E+249506565 -> 737622.974 xsub414 subtract 737622.974 -241560693E+249506565 -> 2.41560693E+249506573 Inexact Rounded xadd415 add 5615373.52 -7.27583808E-949781048 -> 5615373.52 Inexact Rounded xcom415 compare 5615373.52 -7.27583808E-949781048 -> 1 xdiv415 divide 5615373.52 -7.27583808E-949781048 -> -7.71783739E+949781053 Inexact Rounded xdvi415 divideint 5615373.52 -7.27583808E-949781048 -> NaN Division_impossible xmul415 multiply 5615373.52 -7.27583808E-949781048 -> -4.08565485E-949781041 Inexact Rounded xpow415 power 5615373.52 -7 -> 5.68001460E-48 Inexact Rounded xrem415 remainder 5615373.52 -7.27583808E-949781048 -> NaN Division_impossible xsub415 subtract 5615373.52 -7.27583808E-949781048 -> 5615373.52 Inexact Rounded xadd416 add 644136.179 -835708.103 -> -191571.924 xcom416 compare 644136.179 -835708.103 -> 1 xdiv416 divide 644136.179 -835708.103 -> -0.770766942 Inexact Rounded xdvi416 divideint 644136.179 -835708.103 -> -0 xmul416 multiply 644136.179 -835708.103 -> -5.38309824E+11 Inexact Rounded xpow416 power 644136.179 -835708 -> 7.41936858E-4854610 Inexact Rounded xrem416 remainder 644136.179 -835708.103 -> 644136.179 xsub416 subtract 644136.179 -835708.103 -> 1479844.28 Inexact Rounded xadd417 add -307.419521E+466861843 -738689976.E-199032711 -> -3.07419521E+466861845 Inexact Rounded xcom417 compare -307.419521E+466861843 -738689976.E-199032711 -> -1 xdiv417 divide -307.419521E+466861843 -738689976.E-199032711 -> 4.16168529E+665894547 Inexact Rounded xdvi417 divideint -307.419521E+466861843 -738689976.E-199032711 -> NaN Division_impossible xmul417 multiply -307.419521E+466861843 -738689976.E-199032711 -> 2.27087719E+267829143 Inexact Rounded xpow417 power -307.419521E+466861843 -7 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem417 remainder -307.419521E+466861843 -738689976.E-199032711 -> NaN Division_impossible xsub417 subtract -307.419521E+466861843 -738689976.E-199032711 -> -3.07419521E+466861845 Inexact Rounded xadd418 add -619642.130 -226740537.E-902590153 -> -619642.130 Inexact Rounded xcom418 compare -619642.130 -226740537.E-902590153 -> -1 xdiv418 divide -619642.130 -226740537.E-902590153 -> 2.73282466E+902590150 Inexact Rounded xdvi418 divideint -619642.130 -226740537.E-902590153 -> NaN Division_impossible xmul418 multiply -619642.130 -226740537.E-902590153 -> 1.40497989E-902590139 Inexact Rounded xpow418 power -619642.130 -2 -> 2.60446259E-12 Inexact Rounded xrem418 remainder -619642.130 -226740537.E-902590153 -> NaN Division_impossible xsub418 subtract -619642.130 -226740537.E-902590153 -> -619642.130 Inexact Rounded xadd419 add -31068.7549 -3.41495042E+86001379 -> -3.41495042E+86001379 Inexact Rounded xcom419 compare -31068.7549 -3.41495042E+86001379 -> 1 xdiv419 divide -31068.7549 -3.41495042E+86001379 -> 9.09786412E-86001376 Inexact Rounded xdvi419 divideint -31068.7549 -3.41495042E+86001379 -> 0 xmul419 multiply -31068.7549 -3.41495042E+86001379 -> 1.06098258E+86001384 Inexact Rounded xpow419 power -31068.7549 -3 -> -3.33448258E-14 Inexact Rounded xrem419 remainder -31068.7549 -3.41495042E+86001379 -> -31068.7549 xsub419 subtract -31068.7549 -3.41495042E+86001379 -> 3.41495042E+86001379 Inexact Rounded xadd420 add -68951173. -211804977.E-97318126 -> -68951173.0 Inexact Rounded xcom420 compare -68951173. -211804977.E-97318126 -> -1 xdiv420 divide -68951173. -211804977.E-97318126 -> 3.25540854E+97318125 Inexact Rounded xdvi420 divideint -68951173. -211804977.E-97318126 -> NaN Division_impossible xmul420 multiply -68951173. -211804977.E-97318126 -> 1.46042016E-97318110 Inexact Rounded xpow420 power -68951173. -2 -> 2.10337488E-16 Inexact Rounded xrem420 remainder -68951173. -211804977.E-97318126 -> NaN Division_impossible xsub420 subtract -68951173. -211804977.E-97318126 -> -68951173.0 Inexact Rounded xadd421 add -4.09492571E-301749490 434.20199E-749390952 -> -4.09492571E-301749490 Inexact Rounded xcom421 compare -4.09492571E-301749490 434.20199E-749390952 -> -1 xdiv421 divide -4.09492571E-301749490 434.20199E-749390952 -> -9.43092341E+447641459 Inexact Rounded xdvi421 divideint -4.09492571E-301749490 434.20199E-749390952 -> NaN Division_impossible xmul421 multiply -4.09492571E-301749490 434.20199E-749390952 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow421 power -4.09492571E-301749490 4 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem421 remainder -4.09492571E-301749490 434.20199E-749390952 -> NaN Division_impossible xsub421 subtract -4.09492571E-301749490 434.20199E-749390952 -> -4.09492571E-301749490 Inexact Rounded xadd422 add 3898.03188 -82572.615 -> -78674.5831 Inexact Rounded xcom422 compare 3898.03188 -82572.615 -> 1 xdiv422 divide 3898.03188 -82572.615 -> -0.0472073202 Inexact Rounded xdvi422 divideint 3898.03188 -82572.615 -> -0 xmul422 multiply 3898.03188 -82572.615 -> -321870686 Inexact Rounded xpow422 power 3898.03188 -82573 -> 1.33010737E-296507 Inexact Rounded xrem422 remainder 3898.03188 -82572.615 -> 3898.03188 xsub422 subtract 3898.03188 -82572.615 -> 86470.6469 Inexact Rounded xadd423 add -1.7619356 -2546.64043 -> -2548.40237 Inexact Rounded xcom423 compare -1.7619356 -2546.64043 -> 1 xdiv423 divide -1.7619356 -2546.64043 -> 0.000691866657 Inexact Rounded xdvi423 divideint -1.7619356 -2546.64043 -> 0 xmul423 multiply -1.7619356 -2546.64043 -> 4487.01643 Inexact Rounded xpow423 power -1.7619356 -2547 -> -2.90664557E-627 Inexact Rounded xrem423 remainder -1.7619356 -2546.64043 -> -1.7619356 xsub423 subtract -1.7619356 -2546.64043 -> 2544.87849 Inexact Rounded xadd424 add 59714.1968 29734388.6E-564525525 -> 59714.1968 Inexact Rounded xcom424 compare 59714.1968 29734388.6E-564525525 -> 1 xdiv424 divide 59714.1968 29734388.6E-564525525 -> 2.00825373E+564525522 Inexact Rounded xdvi424 divideint 59714.1968 29734388.6E-564525525 -> NaN Division_impossible xmul424 multiply 59714.1968 29734388.6E-564525525 -> 1.77556513E-564525513 Inexact Rounded xpow424 power 59714.1968 3 -> 2.12928005E+14 Inexact Rounded xrem424 remainder 59714.1968 29734388.6E-564525525 -> NaN Division_impossible xsub424 subtract 59714.1968 29734388.6E-564525525 -> 59714.1968 Inexact Rounded xadd425 add 6.88891136E-935467395 -785049.562E-741671442 -> -7.85049562E-741671437 Inexact Rounded xcom425 compare 6.88891136E-935467395 -785049.562E-741671442 -> 1 xdiv425 divide 6.88891136E-935467395 -785049.562E-741671442 -> -8.77512923E-193795959 Inexact Rounded xdvi425 divideint 6.88891136E-935467395 -785049.562E-741671442 -> -0 xmul425 multiply 6.88891136E-935467395 -785049.562E-741671442 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow425 power 6.88891136E-935467395 -8 -> Infinity Overflow Inexact Rounded xrem425 remainder 6.88891136E-935467395 -785049.562E-741671442 -> 6.88891136E-935467395 xsub425 subtract 6.88891136E-935467395 -785049.562E-741671442 -> 7.85049562E-741671437 Inexact Rounded xadd426 add 975566251 -519.858530 -> 975565731 Inexact Rounded xcom426 compare 975566251 -519.858530 -> 1 xdiv426 divide 975566251 -519.858530 -> -1876599.49 Inexact Rounded xdvi426 divideint 975566251 -519.858530 -> -1876599 xmul426 multiply 975566251 -519.858530 -> -5.07156437E+11 Inexact Rounded xpow426 power 975566251 -520 -> 3.85905300E-4675 Inexact Rounded xrem426 remainder 975566251 -519.858530 -> 253.460530 xsub426 subtract 975566251 -519.858530 -> 975566771 Inexact Rounded xadd427 add 307401954 -231481582. -> 75920372 xcom427 compare 307401954 -231481582. -> 1 xdiv427 divide 307401954 -231481582. -> -1.32797586 Inexact Rounded xdvi427 divideint 307401954 -231481582. -> -1 xmul427 multiply 307401954 -231481582. -> -7.11578906E+16 Inexact Rounded xpow427 power 307401954 -231481582 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem427 remainder 307401954 -231481582. -> 75920372 xsub427 subtract 307401954 -231481582. -> 538883536 xadd428 add 2237645.48E+992947388 -60618055.3E-857316706 -> 2.23764548E+992947394 Inexact Rounded xcom428 compare 2237645.48E+992947388 -60618055.3E-857316706 -> 1 xdiv428 divide 2237645.48E+992947388 -60618055.3E-857316706 -> -Infinity Inexact Overflow Rounded xdvi428 divideint 2237645.48E+992947388 -60618055.3E-857316706 -> NaN Division_impossible xmul428 multiply 2237645.48E+992947388 -60618055.3E-857316706 -> -1.35641717E+135630696 Inexact Rounded xpow428 power 2237645.48E+992947388 -6 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem428 remainder 2237645.48E+992947388 -60618055.3E-857316706 -> NaN Division_impossible xsub428 subtract 2237645.48E+992947388 -60618055.3E-857316706 -> 2.23764548E+992947394 Inexact Rounded xadd429 add -403903.851 35.5049687E-72095155 -> -403903.851 Inexact Rounded xcom429 compare -403903.851 35.5049687E-72095155 -> -1 xdiv429 divide -403903.851 35.5049687E-72095155 -> -1.13759810E+72095159 Inexact Rounded xdvi429 divideint -403903.851 35.5049687E-72095155 -> NaN Division_impossible xmul429 multiply -403903.851 35.5049687E-72095155 -> -1.43405936E-72095148 Inexact Rounded xpow429 power -403903.851 4 -> 2.66141117E+22 Inexact Rounded xrem429 remainder -403903.851 35.5049687E-72095155 -> NaN Division_impossible xsub429 subtract -403903.851 35.5049687E-72095155 -> -403903.851 Inexact Rounded xadd430 add 6.48674979 -621732.532E+422575800 -> -6.21732532E+422575805 Inexact Rounded xcom430 compare 6.48674979 -621732.532E+422575800 -> 1 xdiv430 divide 6.48674979 -621732.532E+422575800 -> -1.04333447E-422575805 Inexact Rounded xdvi430 divideint 6.48674979 -621732.532E+422575800 -> -0 xmul430 multiply 6.48674979 -621732.532E+422575800 -> -4.03302337E+422575806 Inexact Rounded xpow430 power 6.48674979 -6 -> 0.0000134226146 Inexact Rounded xrem430 remainder 6.48674979 -621732.532E+422575800 -> 6.48674979 xsub430 subtract 6.48674979 -621732.532E+422575800 -> 6.21732532E+422575805 Inexact Rounded xadd431 add -31401.9418 36.3960679 -> -31365.5457 Inexact Rounded xcom431 compare -31401.9418 36.3960679 -> -1 xdiv431 divide -31401.9418 36.3960679 -> -862.783911 Inexact Rounded xdvi431 divideint -31401.9418 36.3960679 -> -862 xmul431 multiply -31401.9418 36.3960679 -> -1142907.21 Inexact Rounded xpow431 power -31401.9418 36 -> 7.77023505E+161 Inexact Rounded xrem431 remainder -31401.9418 36.3960679 -> -28.5312702 xsub431 subtract -31401.9418 36.3960679 -> -31438.3379 Inexact Rounded xadd432 add 31345321.1 51.5482191 -> 31345372.6 Inexact Rounded xcom432 compare 31345321.1 51.5482191 -> 1 xdiv432 divide 31345321.1 51.5482191 -> 608077.673 Inexact Rounded xdvi432 divideint 31345321.1 51.5482191 -> 608077 xmul432 multiply 31345321.1 51.5482191 -> 1.61579548E+9 Inexact Rounded xpow432 power 31345321.1 52 -> 6.32385059E+389 Inexact Rounded xrem432 remainder 31345321.1 51.5482191 -> 34.6743293 xsub432 subtract 31345321.1 51.5482191 -> 31345269.6 Inexact Rounded xadd433 add -64.172844 -28506227.2E-767965800 -> -64.1728440 Inexact Rounded xcom433 compare -64.172844 -28506227.2E-767965800 -> -1 xdiv433 divide -64.172844 -28506227.2E-767965800 -> 2.25118686E+767965794 Inexact Rounded xdvi433 divideint -64.172844 -28506227.2E-767965800 -> NaN Division_impossible xmul433 multiply -64.172844 -28506227.2E-767965800 -> 1.82932567E-767965791 Inexact Rounded xpow433 power -64.172844 -3 -> -0.00000378395654 Inexact Rounded xrem433 remainder -64.172844 -28506227.2E-767965800 -> NaN Division_impossible xsub433 subtract -64.172844 -28506227.2E-767965800 -> -64.1728440 Inexact Rounded xadd434 add 70437.1551 -62916.1233 -> 7521.0318 xcom434 compare 70437.1551 -62916.1233 -> 1 xdiv434 divide 70437.1551 -62916.1233 -> -1.11954061 Inexact Rounded xdvi434 divideint 70437.1551 -62916.1233 -> -1 xmul434 multiply 70437.1551 -62916.1233 -> -4.43163274E+9 Inexact Rounded xpow434 power 70437.1551 -62916 -> 5.02945060E-305005 Inexact Rounded xrem434 remainder 70437.1551 -62916.1233 -> 7521.0318 xsub434 subtract 70437.1551 -62916.1233 -> 133353.278 Inexact Rounded xadd435 add 916260164 -58.4017325 -> 916260106 Inexact Rounded xcom435 compare 916260164 -58.4017325 -> 1 xdiv435 divide 916260164 -58.4017325 -> -15688920.9 Inexact Rounded xdvi435 divideint 916260164 -58.4017325 -> -15688920 xmul435 multiply 916260164 -58.4017325 -> -5.35111810E+10 Inexact Rounded xpow435 power 916260164 -58 -> 1.59554587E-520 Inexact Rounded xrem435 remainder 916260164 -58.4017325 -> 54.9461000 xsub435 subtract 916260164 -58.4017325 -> 916260222 Inexact Rounded xadd436 add 19889085.3E-46816480 1581683.94 -> 1581683.94 Inexact Rounded xcom436 compare 19889085.3E-46816480 1581683.94 -> -1 xdiv436 divide 19889085.3E-46816480 1581683.94 -> 1.25746268E-46816479 Inexact Rounded xdvi436 divideint 19889085.3E-46816480 1581683.94 -> 0 xmul436 multiply 19889085.3E-46816480 1581683.94 -> 3.14582468E-46816467 Inexact Rounded xpow436 power 19889085.3E-46816480 1581684 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem436 remainder 19889085.3E-46816480 1581683.94 -> 1.98890853E-46816473 xsub436 subtract 19889085.3E-46816480 1581683.94 -> -1581683.94 Inexact Rounded xadd437 add -56312.3383 789.466064 -> -55522.8722 Inexact Rounded xcom437 compare -56312.3383 789.466064 -> -1 xdiv437 divide -56312.3383 789.466064 -> -71.3296503 Inexact Rounded xdvi437 divideint -56312.3383 789.466064 -> -71 xmul437 multiply -56312.3383 789.466064 -> -44456680.1 Inexact Rounded xpow437 power -56312.3383 789 -> -1.68348724E+3748 Inexact Rounded xrem437 remainder -56312.3383 789.466064 -> -260.247756 xsub437 subtract -56312.3383 789.466064 -> -57101.8044 Inexact Rounded xadd438 add 183442.849 -925876106 -> -925692663 Inexact Rounded xcom438 compare 183442.849 -925876106 -> 1 xdiv438 divide 183442.849 -925876106 -> -0.000198128937 Inexact Rounded xdvi438 divideint 183442.849 -925876106 -> -0 xmul438 multiply 183442.849 -925876106 -> -1.69845351E+14 Inexact Rounded xpow438 power 183442.849 -925876106 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem438 remainder 183442.849 -925876106 -> 183442.849 xsub438 subtract 183442.849 -925876106 -> 926059549 Inexact Rounded xadd439 add 971113.655E-695540249 -419351120E-977743823 -> 9.71113655E-695540244 Inexact Rounded xcom439 compare 971113.655E-695540249 -419351120E-977743823 -> 1 xdiv439 divide 971113.655E-695540249 -419351120E-977743823 -> -2.31575310E+282203571 Inexact Rounded xdvi439 divideint 971113.655E-695540249 -419351120E-977743823 -> NaN Division_impossible xmul439 multiply 971113.655E-695540249 -419351120E-977743823 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xpow439 power 971113.655E-695540249 -4 -> Infinity Overflow Inexact Rounded xrem439 remainder 971113.655E-695540249 -419351120E-977743823 -> NaN Division_impossible xsub439 subtract 971113.655E-695540249 -419351120E-977743823 -> 9.71113655E-695540244 Inexact Rounded xadd440 add 859658551. 72338.2054 -> 859730889 Inexact Rounded xcom440 compare 859658551. 72338.2054 -> 1 xdiv440 divide 859658551. 72338.2054 -> 11883.8800 Inexact Rounded xdvi440 divideint 859658551. 72338.2054 -> 11883 xmul440 multiply 859658551. 72338.2054 -> 6.21861568E+13 Inexact Rounded xpow440 power 859658551. 72338 -> 1.87620450E+646291 Inexact Rounded xrem440 remainder 859658551. 72338.2054 -> 63656.2318 xsub440 subtract 859658551. 72338.2054 -> 859586213 Inexact Rounded xadd441 add -3.86446630E+426816068 -664.534737 -> -3.86446630E+426816068 Inexact Rounded xcom441 compare -3.86446630E+426816068 -664.534737 -> -1 xdiv441 divide -3.86446630E+426816068 -664.534737 -> 5.81529615E+426816065 Inexact Rounded xdvi441 divideint -3.86446630E+426816068 -664.534737 -> NaN Division_impossible xmul441 multiply -3.86446630E+426816068 -664.534737 -> 2.56807210E+426816071 Inexact Rounded xpow441 power -3.86446630E+426816068 -665 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem441 remainder -3.86446630E+426816068 -664.534737 -> NaN Division_impossible xsub441 subtract -3.86446630E+426816068 -664.534737 -> -3.86446630E+426816068 Inexact Rounded xadd442 add -969.881818 31170.8555 -> 30200.9737 Inexact Rounded xcom442 compare -969.881818 31170.8555 -> -1 xdiv442 divide -969.881818 31170.8555 -> -0.0311150208 Inexact Rounded xdvi442 divideint -969.881818 31170.8555 -> -0 xmul442 multiply -969.881818 31170.8555 -> -30232046.0 Inexact Rounded xpow442 power -969.881818 31171 -> -1.02865894E+93099 Inexact Rounded xrem442 remainder -969.881818 31170.8555 -> -969.881818 xsub442 subtract -969.881818 31170.8555 -> -32140.7373 Inexact Rounded xadd443 add 7980537.27 85.4040512 -> 7980622.67 Inexact Rounded xcom443 compare 7980537.27 85.4040512 -> 1 xdiv443 divide 7980537.27 85.4040512 -> 93444.4814 Inexact Rounded xdvi443 divideint 7980537.27 85.4040512 -> 93444 xmul443 multiply 7980537.27 85.4040512 -> 681570214 Inexact Rounded xpow443 power 7980537.27 85 -> 4.70685763E+586 Inexact Rounded xrem443 remainder 7980537.27 85.4040512 -> 41.1096672 xsub443 subtract 7980537.27 85.4040512 -> 7980451.87 Inexact Rounded xadd444 add -114609916. 7525.14981 -> -114602391 Inexact Rounded xcom444 compare -114609916. 7525.14981 -> -1 xdiv444 divide -114609916. 7525.14981 -> -15230.2504 Inexact Rounded xdvi444 divideint -114609916. 7525.14981 -> -15230 xmul444 multiply -114609916. 7525.14981 -> -8.62456788E+11 Inexact Rounded xpow444 power -114609916. 7525 -> -4.43620445E+60645 Inexact Rounded xrem444 remainder -114609916. 7525.14981 -> -1884.39370 xsub444 subtract -114609916. 7525.14981 -> -114617441 Inexact Rounded xadd445 add 8.43404682E-500572568 474526719 -> 474526719 Inexact Rounded xcom445 compare 8.43404682E-500572568 474526719 -> -1 xdiv445 divide 8.43404682E-500572568 474526719 -> 1.77735973E-500572576 Inexact Rounded xdvi445 divideint 8.43404682E-500572568 474526719 -> 0 xmul445 multiply 8.43404682E-500572568 474526719 -> 4.00218057E-500572559 Inexact Rounded xpow445 power 8.43404682E-500572568 474526719 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem445 remainder 8.43404682E-500572568 474526719 -> 8.43404682E-500572568 xsub445 subtract 8.43404682E-500572568 474526719 -> -474526719 Inexact Rounded xadd446 add 188006433 2260.17037E-978192525 -> 188006433 Inexact Rounded xcom446 compare 188006433 2260.17037E-978192525 -> 1 xdiv446 divide 188006433 2260.17037E-978192525 -> 8.31824165E+978192529 Inexact Rounded xdvi446 divideint 188006433 2260.17037E-978192525 -> NaN Division_impossible xmul446 multiply 188006433 2260.17037E-978192525 -> 4.24926569E-978192514 Inexact Rounded xpow446 power 188006433 2 -> 3.53464188E+16 Inexact Rounded xrem446 remainder 188006433 2260.17037E-978192525 -> NaN Division_impossible xsub446 subtract 188006433 2260.17037E-978192525 -> 188006433 Inexact Rounded xadd447 add -9.95836312 -866466703 -> -866466713 Inexact Rounded xcom447 compare -9.95836312 -866466703 -> 1 xdiv447 divide -9.95836312 -866466703 -> 1.14930707E-8 Inexact Rounded xdvi447 divideint -9.95836312 -866466703 -> 0 xmul447 multiply -9.95836312 -866466703 -> 8.62859006E+9 Inexact Rounded xpow447 power -9.95836312 -866466703 -> -6.71744369E-864896630 Inexact Rounded xrem447 remainder -9.95836312 -866466703 -> -9.95836312 xsub447 subtract -9.95836312 -866466703 -> 866466693 Inexact Rounded xadd448 add 80919339.2E-967231586 219.824266 -> 219.824266 Inexact Rounded xcom448 compare 80919339.2E-967231586 219.824266 -> -1 xdiv448 divide 80919339.2E-967231586 219.824266 -> 3.68109220E-967231581 Inexact Rounded xdvi448 divideint 80919339.2E-967231586 219.824266 -> 0 xmul448 multiply 80919339.2E-967231586 219.824266 -> 1.77880343E-967231576 Inexact Rounded xpow448 power 80919339.2E-967231586 220 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem448 remainder 80919339.2E-967231586 219.824266 -> 8.09193392E-967231579 xsub448 subtract 80919339.2E-967231586 219.824266 -> -219.824266 Inexact Rounded xadd449 add 159579.444 -89827.5229 -> 69751.9211 xcom449 compare 159579.444 -89827.5229 -> 1 xdiv449 divide 159579.444 -89827.5229 -> -1.77650946 Inexact Rounded xdvi449 divideint 159579.444 -89827.5229 -> -1 xmul449 multiply 159579.444 -89827.5229 -> -1.43346262E+10 Inexact Rounded xpow449 power 159579.444 -89828 -> 9.69955850E-467374 Inexact Rounded xrem449 remainder 159579.444 -89827.5229 -> 69751.9211 xsub449 subtract 159579.444 -89827.5229 -> 249406.967 Inexact Rounded xadd450 add -4.54000153 6966333.74 -> 6966329.20 Inexact Rounded xcom450 compare -4.54000153 6966333.74 -> -1 xdiv450 divide -4.54000153 6966333.74 -> -6.51706005E-7 Inexact Rounded xdvi450 divideint -4.54000153 6966333.74 -> -0 xmul450 multiply -4.54000153 6966333.74 -> -31627165.8 Inexact Rounded xpow450 power -4.54000153 6966334 -> 3.52568913E+4577271 Inexact Rounded xrem450 remainder -4.54000153 6966333.74 -> -4.54000153 xsub450 subtract -4.54000153 6966333.74 -> -6966338.28 Inexact Rounded xadd451 add 28701538.7E-391015649 -920999192. -> -920999192 Inexact Rounded xcom451 compare 28701538.7E-391015649 -920999192. -> 1 xdiv451 divide 28701538.7E-391015649 -920999192. -> -3.11634787E-391015651 Inexact Rounded xdvi451 divideint 28701538.7E-391015649 -920999192. -> -0 xmul451 multiply 28701538.7E-391015649 -920999192. -> -2.64340940E-391015633 Inexact Rounded xpow451 power 28701538.7E-391015649 -920999192 -> Infinity Overflow Inexact Rounded xrem451 remainder 28701538.7E-391015649 -920999192. -> 2.87015387E-391015642 xsub451 subtract 28701538.7E-391015649 -920999192. -> 920999192 Inexact Rounded xadd452 add -361382575. -7976.15286E+898491169 -> -7.97615286E+898491172 Inexact Rounded xcom452 compare -361382575. -7976.15286E+898491169 -> 1 xdiv452 divide -361382575. -7976.15286E+898491169 -> 4.53078798E-898491165 Inexact Rounded xdvi452 divideint -361382575. -7976.15286E+898491169 -> 0 xmul452 multiply -361382575. -7976.15286E+898491169 -> 2.88244266E+898491181 Inexact Rounded xpow452 power -361382575. -8 -> 3.43765537E-69 Inexact Rounded xrem452 remainder -361382575. -7976.15286E+898491169 -> -361382575 xsub452 subtract -361382575. -7976.15286E+898491169 -> 7.97615286E+898491172 Inexact Rounded xadd453 add 7021805.61 1222952.83 -> 8244758.44 xcom453 compare 7021805.61 1222952.83 -> 1 xdiv453 divide 7021805.61 1222952.83 -> 5.74168148 Inexact Rounded xdvi453 divideint 7021805.61 1222952.83 -> 5 xmul453 multiply 7021805.61 1222952.83 -> 8.58733704E+12 Inexact Rounded xpow453 power 7021805.61 1222953 -> 1.26540553E+8372885 Inexact Rounded xrem453 remainder 7021805.61 1222952.83 -> 907041.46 xsub453 subtract 7021805.61 1222952.83 -> 5798852.78 xadd454 add -40.4811667 -79655.5635 -> -79696.0447 Inexact Rounded xcom454 compare -40.4811667 -79655.5635 -> 1 xdiv454 divide -40.4811667 -79655.5635 -> 0.000508202628 Inexact Rounded xdvi454 divideint -40.4811667 -79655.5635 -> 0 xmul454 multiply -40.4811667 -79655.5635 -> 3224550.14 Inexact Rounded xpow454 power -40.4811667 -79656 -> 4.50174275E-128028 Inexact Rounded xrem454 remainder -40.4811667 -79655.5635 -> -40.4811667 xsub454 subtract -40.4811667 -79655.5635 -> 79615.0823 Inexact Rounded xadd455 add -8755674.38E+117168177 148.903404 -> -8.75567438E+117168183 Inexact Rounded xcom455 compare -8755674.38E+117168177 148.903404 -> -1 xdiv455 divide -8755674.38E+117168177 148.903404 -> -5.88010357E+117168181 Inexact Rounded xdvi455 divideint -8755674.38E+117168177 148.903404 -> NaN Division_impossible xmul455 multiply -8755674.38E+117168177 148.903404 -> -1.30374972E+117168186 Inexact Rounded xpow455 power -8755674.38E+117168177 149 -> -Infinity Overflow Inexact Rounded xrem455 remainder -8755674.38E+117168177 148.903404 -> NaN Division_impossible xsub455 subtract -8755674.38E+117168177 148.903404 -> -8.75567438E+117168183 Inexact Rounded xadd456 add 34.5329781E+382829392 -45.2177309 -> 3.45329781E+382829393 Inexact Rounded xcom456 compare 34.5329781E+382829392 -45.2177309 -> 1 xdiv456 divide 34.5329781E+382829392 -45.2177309 -> -7.63704357E+382829391 Inexact Rounded xdvi456 divideint 34.5329781E+382829392 -45.2177309 -> NaN Division_impossible xmul456 multiply 34.5329781E+382829392 -45.2177309 -> -1.56150291E+382829395 Inexact Rounded xpow456 power 34.5329781E+382829392 -45 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem456 remainder 34.5329781E+382829392 -45.2177309 -> NaN Division_impossible xsub456 subtract 34.5329781E+382829392 -45.2177309 -> 3.45329781E+382829393 Inexact Rounded xadd457 add -37958476.0 584367.935 -> -37374108.1 Inexact Rounded xcom457 compare -37958476.0 584367.935 -> -1 xdiv457 divide -37958476.0 584367.935 -> -64.9564662 Inexact Rounded xdvi457 divideint -37958476.0 584367.935 -> -64 xmul457 multiply -37958476.0 584367.935 -> -2.21817162E+13 Inexact Rounded xpow457 power -37958476.0 584368 -> 3.20538268E+4429105 Inexact Rounded xrem457 remainder -37958476.0 584367.935 -> -558928.160 xsub457 subtract -37958476.0 584367.935 -> -38542843.9 Inexact Rounded xadd458 add 495233.553E-414152215 62352759.2 -> 62352759.2 Inexact Rounded xcom458 compare 495233.553E-414152215 62352759.2 -> -1 xdiv458 divide 495233.553E-414152215 62352759.2 -> 7.94244809E-414152218 Inexact Rounded xdvi458 divideint 495233.553E-414152215 62352759.2 -> 0 xmul458 multiply 495233.553E-414152215 62352759.2 -> 3.08791785E-414152202 Inexact Rounded xpow458 power 495233.553E-414152215 62352759 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem458 remainder 495233.553E-414152215 62352759.2 -> 4.95233553E-414152210 xsub458 subtract 495233.553E-414152215 62352759.2 -> -62352759.2 Inexact Rounded xadd459 add -502343060 -96828.994 -> -502439889 Inexact Rounded xcom459 compare -502343060 -96828.994 -> -1 xdiv459 divide -502343060 -96828.994 -> 5187.94050 Inexact Rounded xdvi459 divideint -502343060 -96828.994 -> 5187 xmul459 multiply -502343060 -96828.994 -> 4.86413731E+13 Inexact Rounded xpow459 power -502343060 -96829 -> -6.78602119E-842510 Inexact Rounded xrem459 remainder -502343060 -96828.994 -> -91068.122 xsub459 subtract -502343060 -96828.994 -> -502246231 Inexact Rounded xadd460 add -22.439639E+916362878 -39.4037681 -> -2.24396390E+916362879 Inexact Rounded xcom460 compare -22.439639E+916362878 -39.4037681 -> -1 xdiv460 divide -22.439639E+916362878 -39.4037681 -> 5.69479521E+916362877 Inexact Rounded xdvi460 divideint -22.439639E+916362878 -39.4037681 -> NaN Division_impossible xmul460 multiply -22.439639E+916362878 -39.4037681 -> 8.84206331E+916362880 Inexact Rounded xpow460 power -22.439639E+916362878 -39 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem460 remainder -22.439639E+916362878 -39.4037681 -> NaN Division_impossible xsub460 subtract -22.439639E+916362878 -39.4037681 -> -2.24396390E+916362879 Inexact Rounded xadd461 add 718180.587E-957473722 1.66223443 -> 1.66223443 Inexact Rounded xcom461 compare 718180.587E-957473722 1.66223443 -> -1 xdiv461 divide 718180.587E-957473722 1.66223443 -> 4.32057340E-957473717 Inexact Rounded xdvi461 divideint 718180.587E-957473722 1.66223443 -> 0 xmul461 multiply 718180.587E-957473722 1.66223443 -> 1.19378450E-957473716 Inexact Rounded xpow461 power 718180.587E-957473722 2 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem461 remainder 718180.587E-957473722 1.66223443 -> 7.18180587E-957473717 xsub461 subtract 718180.587E-957473722 1.66223443 -> -1.66223443 Inexact Rounded xadd462 add -51592.2698 -713885.741 -> -765478.011 Inexact Rounded xcom462 compare -51592.2698 -713885.741 -> 1 xdiv462 divide -51592.2698 -713885.741 -> 0.0722696460 Inexact Rounded xdvi462 divideint -51592.2698 -713885.741 -> 0 xmul462 multiply -51592.2698 -713885.741 -> 3.68309858E+10 Inexact Rounded xpow462 power -51592.2698 -713886 -> 6.38576920E-3364249 Inexact Rounded xrem462 remainder -51592.2698 -713885.741 -> -51592.2698 xsub462 subtract -51592.2698 -713885.741 -> 662293.471 Inexact Rounded xadd463 add 51.2279848E+80439745 207.55925E+865165070 -> 2.07559250E+865165072 Inexact Rounded xcom463 compare 51.2279848E+80439745 207.55925E+865165070 -> -1 xdiv463 divide 51.2279848E+80439745 207.55925E+865165070 -> 2.46811379E-784725326 Inexact Rounded xdvi463 divideint 51.2279848E+80439745 207.55925E+865165070 -> 0 xmul463 multiply 51.2279848E+80439745 207.55925E+865165070 -> 1.06328421E+945604819 Inexact Rounded xpow463 power 51.2279848E+80439745 2 -> 2.62430643E+160879493 Inexact Rounded xrem463 remainder 51.2279848E+80439745 207.55925E+865165070 -> 5.12279848E+80439746 xsub463 subtract 51.2279848E+80439745 207.55925E+865165070 -> -2.07559250E+865165072 Inexact Rounded xadd464 add -5983.23468 -39.9544513 -> -6023.18913 Inexact Rounded xcom464 compare -5983.23468 -39.9544513 -> -1 xdiv464 divide -5983.23468 -39.9544513 -> 149.751392 Inexact Rounded xdvi464 divideint -5983.23468 -39.9544513 -> 149 xmul464 multiply -5983.23468 -39.9544513 -> 239056.859 Inexact Rounded xpow464 power -5983.23468 -40 -> 8.36678291E-152 Inexact Rounded xrem464 remainder -5983.23468 -39.9544513 -> -30.0214363 xsub464 subtract -5983.23468 -39.9544513 -> -5943.28023 Inexact Rounded xadd465 add 921639332.E-917542963 287325.891 -> 287325.891 Inexact Rounded xcom465 compare 921639332.E-917542963 287325.891 -> -1 xdiv465 divide 921639332.E-917542963 287325.891 -> 3.20764456E-917542960 Inexact Rounded xdvi465 divideint 921639332.E-917542963 287325.891 -> 0 xmul465 multiply 921639332.E-917542963 287325.891 -> 2.64810842E-917542949 Inexact Rounded xpow465 power 921639332.E-917542963 287326 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem465 remainder 921639332.E-917542963 287325.891 -> 9.21639332E-917542955 xsub465 subtract 921639332.E-917542963 287325.891 -> -287325.891 Inexact Rounded xadd466 add 91095916.8E-787312969 -58643.418E+58189880 -> -5.86434180E+58189884 Inexact Rounded xcom466 compare 91095916.8E-787312969 -58643.418E+58189880 -> 1 xdiv466 divide 91095916.8E-787312969 -58643.418E+58189880 -> -1.55338689E-845502846 Inexact Rounded xdvi466 divideint 91095916.8E-787312969 -58643.418E+58189880 -> -0 xmul466 multiply 91095916.8E-787312969 -58643.418E+58189880 -> -5.34217593E-729123077 Inexact Rounded xpow466 power 91095916.8E-787312969 -6 -> Infinity Overflow Inexact Rounded xrem466 remainder 91095916.8E-787312969 -58643.418E+58189880 -> 9.10959168E-787312962 xsub466 subtract 91095916.8E-787312969 -58643.418E+58189880 -> 5.86434180E+58189884 Inexact Rounded xadd467 add -6410.5555 -234964259 -> -234970670 Inexact Rounded xcom467 compare -6410.5555 -234964259 -> 1 xdiv467 divide -6410.5555 -234964259 -> 0.0000272831090 Inexact Rounded xdvi467 divideint -6410.5555 -234964259 -> 0 xmul467 multiply -6410.5555 -234964259 -> 1.50625142E+12 Inexact Rounded xpow467 power -6410.5555 -234964259 -> -1.27064467E-894484419 Inexact Rounded xrem467 remainder -6410.5555 -234964259 -> -6410.5555 xsub467 subtract -6410.5555 -234964259 -> 234957848 Inexact Rounded xadd468 add -5.32711606 -8447286.21 -> -8447291.54 Inexact Rounded xcom468 compare -5.32711606 -8447286.21 -> 1 xdiv468 divide -5.32711606 -8447286.21 -> 6.30630468E-7 Inexact Rounded xdvi468 divideint -5.32711606 -8447286.21 -> 0 xmul468 multiply -5.32711606 -8447286.21 -> 44999674.0 Inexact Rounded xpow468 power -5.32711606 -8447286 -> 9.09138728E-6136888 Inexact Rounded xrem468 remainder -5.32711606 -8447286.21 -> -5.32711606 xsub468 subtract -5.32711606 -8447286.21 -> 8447280.88 Inexact Rounded xadd469 add -82272171.8 -776.238587E-372690416 -> -82272171.8 Inexact Rounded xcom469 compare -82272171.8 -776.238587E-372690416 -> -1 xdiv469 divide -82272171.8 -776.238587E-372690416 -> 1.05988253E+372690421 Inexact Rounded xdvi469 divideint -82272171.8 -776.238587E-372690416 -> NaN Division_impossible xmul469 multiply -82272171.8 -776.238587E-372690416 -> 6.38628344E-372690406 Inexact Rounded xpow469 power -82272171.8 -8 -> 4.76404994E-64 Inexact Rounded xrem469 remainder -82272171.8 -776.238587E-372690416 -> NaN Division_impossible xsub469 subtract -82272171.8 -776.238587E-372690416 -> -82272171.8 Inexact Rounded xadd470 add 412411244.E-774339264 866452.465 -> 866452.465 Inexact Rounded xcom470 compare 412411244.E-774339264 866452.465 -> -1 xdiv470 divide 412411244.E-774339264 866452.465 -> 4.75976768E-774339262 Inexact Rounded xdvi470 divideint 412411244.E-774339264 866452.465 -> 0 xmul470 multiply 412411244.E-774339264 866452.465 -> 3.57334739E-774339250 Inexact Rounded xpow470 power 412411244.E-774339264 866452 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem470 remainder 412411244.E-774339264 866452.465 -> 4.12411244E-774339256 xsub470 subtract 412411244.E-774339264 866452.465 -> -866452.465 Inexact Rounded xadd471 add -103.474598 -3.01660661E-446661257 -> -103.474598 Inexact Rounded xcom471 compare -103.474598 -3.01660661E-446661257 -> -1 xdiv471 divide -103.474598 -3.01660661E-446661257 -> 3.43016546E+446661258 Inexact Rounded xdvi471 divideint -103.474598 -3.01660661E-446661257 -> NaN Division_impossible xmul471 multiply -103.474598 -3.01660661E-446661257 -> 3.12142156E-446661255 Inexact Rounded xpow471 power -103.474598 -3 -> -9.02607123E-7 Inexact Rounded xrem471 remainder -103.474598 -3.01660661E-446661257 -> NaN Division_impossible xsub471 subtract -103.474598 -3.01660661E-446661257 -> -103.474598 Inexact Rounded xadd472 add -31027.8323 -475378186. -> -475409214 Inexact Rounded xcom472 compare -31027.8323 -475378186. -> 1 xdiv472 divide -31027.8323 -475378186. -> 0.0000652697856 Inexact Rounded xdvi472 divideint -31027.8323 -475378186. -> 0 xmul472 multiply -31027.8323 -475378186. -> 1.47499546E+13 Inexact Rounded xpow472 power -31027.8323 -475378186 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem472 remainder -31027.8323 -475378186. -> -31027.8323 xsub472 subtract -31027.8323 -475378186. -> 475347158 Inexact Rounded xadd473 add -1199339.72 -5.73068392E+53774632 -> -5.73068392E+53774632 Inexact Rounded xcom473 compare -1199339.72 -5.73068392E+53774632 -> 1 xdiv473 divide -1199339.72 -5.73068392E+53774632 -> 2.09283872E-53774627 Inexact Rounded xdvi473 divideint -1199339.72 -5.73068392E+53774632 -> 0 xmul473 multiply -1199339.72 -5.73068392E+53774632 -> 6.87303685E+53774638 Inexact Rounded xpow473 power -1199339.72 -6 -> 3.36005741E-37 Inexact Rounded xrem473 remainder -1199339.72 -5.73068392E+53774632 -> -1199339.72 xsub473 subtract -1199339.72 -5.73068392E+53774632 -> 5.73068392E+53774632 Inexact Rounded xadd474 add -732908.930E+364345433 -3486146.26 -> -7.32908930E+364345438 Inexact Rounded xcom474 compare -732908.930E+364345433 -3486146.26 -> -1 xdiv474 divide -732908.930E+364345433 -3486146.26 -> 2.10234705E+364345432 Inexact Rounded xdvi474 divideint -732908.930E+364345433 -3486146.26 -> NaN Division_impossible xmul474 multiply -732908.930E+364345433 -3486146.26 -> 2.55502773E+364345445 Inexact Rounded xpow474 power -732908.930E+364345433 -3486146 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem474 remainder -732908.930E+364345433 -3486146.26 -> NaN Division_impossible xsub474 subtract -732908.930E+364345433 -3486146.26 -> -7.32908930E+364345438 Inexact Rounded xadd475 add -2376150.83 -46777583.3 -> -49153734.1 Inexact Rounded xcom475 compare -2376150.83 -46777583.3 -> 1 xdiv475 divide -2376150.83 -46777583.3 -> 0.0507967847 Inexact Rounded xdvi475 divideint -2376150.83 -46777583.3 -> 0 xmul475 multiply -2376150.83 -46777583.3 -> 1.11150593E+14 Inexact Rounded xpow475 power -2376150.83 -46777583 -> -3.51886193E-298247976 Inexact Rounded xrem475 remainder -2376150.83 -46777583.3 -> -2376150.83 xsub475 subtract -2376150.83 -46777583.3 -> 44401432.5 Inexact Rounded xadd476 add 6.3664211 -140854908. -> -140854902 Inexact Rounded xcom476 compare 6.3664211 -140854908. -> 1 xdiv476 divide 6.3664211 -140854908. -> -4.51984328E-8 Inexact Rounded xdvi476 divideint 6.3664211 -140854908. -> -0 xmul476 multiply 6.3664211 -140854908. -> -896741658 Inexact Rounded xpow476 power 6.3664211 -140854908 -> 7.25432803E-113232608 Inexact Rounded xrem476 remainder 6.3664211 -140854908. -> 6.3664211 xsub476 subtract 6.3664211 -140854908. -> 140854914 Inexact Rounded xadd477 add -15.791522 1902.30210E+90741844 -> 1.90230210E+90741847 Inexact Rounded xcom477 compare -15.791522 1902.30210E+90741844 -> -1 xdiv477 divide -15.791522 1902.30210E+90741844 -> -8.30126929E-90741847 Inexact Rounded xdvi477 divideint -15.791522 1902.30210E+90741844 -> -0 xmul477 multiply -15.791522 1902.30210E+90741844 -> -3.00402455E+90741848 Inexact Rounded xpow477 power -15.791522 2 -> 249.372167 Inexact Rounded xrem477 remainder -15.791522 1902.30210E+90741844 -> -15.791522 xsub477 subtract -15.791522 1902.30210E+90741844 -> -1.90230210E+90741847 Inexact Rounded xadd478 add 15356.1505E+373950429 2.88020400 -> 1.53561505E+373950433 Inexact Rounded xcom478 compare 15356.1505E+373950429 2.88020400 -> 1 xdiv478 divide 15356.1505E+373950429 2.88020400 -> 5.33161905E+373950432 Inexact Rounded xdvi478 divideint 15356.1505E+373950429 2.88020400 -> NaN Division_impossible xmul478 multiply 15356.1505E+373950429 2.88020400 -> 4.42288461E+373950433 Inexact Rounded xpow478 power 15356.1505E+373950429 3 -> Infinity Overflow Inexact Rounded xrem478 remainder 15356.1505E+373950429 2.88020400 -> NaN Division_impossible xsub478 subtract 15356.1505E+373950429 2.88020400 -> 1.53561505E+373950433 Inexact Rounded xadd479 add -3.12001326E+318884762 9567.21595 -> -3.12001326E+318884762 Inexact Rounded xcom479 compare -3.12001326E+318884762 9567.21595 -> -1 xdiv479 divide -3.12001326E+318884762 9567.21595 -> -3.26115066E+318884758 Inexact Rounded xdvi479 divideint -3.12001326E+318884762 9567.21595 -> NaN Division_impossible xmul479 multiply -3.12001326E+318884762 9567.21595 -> -2.98498406E+318884766 Inexact Rounded xpow479 power -3.12001326E+318884762 9567 -> -Infinity Overflow Inexact Rounded xrem479 remainder -3.12001326E+318884762 9567.21595 -> NaN Division_impossible xsub479 subtract -3.12001326E+318884762 9567.21595 -> -3.12001326E+318884762 Inexact Rounded xadd480 add 49436.6528 751.919517 -> 50188.5723 Inexact Rounded xcom480 compare 49436.6528 751.919517 -> 1 xdiv480 divide 49436.6528 751.919517 -> 65.7472664 Inexact Rounded xdvi480 divideint 49436.6528 751.919517 -> 65 xmul480 multiply 49436.6528 751.919517 -> 37172384.1 Inexact Rounded xpow480 power 49436.6528 752 -> 8.41185718E+3529 Inexact Rounded xrem480 remainder 49436.6528 751.919517 -> 561.884195 xsub480 subtract 49436.6528 751.919517 -> 48684.7333 Inexact Rounded xadd481 add 552.669453 8.3725760E+16223526 -> 8.37257600E+16223526 Inexact Rounded xcom481 compare 552.669453 8.3725760E+16223526 -> -1 xdiv481 divide 552.669453 8.3725760E+16223526 -> 6.60094878E-16223525 Inexact Rounded xdvi481 divideint 552.669453 8.3725760E+16223526 -> 0 xmul481 multiply 552.669453 8.3725760E+16223526 -> 4.62726700E+16223529 Inexact Rounded xpow481 power 552.669453 8 -> 8.70409632E+21 Inexact Rounded xrem481 remainder 552.669453 8.3725760E+16223526 -> 552.669453 xsub481 subtract 552.669453 8.3725760E+16223526 -> -8.37257600E+16223526 Inexact Rounded xadd482 add -3266303 453741.520 -> -2812561.48 Rounded xcom482 compare -3266303 453741.520 -> -1 xdiv482 divide -3266303 453741.520 -> -7.19859844 Inexact Rounded xdvi482 divideint -3266303 453741.520 -> -7 xmul482 multiply -3266303 453741.520 -> -1.48205729E+12 Inexact Rounded xpow482 power -3266303 453742 -> 1.02497315E+2955701 Inexact Rounded xrem482 remainder -3266303 453741.520 -> -90112.360 xsub482 subtract -3266303 453741.520 -> -3720044.52 Rounded xadd483 add 12302757.4 542922.487E+414443353 -> 5.42922487E+414443358 Inexact Rounded xcom483 compare 12302757.4 542922.487E+414443353 -> -1 xdiv483 divide 12302757.4 542922.487E+414443353 -> 2.26602465E-414443352 Inexact Rounded xdvi483 divideint 12302757.4 542922.487E+414443353 -> 0 xmul483 multiply 12302757.4 542922.487E+414443353 -> 6.67944364E+414443365 Inexact Rounded xpow483 power 12302757.4 5 -> 2.81846276E+35 Inexact Rounded xrem483 remainder 12302757.4 542922.487E+414443353 -> 12302757.4 xsub483 subtract 12302757.4 542922.487E+414443353 -> -5.42922487E+414443358 Inexact Rounded xadd484 add -5670757.79E-784754984 128144.503 -> 128144.503 Inexact Rounded xcom484 compare -5670757.79E-784754984 128144.503 -> -1 xdiv484 divide -5670757.79E-784754984 128144.503 -> -4.42528369E-784754983 Inexact Rounded xdvi484 divideint -5670757.79E-784754984 128144.503 -> -0 xmul484 multiply -5670757.79E-784754984 128144.503 -> -7.26676439E-784754973 Inexact Rounded xpow484 power -5670757.79E-784754984 128145 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem484 remainder -5670757.79E-784754984 128144.503 -> -5.67075779E-784754978 xsub484 subtract -5670757.79E-784754984 128144.503 -> -128144.503 Inexact Rounded xadd485 add 22.7721968E+842530698 5223.70462 -> 2.27721968E+842530699 Inexact Rounded xcom485 compare 22.7721968E+842530698 5223.70462 -> 1 xdiv485 divide 22.7721968E+842530698 5223.70462 -> 4.35939596E+842530695 Inexact Rounded xdvi485 divideint 22.7721968E+842530698 5223.70462 -> NaN Division_impossible xmul485 multiply 22.7721968E+842530698 5223.70462 -> 1.18955230E+842530703 Inexact Rounded xpow485 power 22.7721968E+842530698 5224 -> Infinity Overflow Inexact Rounded xrem485 remainder 22.7721968E+842530698 5223.70462 -> NaN Division_impossible xsub485 subtract 22.7721968E+842530698 5223.70462 -> 2.27721968E+842530699 Inexact Rounded xadd486 add 88.5158199E-980164357 325846116 -> 325846116 Inexact Rounded xcom486 compare 88.5158199E-980164357 325846116 -> -1 xdiv486 divide 88.5158199E-980164357 325846116 -> 2.71649148E-980164364 Inexact Rounded xdvi486 divideint 88.5158199E-980164357 325846116 -> 0 xmul486 multiply 88.5158199E-980164357 325846116 -> 2.88425361E-980164347 Inexact Rounded xpow486 power 88.5158199E-980164357 325846116 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem486 remainder 88.5158199E-980164357 325846116 -> 8.85158199E-980164356 xsub486 subtract 88.5158199E-980164357 325846116 -> -325846116 Inexact Rounded xadd487 add -22881.0408 5.63661562 -> -22875.4042 Inexact Rounded xcom487 compare -22881.0408 5.63661562 -> -1 xdiv487 divide -22881.0408 5.63661562 -> -4059.35802 Inexact Rounded xdvi487 divideint -22881.0408 5.63661562 -> -4059 xmul487 multiply -22881.0408 5.63661562 -> -128971.632 Inexact Rounded xpow487 power -22881.0408 6 -> 1.43500909E+26 Inexact Rounded xrem487 remainder -22881.0408 5.63661562 -> -2.01799842 xsub487 subtract -22881.0408 5.63661562 -> -22886.6774 Inexact Rounded xadd488 add -7157.57449 -76.4455519E-85647047 -> -7157.57449 Inexact Rounded xcom488 compare -7157.57449 -76.4455519E-85647047 -> -1 xdiv488 divide -7157.57449 -76.4455519E-85647047 -> 9.36297052E+85647048 Inexact Rounded xdvi488 divideint -7157.57449 -76.4455519E-85647047 -> NaN Division_impossible xmul488 multiply -7157.57449 -76.4455519E-85647047 -> 5.47164732E-85647042 Inexact Rounded xpow488 power -7157.57449 -8 -> 1.45168700E-31 Inexact Rounded xrem488 remainder -7157.57449 -76.4455519E-85647047 -> NaN Division_impossible xsub488 subtract -7157.57449 -76.4455519E-85647047 -> -7157.57449 Inexact Rounded xadd489 add -503113.801 -9715149.82E-612184422 -> -503113.801 Inexact Rounded xcom489 compare -503113.801 -9715149.82E-612184422 -> -1 xdiv489 divide -503113.801 -9715149.82E-612184422 -> 5.17865201E+612184420 Inexact Rounded xdvi489 divideint -503113.801 -9715149.82E-612184422 -> NaN Division_impossible xmul489 multiply -503113.801 -9715149.82E-612184422 -> 4.88782595E-612184410 Inexact Rounded xpow489 power -503113.801 -10 -> 9.62360287E-58 Inexact Rounded xrem489 remainder -503113.801 -9715149.82E-612184422 -> NaN Division_impossible xsub489 subtract -503113.801 -9715149.82E-612184422 -> -503113.801 Inexact Rounded xadd490 add -3066962.41 -55.3096879 -> -3067017.72 Inexact Rounded xcom490 compare -3066962.41 -55.3096879 -> -1 xdiv490 divide -3066962.41 -55.3096879 -> 55450.7271 Inexact Rounded xdvi490 divideint -3066962.41 -55.3096879 -> 55450 xmul490 multiply -3066962.41 -55.3096879 -> 169632734 Inexact Rounded xpow490 power -3066962.41 -55 -> -1.70229600E-357 Inexact Rounded xrem490 remainder -3066962.41 -55.3096879 -> -40.2159450 xsub490 subtract -3066962.41 -55.3096879 -> -3066907.10 Inexact Rounded xadd491 add -53311.5738E+156608936 -7.45890666 -> -5.33115738E+156608940 Inexact Rounded xcom491 compare -53311.5738E+156608936 -7.45890666 -> -1 xdiv491 divide -53311.5738E+156608936 -7.45890666 -> 7.14737109E+156608939 Inexact Rounded xdvi491 divideint -53311.5738E+156608936 -7.45890666 -> NaN Division_impossible xmul491 multiply -53311.5738E+156608936 -7.45890666 -> 3.97646053E+156608941 Inexact Rounded xpow491 power -53311.5738E+156608936 -7 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem491 remainder -53311.5738E+156608936 -7.45890666 -> NaN Division_impossible xsub491 subtract -53311.5738E+156608936 -7.45890666 -> -5.33115738E+156608940 Inexact Rounded xadd492 add 998890068. -92.057879 -> 998889976 Inexact Rounded xcom492 compare 998890068. -92.057879 -> 1 xdiv492 divide 998890068. -92.057879 -> -10850674.4 Inexact Rounded xdvi492 divideint 998890068. -92.057879 -> -10850674 xmul492 multiply 998890068. -92.057879 -> -9.19557010E+10 Inexact Rounded xpow492 power 998890068. -92 -> 1.10757225E-828 Inexact Rounded xrem492 remainder 998890068. -92.057879 -> 33.839554 xsub492 subtract 998890068. -92.057879 -> 998890160 Inexact Rounded xadd493 add 122.495591 -407836028. -> -407835906 Inexact Rounded xcom493 compare 122.495591 -407836028. -> 1 xdiv493 divide 122.495591 -407836028. -> -3.00355002E-7 Inexact Rounded xdvi493 divideint 122.495591 -407836028. -> -0 xmul493 multiply 122.495591 -407836028. -> -4.99581153E+10 Inexact Rounded xpow493 power 122.495591 -407836028 -> 4.82463773E-851610754 Inexact Rounded xrem493 remainder 122.495591 -407836028. -> 122.495591 xsub493 subtract 122.495591 -407836028. -> 407836150 Inexact Rounded xadd494 add 187098.488 6220.05584E-236541249 -> 187098.488 Inexact Rounded xcom494 compare 187098.488 6220.05584E-236541249 -> 1 xdiv494 divide 187098.488 6220.05584E-236541249 -> 3.00798727E+236541250 Inexact Rounded xdvi494 divideint 187098.488 6220.05584E-236541249 -> NaN Division_impossible xmul494 multiply 187098.488 6220.05584E-236541249 -> 1.16376304E-236541240 Inexact Rounded xpow494 power 187098.488 6 -> 4.28964811E+31 Inexact Rounded xrem494 remainder 187098.488 6220.05584E-236541249 -> NaN Division_impossible xsub494 subtract 187098.488 6220.05584E-236541249 -> 187098.488 Inexact Rounded xadd495 add 4819899.21E+432982550 -727441917 -> 4.81989921E+432982556 Inexact Rounded xcom495 compare 4819899.21E+432982550 -727441917 -> 1 xdiv495 divide 4819899.21E+432982550 -727441917 -> -6.62582001E+432982547 Inexact Rounded xdvi495 divideint 4819899.21E+432982550 -727441917 -> NaN Division_impossible xmul495 multiply 4819899.21E+432982550 -727441917 -> -3.50619672E+432982565 Inexact Rounded xpow495 power 4819899.21E+432982550 -727441917 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem495 remainder 4819899.21E+432982550 -727441917 -> NaN Division_impossible xsub495 subtract 4819899.21E+432982550 -727441917 -> 4.81989921E+432982556 Inexact Rounded xadd496 add 5770.01020E+507459752 -4208339.33E-129766680 -> 5.77001020E+507459755 Inexact Rounded xcom496 compare 5770.01020E+507459752 -4208339.33E-129766680 -> 1 xdiv496 divide 5770.01020E+507459752 -4208339.33E-129766680 -> -1.37108958E+637226429 Inexact Rounded xdvi496 divideint 5770.01020E+507459752 -4208339.33E-129766680 -> NaN Division_impossible xmul496 multiply 5770.01020E+507459752 -4208339.33E-129766680 -> -2.42821609E+377693082 Inexact Rounded xpow496 power 5770.01020E+507459752 -4 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped xrem496 remainder 5770.01020E+507459752 -4208339.33E-129766680 -> NaN Division_impossible xsub496 subtract 5770.01020E+507459752 -4208339.33E-129766680 -> 5.77001020E+507459755 Inexact Rounded xadd497 add -286.371320 710319152 -> 710318866 Inexact Rounded xcom497 compare -286.371320 710319152 -> -1 xdiv497 divide -286.371320 710319152 -> -4.03158664E-7 Inexact Rounded xdvi497 divideint -286.371320 710319152 -> -0 xmul497 multiply -286.371320 710319152 -> -2.03415033E+11 Inexact Rounded xpow497 power -286.371320 710319152 -> Infinity Overflow Inexact Rounded xrem497 remainder -286.371320 710319152 -> -286.371320 xsub497 subtract -286.371320 710319152 -> -710319438 Inexact Rounded xadd498 add -7.27403536 -481469656E-835183700 -> -7.27403536 Inexact Rounded xcom498 compare -7.27403536 -481469656E-835183700 -> -1 xdiv498 divide -7.27403536 -481469656E-835183700 -> 1.51079830E+835183692 Inexact Rounded xdvi498 divideint -7.27403536 -481469656E-835183700 -> NaN Division_impossible xmul498 multiply -7.27403536 -481469656E-835183700 -> 3.50222730E-835183691 Inexact Rounded xpow498 power -7.27403536 -5 -> -0.0000491046885 Inexact Rounded xrem498 remainder -7.27403536 -481469656E-835183700 -> NaN Division_impossible xsub498 subtract -7.27403536 -481469656E-835183700 -> -7.27403536 Inexact Rounded xadd499 add -6157.74292 -94075286.2E+92555877 -> -9.40752862E+92555884 Inexact Rounded xcom499 compare -6157.74292 -94075286.2E+92555877 -> 1 xdiv499 divide -6157.74292 -94075286.2E+92555877 -> 6.54554790E-92555882 Inexact Rounded xdvi499 divideint -6157.74292 -94075286.2E+92555877 -> 0 xmul499 multiply -6157.74292 -94075286.2E+92555877 -> 5.79291428E+92555888 Inexact Rounded xpow499 power -6157.74292 -9 -> -7.85608218E-35 Inexact Rounded xrem499 remainder -6157.74292 -94075286.2E+92555877 -> -6157.74292 xsub499 subtract -6157.74292 -94075286.2E+92555877 -> 9.40752862E+92555884 Inexact Rounded xadd500 add -525445087.E+231529167 188227460 -> -5.25445087E+231529175 Inexact Rounded xcom500 compare -525445087.E+231529167 188227460 -> -1 xdiv500 divide -525445087.E+231529167 188227460 -> -2.79154321E+231529167 Inexact Rounded xdvi500 divideint -525445087.E+231529167 188227460 -> NaN Division_impossible xmul500 multiply -525445087.E+231529167 188227460 -> -9.89031941E+231529183 Inexact Rounded xpow500 power -525445087.E+231529167 188227460 -> Infinity Overflow Inexact Rounded xrem500 remainder -525445087.E+231529167 188227460 -> NaN Division_impossible xsub500 subtract -525445087.E+231529167 188227460 -> -5.25445087E+231529175 Inexact Rounded apd-3.2.1/testdata/reduce.decTest000066400000000000000000000223371450022325000166560ustar00rootroot00000000000000------------------------------------------------------------------------ -- reduce.decTest -- remove trailing zeros -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 999 minexponent: -999 redx001 reduce '1' -> '1' redx002 reduce '-1' -> '-1' redx003 reduce '1.00' -> '1' redx004 reduce '-1.00' -> '-1' redx005 reduce '0' -> '0' redx006 reduce '0.00' -> '0' redx007 reduce '00.0' -> '0' redx008 reduce '00.00' -> '0' redx009 reduce '00' -> '0' redx010 reduce '0E+1' -> '0' redx011 reduce '0E+5' -> '0' redx012 reduce '-2' -> '-2' redx013 reduce '2' -> '2' redx014 reduce '-2.00' -> '-2' redx015 reduce '2.00' -> '2' redx016 reduce '-0' -> '-0' redx017 reduce '-0.00' -> '-0' redx018 reduce '-00.0' -> '-0' redx019 reduce '-00.00' -> '-0' redx020 reduce '-00' -> '-0' redx021 reduce '-0E+5' -> '-0' redx022 reduce '-0E+1' -> '-0' redx030 reduce '+0.1' -> '0.1' redx031 reduce '-0.1' -> '-0.1' redx032 reduce '+0.01' -> '0.01' redx033 reduce '-0.01' -> '-0.01' redx034 reduce '+0.001' -> '0.001' redx035 reduce '-0.001' -> '-0.001' redx036 reduce '+0.000001' -> '0.000001' redx037 reduce '-0.000001' -> '-0.000001' redx038 reduce '+0.000000000001' -> '1E-12' redx039 reduce '-0.000000000001' -> '-1E-12' redx041 reduce 1.1 -> 1.1 redx042 reduce 1.10 -> 1.1 redx043 reduce 1.100 -> 1.1 redx044 reduce 1.110 -> 1.11 redx045 reduce -1.1 -> -1.1 redx046 reduce -1.10 -> -1.1 redx047 reduce -1.100 -> -1.1 redx048 reduce -1.110 -> -1.11 redx049 reduce 9.9 -> 9.9 redx050 reduce 9.90 -> 9.9 redx051 reduce 9.900 -> 9.9 redx052 reduce 9.990 -> 9.99 redx053 reduce -9.9 -> -9.9 redx054 reduce -9.90 -> -9.9 redx055 reduce -9.900 -> -9.9 redx056 reduce -9.990 -> -9.99 -- some trailing fractional zeros with zeros in units redx060 reduce 10.0 -> 1E+1 redx061 reduce 10.00 -> 1E+1 redx062 reduce 100.0 -> 1E+2 redx063 reduce 100.00 -> 1E+2 redx064 reduce 1.1000E+3 -> 1.1E+3 redx065 reduce 1.10000E+3 -> 1.1E+3 redx066 reduce -10.0 -> -1E+1 redx067 reduce -10.00 -> -1E+1 redx068 reduce -100.0 -> -1E+2 redx069 reduce -100.00 -> -1E+2 redx070 reduce -1.1000E+3 -> -1.1E+3 redx071 reduce -1.10000E+3 -> -1.1E+3 -- some insignificant trailing zeros with positive exponent redx080 reduce 10E+1 -> 1E+2 redx081 reduce 100E+1 -> 1E+3 redx082 reduce 1.0E+2 -> 1E+2 redx083 reduce 1.0E+3 -> 1E+3 redx084 reduce 1.1E+3 -> 1.1E+3 redx085 reduce 1.00E+3 -> 1E+3 redx086 reduce 1.10E+3 -> 1.1E+3 redx087 reduce -10E+1 -> -1E+2 redx088 reduce -100E+1 -> -1E+3 redx089 reduce -1.0E+2 -> -1E+2 redx090 reduce -1.0E+3 -> -1E+3 redx091 reduce -1.1E+3 -> -1.1E+3 redx092 reduce -1.00E+3 -> -1E+3 redx093 reduce -1.10E+3 -> -1.1E+3 -- some significant trailing zeros, were we to be trimming redx100 reduce 11 -> 11 redx101 reduce 10 -> 1E+1 redx102 reduce 10. -> 1E+1 redx103 reduce 1.1E+1 -> 11 redx104 reduce 1.0E+1 -> 1E+1 redx105 reduce 1.10E+2 -> 1.1E+2 redx106 reduce 1.00E+2 -> 1E+2 redx107 reduce 1.100E+3 -> 1.1E+3 redx108 reduce 1.000E+3 -> 1E+3 redx109 reduce 1.000000E+6 -> 1E+6 redx110 reduce -11 -> -11 redx111 reduce -10 -> -1E+1 redx112 reduce -10. -> -1E+1 redx113 reduce -1.1E+1 -> -11 redx114 reduce -1.0E+1 -> -1E+1 redx115 reduce -1.10E+2 -> -1.1E+2 redx116 reduce -1.00E+2 -> -1E+2 redx117 reduce -1.100E+3 -> -1.1E+3 redx118 reduce -1.000E+3 -> -1E+3 redx119 reduce -1.00000E+5 -> -1E+5 redx120 reduce -1.000000E+6 -> -1E+6 redx121 reduce -10.00000E+6 -> -1E+7 redx122 reduce -100.0000E+6 -> -1E+8 redx123 reduce -1000.000E+6 -> -1E+9 redx124 reduce -10000.00E+6 -> -1E+10 redx125 reduce -100000.0E+6 -> -1E+11 redx126 reduce -1000000.E+6 -> -1E+12 -- examples from decArith redx140 reduce '2.1' -> '2.1' redx141 reduce '-2.0' -> '-2' redx142 reduce '1.200' -> '1.2' redx143 reduce '-120' -> '-1.2E+2' redx144 reduce '120.00' -> '1.2E+2' redx145 reduce '0.00' -> '0' -- overflow tests maxexponent: 999999999 minexponent: -999999999 precision: 3 redx160 reduce 9.999E+999999999 -> Infinity Inexact Overflow Rounded redx161 reduce -9.999E+999999999 -> -Infinity Inexact Overflow Rounded -- subnormals and underflow precision: 3 maxexponent: 999 minexponent: -999 redx210 reduce 1.00E-999 -> 1E-999 redx211 reduce 0.1E-999 -> 1E-1000 Subnormal redx212 reduce 0.10E-999 -> 1E-1000 Subnormal redx213 reduce 0.100E-999 -> 1E-1000 Subnormal Rounded redx214 reduce 0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin redx215 reduce 0.999E-999 -> 1E-999 Inexact Rounded Subnormal Underflow redx216 reduce 0.099E-999 -> 1E-1000 Inexact Rounded Subnormal Underflow redx217 reduce 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow redx218 reduce 0.001E-999 -> 0 Inexact Rounded Subnormal Underflow Clamped redx219 reduce 0.0009E-999 -> 0 Inexact Rounded Subnormal Underflow Clamped redx220 reduce 0.0001E-999 -> 0 Inexact Rounded Subnormal Underflow Clamped redx230 reduce -1.00E-999 -> -1E-999 redx231 reduce -0.1E-999 -> -1E-1000 Subnormal redx232 reduce -0.10E-999 -> -1E-1000 Subnormal redx233 reduce -0.100E-999 -> -1E-1000 Subnormal Rounded redx234 reduce -0.01E-999 -> -1E-1001 Subnormal -- next is rounded to Emin redx235 reduce -0.999E-999 -> -1E-999 Inexact Rounded Subnormal Underflow redx236 reduce -0.099E-999 -> -1E-1000 Inexact Rounded Subnormal Underflow redx237 reduce -0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow redx238 reduce -0.001E-999 -> -0 Inexact Rounded Subnormal Underflow Clamped redx239 reduce -0.0009E-999 -> -0 Inexact Rounded Subnormal Underflow Clamped redx240 reduce -0.0001E-999 -> -0 Inexact Rounded Subnormal Underflow Clamped -- more reshaping precision: 9 redx260 reduce '56260E-10' -> '0.000005626' redx261 reduce '56260E-5' -> '0.5626' redx262 reduce '56260E-2' -> '562.6' redx263 reduce '56260E-1' -> '5626' redx265 reduce '56260E-0' -> '5.626E+4' redx266 reduce '56260E+0' -> '5.626E+4' redx267 reduce '56260E+1' -> '5.626E+5' redx268 reduce '56260E+2' -> '5.626E+6' redx269 reduce '56260E+3' -> '5.626E+7' redx270 reduce '56260E+4' -> '5.626E+8' redx271 reduce '56260E+5' -> '5.626E+9' redx272 reduce '56260E+6' -> '5.626E+10' redx280 reduce '-56260E-10' -> '-0.000005626' redx281 reduce '-56260E-5' -> '-0.5626' redx282 reduce '-56260E-2' -> '-562.6' redx283 reduce '-56260E-1' -> '-5626' redx285 reduce '-56260E-0' -> '-5.626E+4' redx286 reduce '-56260E+0' -> '-5.626E+4' redx287 reduce '-56260E+1' -> '-5.626E+5' redx288 reduce '-56260E+2' -> '-5.626E+6' redx289 reduce '-56260E+3' -> '-5.626E+7' redx290 reduce '-56260E+4' -> '-5.626E+8' redx291 reduce '-56260E+5' -> '-5.626E+9' redx292 reduce '-56260E+6' -> '-5.626E+10' -- FL test precision: 40 redx295 reduce 9892345673.0123456780000000000 -> 9892345673.012345678 -- specials redx820 reduce 'Inf' -> 'Infinity' redx821 reduce '-Inf' -> '-Infinity' redx822 reduce NaN -> NaN redx823 reduce sNaN -> NaN Invalid_operation redx824 reduce NaN101 -> NaN101 redx825 reduce sNaN010 -> NaN10 Invalid_operation redx827 reduce -NaN -> -NaN redx828 reduce -sNaN -> -NaN Invalid_operation redx829 reduce -NaN101 -> -NaN101 redx830 reduce -sNaN010 -> -NaN10 Invalid_operation -- payload decapitate precision: 5 redx62100 reduce sNaN1234567890 -> NaN67890 Invalid_operation -- Null test redx900 reduce # -> NaN Invalid_operation apd-3.2.1/testdata/remainder.decTest000066400000000000000000000660521450022325000173570ustar00rootroot00000000000000------------------------------------------------------------------------ -- remainder.decTest -- decimal remainder -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 -- sanity checks (as base, above) remx001 remainder 1 1 -> 0 remx002 remainder 2 1 -> 0 remx003 remainder 1 2 -> 1 remx004 remainder 2 2 -> 0 remx005 remainder 0 1 -> 0 remx006 remainder 0 2 -> 0 remx007 remainder 1 3 -> 1 remx008 remainder 2 3 -> 2 remx009 remainder 3 3 -> 0 remx010 remainder 2.4 1 -> 0.4 remx011 remainder 2.4 -1 -> 0.4 remx012 remainder -2.4 1 -> -0.4 remx013 remainder -2.4 -1 -> -0.4 remx014 remainder 2.40 1 -> 0.40 remx015 remainder 2.400 1 -> 0.400 remx016 remainder 2.4 2 -> 0.4 remx017 remainder 2.400 2 -> 0.400 remx018 remainder 2. 2 -> 0 remx019 remainder 20 20 -> 0 remx020 remainder 187 187 -> 0 remx021 remainder 5 2 -> 1 remx022 remainder 5 2.0 -> 1.0 remx023 remainder 5 2.000 -> 1.000 remx024 remainder 5 0.200 -> 0.000 remx025 remainder 5 0.200 -> 0.000 remx030 remainder 1 2 -> 1 remx031 remainder 1 4 -> 1 remx032 remainder 1 8 -> 1 remx033 remainder 1 16 -> 1 remx034 remainder 1 32 -> 1 remx035 remainder 1 64 -> 1 remx040 remainder 1 -2 -> 1 remx041 remainder 1 -4 -> 1 remx042 remainder 1 -8 -> 1 remx043 remainder 1 -16 -> 1 remx044 remainder 1 -32 -> 1 remx045 remainder 1 -64 -> 1 remx050 remainder -1 2 -> -1 remx051 remainder -1 4 -> -1 remx052 remainder -1 8 -> -1 remx053 remainder -1 16 -> -1 remx054 remainder -1 32 -> -1 remx055 remainder -1 64 -> -1 remx060 remainder -1 -2 -> -1 remx061 remainder -1 -4 -> -1 remx062 remainder -1 -8 -> -1 remx063 remainder -1 -16 -> -1 remx064 remainder -1 -32 -> -1 remx065 remainder -1 -64 -> -1 remx066 remainder 999999999 1 -> 0 remx067 remainder 999999999.4 1 -> 0.4 remx068 remainder 999999999.5 1 -> 0.5 remx069 remainder 999999999.9 1 -> 0.9 remx070 remainder 999999999.999 1 -> 0.999 precision: 6 remx071 remainder 999999999 1 -> NaN Division_impossible remx072 remainder 99999999 1 -> NaN Division_impossible remx073 remainder 9999999 1 -> NaN Division_impossible remx074 remainder 999999 1 -> 0 remx075 remainder 99999 1 -> 0 remx076 remainder 9999 1 -> 0 remx077 remainder 999 1 -> 0 remx078 remainder 99 1 -> 0 remx079 remainder 9 1 -> 0 precision: 9 remx080 remainder 0. 1 -> 0 remx081 remainder .0 1 -> 0.0 remx082 remainder 0.00 1 -> 0.00 remx083 remainder 0.00E+9 1 -> 0 remx084 remainder 0.00E+3 1 -> 0 remx085 remainder 0.00E+2 1 -> 0 remx086 remainder 0.00E+1 1 -> 0.0 remx087 remainder 0.00E+0 1 -> 0.00 remx088 remainder 0.00E-0 1 -> 0.00 remx089 remainder 0.00E-1 1 -> 0.000 remx090 remainder 0.00E-2 1 -> 0.0000 remx091 remainder 0.00E-3 1 -> 0.00000 remx092 remainder 0.00E-4 1 -> 0.000000 remx093 remainder 0.00E-5 1 -> 0E-7 remx094 remainder 0.00E-6 1 -> 0E-8 remx095 remainder 0.0000E-50 1 -> 0E-54 -- Various flavours of remainder by 0 precision: 9 maxexponent: 999999999 minexponent: -999999999 remx101 remainder 0 0 -> NaN Division_undefined remx102 remainder 0 -0 -> NaN Division_undefined remx103 remainder -0 0 -> NaN Division_undefined remx104 remainder -0 -0 -> NaN Division_undefined remx105 remainder 0.0E5 0 -> NaN Division_undefined remx106 remainder 0.000 0 -> NaN Division_undefined -- [Some think this next group should be Division_by_zero exception, but -- IEEE 854 is explicit that it is Invalid operation .. for -- remainder-near, anyway] remx107 remainder 0.0001 0 -> NaN Invalid_operation remx108 remainder 0.01 0 -> NaN Invalid_operation remx109 remainder 0.1 0 -> NaN Invalid_operation remx110 remainder 1 0 -> NaN Invalid_operation remx111 remainder 1 0.0 -> NaN Invalid_operation remx112 remainder 10 0.0 -> NaN Invalid_operation remx113 remainder 1E+100 0.0 -> NaN Invalid_operation remx114 remainder 1E+1000 0 -> NaN Invalid_operation remx115 remainder 0.0001 -0 -> NaN Invalid_operation remx116 remainder 0.01 -0 -> NaN Invalid_operation remx119 remainder 0.1 -0 -> NaN Invalid_operation remx120 remainder 1 -0 -> NaN Invalid_operation remx121 remainder 1 -0.0 -> NaN Invalid_operation remx122 remainder 10 -0.0 -> NaN Invalid_operation remx123 remainder 1E+100 -0.0 -> NaN Invalid_operation remx124 remainder 1E+1000 -0 -> NaN Invalid_operation -- and zeros on left remx130 remainder 0 1 -> 0 remx131 remainder 0 -1 -> 0 remx132 remainder 0.0 1 -> 0.0 remx133 remainder 0.0 -1 -> 0.0 remx134 remainder -0 1 -> -0 remx135 remainder -0 -1 -> -0 remx136 remainder -0.0 1 -> -0.0 remx137 remainder -0.0 -1 -> -0.0 -- 0.5ers remx143 remainder 0.5 2 -> 0.5 remx144 remainder 0.5 2.1 -> 0.5 remx145 remainder 0.5 2.01 -> 0.50 remx146 remainder 0.5 2.001 -> 0.500 remx147 remainder 0.50 2 -> 0.50 remx148 remainder 0.50 2.01 -> 0.50 remx149 remainder 0.50 2.001 -> 0.500 -- steadies remx150 remainder 1 1 -> 0 remx151 remainder 1 2 -> 1 remx152 remainder 1 3 -> 1 remx153 remainder 1 4 -> 1 remx154 remainder 1 5 -> 1 remx155 remainder 1 6 -> 1 remx156 remainder 1 7 -> 1 remx157 remainder 1 8 -> 1 remx158 remainder 1 9 -> 1 remx159 remainder 1 10 -> 1 remx160 remainder 1 1 -> 0 remx161 remainder 2 1 -> 0 remx162 remainder 3 1 -> 0 remx163 remainder 4 1 -> 0 remx164 remainder 5 1 -> 0 remx165 remainder 6 1 -> 0 remx166 remainder 7 1 -> 0 remx167 remainder 8 1 -> 0 remx168 remainder 9 1 -> 0 remx169 remainder 10 1 -> 0 -- some differences from remainderNear remx171 remainder 0.4 1.020 -> 0.400 remx172 remainder 0.50 1.020 -> 0.500 remx173 remainder 0.51 1.020 -> 0.510 remx174 remainder 0.52 1.020 -> 0.520 remx175 remainder 0.6 1.020 -> 0.600 -- More flavours of remainder by 0 maxexponent: 999999999 minexponent: -999999999 remx201 remainder 0 0 -> NaN Division_undefined remx202 remainder 0.0E5 0 -> NaN Division_undefined remx203 remainder 0.000 0 -> NaN Division_undefined remx204 remainder 0.0001 0 -> NaN Invalid_operation remx205 remainder 0.01 0 -> NaN Invalid_operation remx206 remainder 0.1 0 -> NaN Invalid_operation remx207 remainder 1 0 -> NaN Invalid_operation remx208 remainder 1 0.0 -> NaN Invalid_operation remx209 remainder 10 0.0 -> NaN Invalid_operation remx210 remainder 1E+100 0.0 -> NaN Invalid_operation remx211 remainder 1E+1000 0 -> NaN Invalid_operation -- some differences from remainderNear remx231 remainder -0.4 1.020 -> -0.400 remx232 remainder -0.50 1.020 -> -0.500 remx233 remainder -0.51 1.020 -> -0.510 remx234 remainder -0.52 1.020 -> -0.520 remx235 remainder -0.6 1.020 -> -0.600 -- high Xs remx240 remainder 1E+2 1.00 -> 0.00 -- test some cases that are close to exponent overflow maxexponent: 999999999 minexponent: -999999999 remx270 remainder 1 1e999999999 -> 1 remx271 remainder 1 0.9e999999999 -> 1 remx272 remainder 1 0.99e999999999 -> 1 remx273 remainder 1 0.999999999e999999999 -> 1 remx274 remainder 9e999999999 1 -> NaN Division_impossible remx275 remainder 9.9e999999999 1 -> NaN Division_impossible remx276 remainder 9.99e999999999 1 -> NaN Division_impossible remx277 remainder 9.99999999e999999999 1 -> NaN Division_impossible remx280 remainder 0.1 9e-999999999 -> NaN Division_impossible remx281 remainder 0.1 99e-999999999 -> NaN Division_impossible remx282 remainder 0.1 999e-999999999 -> NaN Division_impossible remx283 remainder 0.1 9e-999999998 -> NaN Division_impossible remx284 remainder 0.1 99e-999999998 -> NaN Division_impossible remx285 remainder 0.1 999e-999999998 -> NaN Division_impossible remx286 remainder 0.1 999e-999999997 -> NaN Division_impossible remx287 remainder 0.1 9999e-999999997 -> NaN Division_impossible remx288 remainder 0.1 99999e-999999997 -> NaN Division_impossible -- remx3xx are from DiagBigDecimal remx301 remainder 1 3 -> 1 remx302 remainder 5 5 -> 0 remx303 remainder 13 10 -> 3 remx304 remainder 13 50 -> 13 remx305 remainder 13 100 -> 13 remx306 remainder 13 1000 -> 13 remx307 remainder .13 1 -> 0.13 remx308 remainder 0.133 1 -> 0.133 remx309 remainder 0.1033 1 -> 0.1033 remx310 remainder 1.033 1 -> 0.033 remx311 remainder 10.33 1 -> 0.33 remx312 remainder 10.33 10 -> 0.33 remx313 remainder 103.3 1 -> 0.3 remx314 remainder 133 10 -> 3 remx315 remainder 1033 10 -> 3 remx316 remainder 1033 50 -> 33 remx317 remainder 101.0 3 -> 2.0 remx318 remainder 102.0 3 -> 0.0 remx319 remainder 103.0 3 -> 1.0 remx320 remainder 2.40 1 -> 0.40 remx321 remainder 2.400 1 -> 0.400 remx322 remainder 2.4 1 -> 0.4 remx323 remainder 2.4 2 -> 0.4 remx324 remainder 2.400 2 -> 0.400 remx325 remainder 1 0.3 -> 0.1 remx326 remainder 1 0.30 -> 0.10 remx327 remainder 1 0.300 -> 0.100 remx328 remainder 1 0.3000 -> 0.1000 remx329 remainder 1.0 0.3 -> 0.1 remx330 remainder 1.00 0.3 -> 0.10 remx331 remainder 1.000 0.3 -> 0.100 remx332 remainder 1.0000 0.3 -> 0.1000 remx333 remainder 0.5 2 -> 0.5 remx334 remainder 0.5 2.1 -> 0.5 remx335 remainder 0.5 2.01 -> 0.50 remx336 remainder 0.5 2.001 -> 0.500 remx337 remainder 0.50 2 -> 0.50 remx338 remainder 0.50 2.01 -> 0.50 remx339 remainder 0.50 2.001 -> 0.500 remx340 remainder 0.5 0.5000001 -> 0.5000000 remx341 remainder 0.5 0.50000001 -> 0.50000000 remx342 remainder 0.5 0.500000001 -> 0.500000000 remx343 remainder 0.5 0.5000000001 -> 0.500000000 Rounded remx344 remainder 0.5 0.50000000001 -> 0.500000000 Rounded remx345 remainder 0.5 0.4999999 -> 1E-7 remx346 remainder 0.5 0.49999999 -> 1E-8 remx347 remainder 0.5 0.499999999 -> 1E-9 remx348 remainder 0.5 0.4999999999 -> 1E-10 remx349 remainder 0.5 0.49999999999 -> 1E-11 remx350 remainder 0.5 0.499999999999 -> 1E-12 remx351 remainder 0.03 7 -> 0.03 remx352 remainder 5 2 -> 1 remx353 remainder 4.1 2 -> 0.1 remx354 remainder 4.01 2 -> 0.01 remx355 remainder 4.001 2 -> 0.001 remx356 remainder 4.0001 2 -> 0.0001 remx357 remainder 4.00001 2 -> 0.00001 remx358 remainder 4.000001 2 -> 0.000001 remx359 remainder 4.0000001 2 -> 1E-7 remx360 remainder 1.2 0.7345 -> 0.4655 remx361 remainder 0.8 12 -> 0.8 remx362 remainder 0.8 0.2 -> 0.0 remx363 remainder 0.8 0.3 -> 0.2 remx364 remainder 0.800 12 -> 0.800 remx365 remainder 0.800 1.7 -> 0.800 remx366 remainder 2.400 2 -> 0.400 precision: 6 remx371 remainder 2.400 2 -> 0.400 precision: 3 -- long operand, rounded, case remx372 remainder 12345678900000 12e+12 -> 3.46E+11 Inexact Rounded -- 12000000000000 precision: 5 remx381 remainder 12345 1 -> 0 remx382 remainder 12345 1.0001 -> 0.7657 remx383 remainder 12345 1.001 -> 0.668 remx384 remainder 12345 1.01 -> 0.78 remx385 remainder 12345 1.1 -> 0.8 remx386 remainder 12355 4 -> 3 remx387 remainder 12345 4 -> 1 remx388 remainder 12355 4.0001 -> 2.6912 remx389 remainder 12345 4.0001 -> 0.6914 remx390 remainder 12345 4.9 -> 1.9 remx391 remainder 12345 4.99 -> 4.73 remx392 remainder 12345 4.999 -> 2.469 remx393 remainder 12345 4.9999 -> 0.2469 remx394 remainder 12345 5 -> 0 remx395 remainder 12345 5.0001 -> 4.7532 remx396 remainder 12345 5.001 -> 2.532 remx397 remainder 12345 5.01 -> 0.36 remx398 remainder 12345 5.1 -> 3.0 precision: 9 -- the nasty division-by-1 cases remx401 remainder 0.5 1 -> 0.5 remx402 remainder 0.55 1 -> 0.55 remx403 remainder 0.555 1 -> 0.555 remx404 remainder 0.5555 1 -> 0.5555 remx405 remainder 0.55555 1 -> 0.55555 remx406 remainder 0.555555 1 -> 0.555555 remx407 remainder 0.5555555 1 -> 0.5555555 remx408 remainder 0.55555555 1 -> 0.55555555 remx409 remainder 0.555555555 1 -> 0.555555555 -- zero signs remx650 remainder 1 1 -> 0 remx651 remainder -1 1 -> -0 remx652 remainder 1 -1 -> 0 remx653 remainder -1 -1 -> -0 remx654 remainder 0 1 -> 0 remx655 remainder -0 1 -> -0 remx656 remainder 0 -1 -> 0 remx657 remainder -0 -1 -> -0 remx658 remainder 0.00 1 -> 0.00 remx659 remainder -0.00 1 -> -0.00 -- Specials remx680 remainder Inf -Inf -> NaN Invalid_operation remx681 remainder Inf -1000 -> NaN Invalid_operation remx682 remainder Inf -1 -> NaN Invalid_operation remx683 remainder Inf 0 -> NaN Invalid_operation remx684 remainder Inf -0 -> NaN Invalid_operation remx685 remainder Inf 1 -> NaN Invalid_operation remx686 remainder Inf 1000 -> NaN Invalid_operation remx687 remainder Inf Inf -> NaN Invalid_operation remx688 remainder -1000 Inf -> -1000 remx689 remainder -Inf Inf -> NaN Invalid_operation remx691 remainder -1 Inf -> -1 remx692 remainder 0 Inf -> 0 remx693 remainder -0 Inf -> -0 remx694 remainder 1 Inf -> 1 remx695 remainder 1000 Inf -> 1000 remx696 remainder Inf Inf -> NaN Invalid_operation remx700 remainder -Inf -Inf -> NaN Invalid_operation remx701 remainder -Inf -1000 -> NaN Invalid_operation remx702 remainder -Inf -1 -> NaN Invalid_operation remx703 remainder -Inf -0 -> NaN Invalid_operation remx704 remainder -Inf 0 -> NaN Invalid_operation remx705 remainder -Inf 1 -> NaN Invalid_operation remx706 remainder -Inf 1000 -> NaN Invalid_operation remx707 remainder -Inf Inf -> NaN Invalid_operation remx708 remainder -Inf -Inf -> NaN Invalid_operation remx709 remainder -1000 Inf -> -1000 remx710 remainder -1 -Inf -> -1 remx711 remainder -0 -Inf -> -0 remx712 remainder 0 -Inf -> 0 remx713 remainder 1 -Inf -> 1 remx714 remainder 1000 -Inf -> 1000 remx715 remainder Inf -Inf -> NaN Invalid_operation remx721 remainder NaN -Inf -> NaN remx722 remainder NaN -1000 -> NaN remx723 remainder NaN -1 -> NaN remx724 remainder NaN -0 -> NaN remx725 remainder -NaN 0 -> -NaN remx726 remainder NaN 1 -> NaN remx727 remainder NaN 1000 -> NaN remx728 remainder NaN Inf -> NaN remx729 remainder NaN -NaN -> NaN remx730 remainder -Inf NaN -> NaN remx731 remainder -1000 NaN -> NaN remx732 remainder -1 NaN -> NaN remx733 remainder -0 -NaN -> -NaN remx734 remainder 0 NaN -> NaN remx735 remainder 1 -NaN -> -NaN remx736 remainder 1000 NaN -> NaN remx737 remainder Inf NaN -> NaN remx741 remainder sNaN -Inf -> NaN Invalid_operation remx742 remainder sNaN -1000 -> NaN Invalid_operation remx743 remainder -sNaN -1 -> -NaN Invalid_operation remx744 remainder sNaN -0 -> NaN Invalid_operation remx745 remainder sNaN 0 -> NaN Invalid_operation remx746 remainder sNaN 1 -> NaN Invalid_operation remx747 remainder sNaN 1000 -> NaN Invalid_operation remx749 remainder sNaN NaN -> NaN Invalid_operation remx750 remainder sNaN sNaN -> NaN Invalid_operation remx751 remainder NaN sNaN -> NaN Invalid_operation remx752 remainder -Inf sNaN -> NaN Invalid_operation remx753 remainder -1000 sNaN -> NaN Invalid_operation remx754 remainder -1 sNaN -> NaN Invalid_operation remx755 remainder -0 sNaN -> NaN Invalid_operation remx756 remainder 0 sNaN -> NaN Invalid_operation remx757 remainder 1 sNaN -> NaN Invalid_operation remx758 remainder 1000 sNaN -> NaN Invalid_operation remx759 remainder Inf -sNaN -> -NaN Invalid_operation -- propaging NaNs remx760 remainder NaN1 NaN7 -> NaN1 remx761 remainder sNaN2 NaN8 -> NaN2 Invalid_operation remx762 remainder NaN3 sNaN9 -> NaN9 Invalid_operation remx763 remainder sNaN4 sNaN10 -> NaN4 Invalid_operation remx764 remainder 15 NaN11 -> NaN11 remx765 remainder NaN6 NaN12 -> NaN6 remx766 remainder Inf NaN13 -> NaN13 remx767 remainder NaN14 -Inf -> NaN14 remx768 remainder 0 NaN15 -> NaN15 remx769 remainder NaN16 -0 -> NaN16 -- test some cases that are close to exponent overflow maxexponent: 999999999 minexponent: -999999999 remx770 remainder 1 1e999999999 -> 1 remx771 remainder 1 0.9e999999999 -> 1 remx772 remainder 1 0.99e999999999 -> 1 remx773 remainder 1 0.999999999e999999999 -> 1 remx774 remainder 9e999999999 1 -> NaN Division_impossible remx775 remainder 9.9e999999999 1 -> NaN Division_impossible remx776 remainder 9.99e999999999 1 -> NaN Division_impossible remx777 remainder 9.99999999e999999999 1 -> NaN Division_impossible -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 remx801 remainder 12345678000 100 -> 0 remx802 remainder 1 12345678000 -> 1 remx803 remainder 1234567800 10 -> 0 remx804 remainder 1 1234567800 -> 1 remx805 remainder 1234567890 10 -> 0 remx806 remainder 1 1234567890 -> 1 remx807 remainder 1234567891 10 -> 1 remx808 remainder 1 1234567891 -> 1 remx809 remainder 12345678901 100 -> 1 remx810 remainder 1 12345678901 -> 1 remx811 remainder 1234567896 10 -> 6 remx812 remainder 1 1234567896 -> 1 precision: 15 remx821 remainder 12345678000 100 -> 0 remx822 remainder 1 12345678000 -> 1 remx823 remainder 1234567800 10 -> 0 remx824 remainder 1 1234567800 -> 1 remx825 remainder 1234567890 10 -> 0 remx826 remainder 1 1234567890 -> 1 remx827 remainder 1234567891 10 -> 1 remx828 remainder 1 1234567891 -> 1 remx829 remainder 12345678901 100 -> 1 remx830 remainder 1 12345678901 -> 1 remx831 remainder 1234567896 10 -> 6 remx832 remainder 1 1234567896 -> 1 -- worries from divideint precision: 8 remx840 remainder 100000000.0 1 -> NaN Division_impossible remx841 remainder 100000000.4 1 -> NaN Division_impossible remx842 remainder 100000000.5 1 -> NaN Division_impossible remx843 remainder 100000000.9 1 -> NaN Division_impossible remx844 remainder 100000000.999 1 -> NaN Division_impossible precision: 6 remx850 remainder 100000003 5 -> NaN Division_impossible remx851 remainder 10000003 5 -> NaN Division_impossible remx852 remainder 1000003 5 -> 3 remx853 remainder 100003 5 -> 3 remx854 remainder 10003 5 -> 3 remx855 remainder 1003 5 -> 3 remx856 remainder 103 5 -> 3 remx857 remainder 13 5 -> 3 remx858 remainder 1 5 -> 1 -- Vladimir's cases remx860 remainder 123.0e1 10000000000000000 -> 1230 remx861 remainder 1230 10000000000000000 -> 1230 remx862 remainder 12.3e2 10000000000000000 -> 1230 remx863 remainder 1.23e3 10000000000000000 -> 1230 remx864 remainder 123e1 10000000000000000 -> 1230 remx870 remainder 123e1 1000000000000000 -> 1230 remx871 remainder 123e1 100000000000000 -> 1230 remx872 remainder 123e1 10000000000000 -> 1230 remx873 remainder 123e1 1000000000000 -> 1230 remx874 remainder 123e1 100000000000 -> 1230 remx875 remainder 123e1 10000000000 -> 1230 remx876 remainder 123e1 1000000000 -> 1230 remx877 remainder 123e1 100000000 -> 1230 remx878 remainder 1230 100000000 -> 1230 remx879 remainder 123e1 10000000 -> 1230 remx880 remainder 123e1 1000000 -> 1230 remx881 remainder 123e1 100000 -> 1230 remx882 remainder 123e1 10000 -> 1230 remx883 remainder 123e1 1000 -> 230 remx884 remainder 123e1 100 -> 30 remx885 remainder 123e1 10 -> 0 remx886 remainder 123e1 1 -> 0 remx889 remainder 123e1 20000000000000000 -> 1230 remx890 remainder 123e1 2000000000000000 -> 1230 remx891 remainder 123e1 200000000000000 -> 1230 remx892 remainder 123e1 20000000000000 -> 1230 remx893 remainder 123e1 2000000000000 -> 1230 remx894 remainder 123e1 200000000000 -> 1230 remx895 remainder 123e1 20000000000 -> 1230 remx896 remainder 123e1 2000000000 -> 1230 remx897 remainder 123e1 200000000 -> 1230 remx899 remainder 123e1 20000000 -> 1230 remx900 remainder 123e1 2000000 -> 1230 remx901 remainder 123e1 200000 -> 1230 remx902 remainder 123e1 20000 -> 1230 remx903 remainder 123e1 2000 -> 1230 remx904 remainder 123e1 200 -> 30 remx905 remainder 123e1 20 -> 10 remx906 remainder 123e1 2 -> 0 remx909 remainder 123e1 50000000000000000 -> 1230 remx910 remainder 123e1 5000000000000000 -> 1230 remx911 remainder 123e1 500000000000000 -> 1230 remx912 remainder 123e1 50000000000000 -> 1230 remx913 remainder 123e1 5000000000000 -> 1230 remx914 remainder 123e1 500000000000 -> 1230 remx915 remainder 123e1 50000000000 -> 1230 remx916 remainder 123e1 5000000000 -> 1230 remx917 remainder 123e1 500000000 -> 1230 remx919 remainder 123e1 50000000 -> 1230 remx920 remainder 123e1 5000000 -> 1230 remx921 remainder 123e1 500000 -> 1230 remx922 remainder 123e1 50000 -> 1230 remx923 remainder 123e1 5000 -> 1230 remx924 remainder 123e1 500 -> 230 remx925 remainder 123e1 50 -> 30 remx926 remainder 123e1 5 -> 0 remx929 remainder 123e1 90000000000000000 -> 1230 remx930 remainder 123e1 9000000000000000 -> 1230 remx931 remainder 123e1 900000000000000 -> 1230 remx932 remainder 123e1 90000000000000 -> 1230 remx933 remainder 123e1 9000000000000 -> 1230 remx934 remainder 123e1 900000000000 -> 1230 remx935 remainder 123e1 90000000000 -> 1230 remx936 remainder 123e1 9000000000 -> 1230 remx937 remainder 123e1 900000000 -> 1230 remx939 remainder 123e1 90000000 -> 1230 remx940 remainder 123e1 9000000 -> 1230 remx941 remainder 123e1 900000 -> 1230 remx942 remainder 123e1 90000 -> 1230 remx943 remainder 123e1 9000 -> 1230 remx944 remainder 123e1 900 -> 330 remx945 remainder 123e1 90 -> 60 remx946 remainder 123e1 9 -> 6 remx950 remainder 123e1 10000000000000000 -> 1230 remx951 remainder 123e1 100000000000000000 -> 1230 remx952 remainder 123e1 1000000000000000000 -> 1230 remx953 remainder 123e1 10000000000000000000 -> 1230 remx954 remainder 123e1 100000000000000000000 -> 1230 remx955 remainder 123e1 1000000000000000000000 -> 1230 remx956 remainder 123e1 10000000000000000000000 -> 1230 remx957 remainder 123e1 100000000000000000000000 -> 1230 remx958 remainder 123e1 1000000000000000000000000 -> 1230 remx959 remainder 123e1 10000000000000000000000000 -> 1230 remx960 remainder 123e1 19999999999999999 -> 1230 remx961 remainder 123e1 199999999999999990 -> 1230 remx962 remainder 123e1 1999999999999999999 -> 1230 remx963 remainder 123e1 19999999999999999990 -> 1230 remx964 remainder 123e1 199999999999999999999 -> 1230 remx965 remainder 123e1 1999999999999999999990 -> 1230 remx966 remainder 123e1 19999999999999999999999 -> 1230 remx967 remainder 123e1 199999999999999999999990 -> 1230 remx968 remainder 123e1 1999999999999999999999999 -> 1230 remx969 remainder 123e1 19999999999999999999999990 -> 1230 remx970 remainder 1e1 10000000000000000 -> 10 remx971 remainder 1e1 100000000000000000 -> 10 remx972 remainder 1e1 1000000000000000000 -> 10 remx973 remainder 1e1 10000000000000000000 -> 10 remx974 remainder 1e1 100000000000000000000 -> 10 remx975 remainder 1e1 1000000000000000000000 -> 10 remx976 remainder 1e1 10000000000000000000000 -> 10 remx977 remainder 1e1 100000000000000000000000 -> 10 remx978 remainder 1e1 1000000000000000000000000 -> 10 remx979 remainder 1e1 10000000000000000000000000 -> 10 remx980 remainder 123e1 1000E999999 -> 1.23E+3 -- 123E+1 internally -- overflow and underflow tests [from divide] precision: 9 maxexponent: 999999999 minexponent: -999999999 remx990 remainder +1.23456789012345E-0 9E+999999999 -> 1.23456789 Inexact Rounded remx991 remainder 9E+999999999 +0.23456789012345E-0 -> NaN Division_impossible remx992 remainder +0.100 9E+999999999 -> 0.100 remx993 remainder 9E-999999999 +9.100 -> 9E-999999999 remx995 remainder -1.23456789012345E-0 9E+999999999 -> -1.23456789 Inexact Rounded remx996 remainder 9E+999999999 -0.83456789012345E-0 -> NaN Division_impossible remx997 remainder -0.100 9E+999999999 -> -0.100 remx998 remainder 9E-999999999 -9.100 -> 9E-999999999 -- Null tests remx1000 remainder 10 # -> NaN Invalid_operation remx1001 remainder # 10 -> NaN Invalid_operation apd-3.2.1/testdata/rounding.decTest000066400000000000000000001767511450022325000172460ustar00rootroot00000000000000------------------------------------------------------------------------ -- rounding.decTest -- decimal rounding modes testcases -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- These tests require that implementations take account of residues in -- order to get correct results for some rounding modes. Rather than -- single rounding tests we therefore need tests for most operators. -- [We do assume add/minus/plus/subtract are common paths, however, as -- is rounding of negatives (if the latter works for addition, assume it -- works for the others, too).] -- -- Round-for-reround (05UP) is tested as a separate block, mostly for -- 'historical' reasons. -- -- Underflow Subnormal and overflow behaviours are tested under the -- individual operators. extended: 1 precision: 5 -- for easier visual inspection maxExponent: 999 minexponent: -999 -- Addition operators ------------------------------------------------- rounding: down radx100 add 12345 -0.1 -> 12344 Inexact Rounded radx101 add 12345 -0.01 -> 12344 Inexact Rounded radx102 add 12345 -0.001 -> 12344 Inexact Rounded radx103 add 12345 -0.00001 -> 12344 Inexact Rounded radx104 add 12345 -0.000001 -> 12344 Inexact Rounded radx105 add 12345 -0.0000001 -> 12344 Inexact Rounded radx106 add 12345 0 -> 12345 radx107 add 12345 0.0000001 -> 12345 Inexact Rounded radx108 add 12345 0.000001 -> 12345 Inexact Rounded radx109 add 12345 0.00001 -> 12345 Inexact Rounded radx110 add 12345 0.0001 -> 12345 Inexact Rounded radx111 add 12345 0.001 -> 12345 Inexact Rounded radx112 add 12345 0.01 -> 12345 Inexact Rounded radx113 add 12345 0.1 -> 12345 Inexact Rounded radx115 add 12346 0.49999 -> 12346 Inexact Rounded radx116 add 12346 0.5 -> 12346 Inexact Rounded radx117 add 12346 0.50001 -> 12346 Inexact Rounded radx120 add 12345 0.4 -> 12345 Inexact Rounded radx121 add 12345 0.49 -> 12345 Inexact Rounded radx122 add 12345 0.499 -> 12345 Inexact Rounded radx123 add 12345 0.49999 -> 12345 Inexact Rounded radx124 add 12345 0.5 -> 12345 Inexact Rounded radx125 add 12345 0.50001 -> 12345 Inexact Rounded radx126 add 12345 0.5001 -> 12345 Inexact Rounded radx127 add 12345 0.501 -> 12345 Inexact Rounded radx128 add 12345 0.51 -> 12345 Inexact Rounded radx129 add 12345 0.6 -> 12345 Inexact Rounded rounding: half_down radx140 add 12345 -0.1 -> 12345 Inexact Rounded radx141 add 12345 -0.01 -> 12345 Inexact Rounded radx142 add 12345 -0.001 -> 12345 Inexact Rounded radx143 add 12345 -0.00001 -> 12345 Inexact Rounded radx144 add 12345 -0.000001 -> 12345 Inexact Rounded radx145 add 12345 -0.0000001 -> 12345 Inexact Rounded radx146 add 12345 0 -> 12345 radx147 add 12345 0.0000001 -> 12345 Inexact Rounded radx148 add 12345 0.000001 -> 12345 Inexact Rounded radx149 add 12345 0.00001 -> 12345 Inexact Rounded radx150 add 12345 0.0001 -> 12345 Inexact Rounded radx151 add 12345 0.001 -> 12345 Inexact Rounded radx152 add 12345 0.01 -> 12345 Inexact Rounded radx153 add 12345 0.1 -> 12345 Inexact Rounded radx155 add 12346 0.49999 -> 12346 Inexact Rounded radx156 add 12346 0.5 -> 12346 Inexact Rounded radx157 add 12346 0.50001 -> 12347 Inexact Rounded radx160 add 12345 0.4 -> 12345 Inexact Rounded radx161 add 12345 0.49 -> 12345 Inexact Rounded radx162 add 12345 0.499 -> 12345 Inexact Rounded radx163 add 12345 0.49999 -> 12345 Inexact Rounded radx164 add 12345 0.5 -> 12345 Inexact Rounded radx165 add 12345 0.50001 -> 12346 Inexact Rounded radx166 add 12345 0.5001 -> 12346 Inexact Rounded radx167 add 12345 0.501 -> 12346 Inexact Rounded radx168 add 12345 0.51 -> 12346 Inexact Rounded radx169 add 12345 0.6 -> 12346 Inexact Rounded rounding: half_even radx170 add 12345 -0.1 -> 12345 Inexact Rounded radx171 add 12345 -0.01 -> 12345 Inexact Rounded radx172 add 12345 -0.001 -> 12345 Inexact Rounded radx173 add 12345 -0.00001 -> 12345 Inexact Rounded radx174 add 12345 -0.000001 -> 12345 Inexact Rounded radx175 add 12345 -0.0000001 -> 12345 Inexact Rounded radx176 add 12345 0 -> 12345 radx177 add 12345 0.0000001 -> 12345 Inexact Rounded radx178 add 12345 0.000001 -> 12345 Inexact Rounded radx179 add 12345 0.00001 -> 12345 Inexact Rounded radx180 add 12345 0.0001 -> 12345 Inexact Rounded radx181 add 12345 0.001 -> 12345 Inexact Rounded radx182 add 12345 0.01 -> 12345 Inexact Rounded radx183 add 12345 0.1 -> 12345 Inexact Rounded radx185 add 12346 0.49999 -> 12346 Inexact Rounded radx186 add 12346 0.5 -> 12346 Inexact Rounded radx187 add 12346 0.50001 -> 12347 Inexact Rounded radx190 add 12345 0.4 -> 12345 Inexact Rounded radx191 add 12345 0.49 -> 12345 Inexact Rounded radx192 add 12345 0.499 -> 12345 Inexact Rounded radx193 add 12345 0.49999 -> 12345 Inexact Rounded radx194 add 12345 0.5 -> 12346 Inexact Rounded radx195 add 12345 0.50001 -> 12346 Inexact Rounded radx196 add 12345 0.5001 -> 12346 Inexact Rounded radx197 add 12345 0.501 -> 12346 Inexact Rounded radx198 add 12345 0.51 -> 12346 Inexact Rounded radx199 add 12345 0.6 -> 12346 Inexact Rounded rounding: half_up radx200 add 12345 -0.1 -> 12345 Inexact Rounded radx201 add 12345 -0.01 -> 12345 Inexact Rounded radx202 add 12345 -0.001 -> 12345 Inexact Rounded radx203 add 12345 -0.00001 -> 12345 Inexact Rounded radx204 add 12345 -0.000001 -> 12345 Inexact Rounded radx205 add 12345 -0.0000001 -> 12345 Inexact Rounded radx206 add 12345 0 -> 12345 radx207 add 12345 0.0000001 -> 12345 Inexact Rounded radx208 add 12345 0.000001 -> 12345 Inexact Rounded radx209 add 12345 0.00001 -> 12345 Inexact Rounded radx210 add 12345 0.0001 -> 12345 Inexact Rounded radx211 add 12345 0.001 -> 12345 Inexact Rounded radx212 add 12345 0.01 -> 12345 Inexact Rounded radx213 add 12345 0.1 -> 12345 Inexact Rounded radx215 add 12346 0.49999 -> 12346 Inexact Rounded radx216 add 12346 0.5 -> 12347 Inexact Rounded radx217 add 12346 0.50001 -> 12347 Inexact Rounded radx220 add 12345 0.4 -> 12345 Inexact Rounded radx221 add 12345 0.49 -> 12345 Inexact Rounded radx222 add 12345 0.499 -> 12345 Inexact Rounded radx223 add 12345 0.49999 -> 12345 Inexact Rounded radx224 add 12345 0.5 -> 12346 Inexact Rounded radx225 add 12345 0.50001 -> 12346 Inexact Rounded radx226 add 12345 0.5001 -> 12346 Inexact Rounded radx227 add 12345 0.501 -> 12346 Inexact Rounded radx228 add 12345 0.51 -> 12346 Inexact Rounded radx229 add 12345 0.6 -> 12346 Inexact Rounded rounding: up radx230 add 12345 -0.1 -> 12345 Inexact Rounded radx231 add 12345 -0.01 -> 12345 Inexact Rounded radx232 add 12345 -0.001 -> 12345 Inexact Rounded radx233 add 12345 -0.00001 -> 12345 Inexact Rounded radx234 add 12345 -0.000001 -> 12345 Inexact Rounded radx235 add 12345 -0.0000001 -> 12345 Inexact Rounded radx236 add 12345 0 -> 12345 radx237 add 12345 0.0000001 -> 12346 Inexact Rounded radx238 add 12345 0.000001 -> 12346 Inexact Rounded radx239 add 12345 0.00001 -> 12346 Inexact Rounded radx240 add 12345 0.0001 -> 12346 Inexact Rounded radx241 add 12345 0.001 -> 12346 Inexact Rounded radx242 add 12345 0.01 -> 12346 Inexact Rounded radx243 add 12345 0.1 -> 12346 Inexact Rounded radx245 add 12346 0.49999 -> 12347 Inexact Rounded radx246 add 12346 0.5 -> 12347 Inexact Rounded radx247 add 12346 0.50001 -> 12347 Inexact Rounded radx250 add 12345 0.4 -> 12346 Inexact Rounded radx251 add 12345 0.49 -> 12346 Inexact Rounded radx252 add 12345 0.499 -> 12346 Inexact Rounded radx253 add 12345 0.49999 -> 12346 Inexact Rounded radx254 add 12345 0.5 -> 12346 Inexact Rounded radx255 add 12345 0.50001 -> 12346 Inexact Rounded radx256 add 12345 0.5001 -> 12346 Inexact Rounded radx257 add 12345 0.501 -> 12346 Inexact Rounded radx258 add 12345 0.51 -> 12346 Inexact Rounded radx259 add 12345 0.6 -> 12346 Inexact Rounded rounding: floor radx300 add 12345 -0.1 -> 12344 Inexact Rounded radx301 add 12345 -0.01 -> 12344 Inexact Rounded radx302 add 12345 -0.001 -> 12344 Inexact Rounded radx303 add 12345 -0.00001 -> 12344 Inexact Rounded radx304 add 12345 -0.000001 -> 12344 Inexact Rounded radx305 add 12345 -0.0000001 -> 12344 Inexact Rounded radx306 add 12345 0 -> 12345 radx307 add 12345 0.0000001 -> 12345 Inexact Rounded radx308 add 12345 0.000001 -> 12345 Inexact Rounded radx309 add 12345 0.00001 -> 12345 Inexact Rounded radx310 add 12345 0.0001 -> 12345 Inexact Rounded radx311 add 12345 0.001 -> 12345 Inexact Rounded radx312 add 12345 0.01 -> 12345 Inexact Rounded radx313 add 12345 0.1 -> 12345 Inexact Rounded radx315 add 12346 0.49999 -> 12346 Inexact Rounded radx316 add 12346 0.5 -> 12346 Inexact Rounded radx317 add 12346 0.50001 -> 12346 Inexact Rounded radx320 add 12345 0.4 -> 12345 Inexact Rounded radx321 add 12345 0.49 -> 12345 Inexact Rounded radx322 add 12345 0.499 -> 12345 Inexact Rounded radx323 add 12345 0.49999 -> 12345 Inexact Rounded radx324 add 12345 0.5 -> 12345 Inexact Rounded radx325 add 12345 0.50001 -> 12345 Inexact Rounded radx326 add 12345 0.5001 -> 12345 Inexact Rounded radx327 add 12345 0.501 -> 12345 Inexact Rounded radx328 add 12345 0.51 -> 12345 Inexact Rounded radx329 add 12345 0.6 -> 12345 Inexact Rounded rounding: ceiling radx330 add 12345 -0.1 -> 12345 Inexact Rounded radx331 add 12345 -0.01 -> 12345 Inexact Rounded radx332 add 12345 -0.001 -> 12345 Inexact Rounded radx333 add 12345 -0.00001 -> 12345 Inexact Rounded radx334 add 12345 -0.000001 -> 12345 Inexact Rounded radx335 add 12345 -0.0000001 -> 12345 Inexact Rounded radx336 add 12345 0 -> 12345 radx337 add 12345 0.0000001 -> 12346 Inexact Rounded radx338 add 12345 0.000001 -> 12346 Inexact Rounded radx339 add 12345 0.00001 -> 12346 Inexact Rounded radx340 add 12345 0.0001 -> 12346 Inexact Rounded radx341 add 12345 0.001 -> 12346 Inexact Rounded radx342 add 12345 0.01 -> 12346 Inexact Rounded radx343 add 12345 0.1 -> 12346 Inexact Rounded radx345 add 12346 0.49999 -> 12347 Inexact Rounded radx346 add 12346 0.5 -> 12347 Inexact Rounded radx347 add 12346 0.50001 -> 12347 Inexact Rounded radx350 add 12345 0.4 -> 12346 Inexact Rounded radx351 add 12345 0.49 -> 12346 Inexact Rounded radx352 add 12345 0.499 -> 12346 Inexact Rounded radx353 add 12345 0.49999 -> 12346 Inexact Rounded radx354 add 12345 0.5 -> 12346 Inexact Rounded radx355 add 12345 0.50001 -> 12346 Inexact Rounded radx356 add 12345 0.5001 -> 12346 Inexact Rounded radx357 add 12345 0.501 -> 12346 Inexact Rounded radx358 add 12345 0.51 -> 12346 Inexact Rounded radx359 add 12345 0.6 -> 12346 Inexact Rounded -- negatives... rounding: down rsux100 add -12345 -0.1 -> -12345 Inexact Rounded rsux101 add -12345 -0.01 -> -12345 Inexact Rounded rsux102 add -12345 -0.001 -> -12345 Inexact Rounded rsux103 add -12345 -0.00001 -> -12345 Inexact Rounded rsux104 add -12345 -0.000001 -> -12345 Inexact Rounded rsux105 add -12345 -0.0000001 -> -12345 Inexact Rounded rsux106 add -12345 0 -> -12345 rsux107 add -12345 0.0000001 -> -12344 Inexact Rounded rsux108 add -12345 0.000001 -> -12344 Inexact Rounded rsux109 add -12345 0.00001 -> -12344 Inexact Rounded rsux110 add -12345 0.0001 -> -12344 Inexact Rounded rsux111 add -12345 0.001 -> -12344 Inexact Rounded rsux112 add -12345 0.01 -> -12344 Inexact Rounded rsux113 add -12345 0.1 -> -12344 Inexact Rounded rsux115 add -12346 0.49999 -> -12345 Inexact Rounded rsux116 add -12346 0.5 -> -12345 Inexact Rounded rsux117 add -12346 0.50001 -> -12345 Inexact Rounded rsux120 add -12345 0.4 -> -12344 Inexact Rounded rsux121 add -12345 0.49 -> -12344 Inexact Rounded rsux122 add -12345 0.499 -> -12344 Inexact Rounded rsux123 add -12345 0.49999 -> -12344 Inexact Rounded rsux124 add -12345 0.5 -> -12344 Inexact Rounded rsux125 add -12345 0.50001 -> -12344 Inexact Rounded rsux126 add -12345 0.5001 -> -12344 Inexact Rounded rsux127 add -12345 0.501 -> -12344 Inexact Rounded rsux128 add -12345 0.51 -> -12344 Inexact Rounded rsux129 add -12345 0.6 -> -12344 Inexact Rounded rounding: half_down rsux140 add -12345 -0.1 -> -12345 Inexact Rounded rsux141 add -12345 -0.01 -> -12345 Inexact Rounded rsux142 add -12345 -0.001 -> -12345 Inexact Rounded rsux143 add -12345 -0.00001 -> -12345 Inexact Rounded rsux144 add -12345 -0.000001 -> -12345 Inexact Rounded rsux145 add -12345 -0.0000001 -> -12345 Inexact Rounded rsux146 add -12345 0 -> -12345 rsux147 add -12345 0.0000001 -> -12345 Inexact Rounded rsux148 add -12345 0.000001 -> -12345 Inexact Rounded rsux149 add -12345 0.00001 -> -12345 Inexact Rounded rsux150 add -12345 0.0001 -> -12345 Inexact Rounded rsux151 add -12345 0.001 -> -12345 Inexact Rounded rsux152 add -12345 0.01 -> -12345 Inexact Rounded rsux153 add -12345 0.1 -> -12345 Inexact Rounded rsux155 add -12346 0.49999 -> -12346 Inexact Rounded rsux156 add -12346 0.5 -> -12345 Inexact Rounded rsux157 add -12346 0.50001 -> -12345 Inexact Rounded rsux160 add -12345 0.4 -> -12345 Inexact Rounded rsux161 add -12345 0.49 -> -12345 Inexact Rounded rsux162 add -12345 0.499 -> -12345 Inexact Rounded rsux163 add -12345 0.49999 -> -12345 Inexact Rounded rsux164 add -12345 0.5 -> -12344 Inexact Rounded rsux165 add -12345 0.50001 -> -12344 Inexact Rounded rsux166 add -12345 0.5001 -> -12344 Inexact Rounded rsux167 add -12345 0.501 -> -12344 Inexact Rounded rsux168 add -12345 0.51 -> -12344 Inexact Rounded rsux169 add -12345 0.6 -> -12344 Inexact Rounded rounding: half_even rsux170 add -12345 -0.1 -> -12345 Inexact Rounded rsux171 add -12345 -0.01 -> -12345 Inexact Rounded rsux172 add -12345 -0.001 -> -12345 Inexact Rounded rsux173 add -12345 -0.00001 -> -12345 Inexact Rounded rsux174 add -12345 -0.000001 -> -12345 Inexact Rounded rsux175 add -12345 -0.0000001 -> -12345 Inexact Rounded rsux176 add -12345 0 -> -12345 rsux177 add -12345 0.0000001 -> -12345 Inexact Rounded rsux178 add -12345 0.000001 -> -12345 Inexact Rounded rsux179 add -12345 0.00001 -> -12345 Inexact Rounded rsux180 add -12345 0.0001 -> -12345 Inexact Rounded rsux181 add -12345 0.001 -> -12345 Inexact Rounded rsux182 add -12345 0.01 -> -12345 Inexact Rounded rsux183 add -12345 0.1 -> -12345 Inexact Rounded rsux185 add -12346 0.49999 -> -12346 Inexact Rounded rsux186 add -12346 0.5 -> -12346 Inexact Rounded rsux187 add -12346 0.50001 -> -12345 Inexact Rounded rsux190 add -12345 0.4 -> -12345 Inexact Rounded rsux191 add -12345 0.49 -> -12345 Inexact Rounded rsux192 add -12345 0.499 -> -12345 Inexact Rounded rsux193 add -12345 0.49999 -> -12345 Inexact Rounded rsux194 add -12345 0.5 -> -12344 Inexact Rounded rsux195 add -12345 0.50001 -> -12344 Inexact Rounded rsux196 add -12345 0.5001 -> -12344 Inexact Rounded rsux197 add -12345 0.501 -> -12344 Inexact Rounded rsux198 add -12345 0.51 -> -12344 Inexact Rounded rsux199 add -12345 0.6 -> -12344 Inexact Rounded rounding: half_up rsux200 add -12345 -0.1 -> -12345 Inexact Rounded rsux201 add -12345 -0.01 -> -12345 Inexact Rounded rsux202 add -12345 -0.001 -> -12345 Inexact Rounded rsux203 add -12345 -0.00001 -> -12345 Inexact Rounded rsux204 add -12345 -0.000001 -> -12345 Inexact Rounded rsux205 add -12345 -0.0000001 -> -12345 Inexact Rounded rsux206 add -12345 0 -> -12345 rsux207 add -12345 0.0000001 -> -12345 Inexact Rounded rsux208 add -12345 0.000001 -> -12345 Inexact Rounded rsux209 add -12345 0.00001 -> -12345 Inexact Rounded rsux210 add -12345 0.0001 -> -12345 Inexact Rounded rsux211 add -12345 0.001 -> -12345 Inexact Rounded rsux212 add -12345 0.01 -> -12345 Inexact Rounded rsux213 add -12345 0.1 -> -12345 Inexact Rounded rsux215 add -12346 0.49999 -> -12346 Inexact Rounded rsux216 add -12346 0.5 -> -12346 Inexact Rounded rsux217 add -12346 0.50001 -> -12345 Inexact Rounded rsux220 add -12345 0.4 -> -12345 Inexact Rounded rsux221 add -12345 0.49 -> -12345 Inexact Rounded rsux222 add -12345 0.499 -> -12345 Inexact Rounded rsux223 add -12345 0.49999 -> -12345 Inexact Rounded rsux224 add -12345 0.5 -> -12345 Inexact Rounded rsux225 add -12345 0.50001 -> -12344 Inexact Rounded rsux226 add -12345 0.5001 -> -12344 Inexact Rounded rsux227 add -12345 0.501 -> -12344 Inexact Rounded rsux228 add -12345 0.51 -> -12344 Inexact Rounded rsux229 add -12345 0.6 -> -12344 Inexact Rounded rounding: up rsux230 add -12345 -0.1 -> -12346 Inexact Rounded rsux231 add -12345 -0.01 -> -12346 Inexact Rounded rsux232 add -12345 -0.001 -> -12346 Inexact Rounded rsux233 add -12345 -0.00001 -> -12346 Inexact Rounded rsux234 add -12345 -0.000001 -> -12346 Inexact Rounded rsux235 add -12345 -0.0000001 -> -12346 Inexact Rounded rsux236 add -12345 0 -> -12345 rsux237 add -12345 0.0000001 -> -12345 Inexact Rounded rsux238 add -12345 0.000001 -> -12345 Inexact Rounded rsux239 add -12345 0.00001 -> -12345 Inexact Rounded rsux240 add -12345 0.0001 -> -12345 Inexact Rounded rsux241 add -12345 0.001 -> -12345 Inexact Rounded rsux242 add -12345 0.01 -> -12345 Inexact Rounded rsux243 add -12345 0.1 -> -12345 Inexact Rounded rsux245 add -12346 0.49999 -> -12346 Inexact Rounded rsux246 add -12346 0.5 -> -12346 Inexact Rounded rsux247 add -12346 0.50001 -> -12346 Inexact Rounded rsux250 add -12345 0.4 -> -12345 Inexact Rounded rsux251 add -12345 0.49 -> -12345 Inexact Rounded rsux252 add -12345 0.499 -> -12345 Inexact Rounded rsux253 add -12345 0.49999 -> -12345 Inexact Rounded rsux254 add -12345 0.5 -> -12345 Inexact Rounded rsux255 add -12345 0.50001 -> -12345 Inexact Rounded rsux256 add -12345 0.5001 -> -12345 Inexact Rounded rsux257 add -12345 0.501 -> -12345 Inexact Rounded rsux258 add -12345 0.51 -> -12345 Inexact Rounded rsux259 add -12345 0.6 -> -12345 Inexact Rounded rounding: floor rsux300 add -12345 -0.1 -> -12346 Inexact Rounded rsux301 add -12345 -0.01 -> -12346 Inexact Rounded rsux302 add -12345 -0.001 -> -12346 Inexact Rounded rsux303 add -12345 -0.00001 -> -12346 Inexact Rounded rsux304 add -12345 -0.000001 -> -12346 Inexact Rounded rsux305 add -12345 -0.0000001 -> -12346 Inexact Rounded rsux306 add -12345 0 -> -12345 rsux307 add -12345 0.0000001 -> -12345 Inexact Rounded rsux308 add -12345 0.000001 -> -12345 Inexact Rounded rsux309 add -12345 0.00001 -> -12345 Inexact Rounded rsux310 add -12345 0.0001 -> -12345 Inexact Rounded rsux311 add -12345 0.001 -> -12345 Inexact Rounded rsux312 add -12345 0.01 -> -12345 Inexact Rounded rsux313 add -12345 0.1 -> -12345 Inexact Rounded rsux315 add -12346 0.49999 -> -12346 Inexact Rounded rsux316 add -12346 0.5 -> -12346 Inexact Rounded rsux317 add -12346 0.50001 -> -12346 Inexact Rounded rsux320 add -12345 0.4 -> -12345 Inexact Rounded rsux321 add -12345 0.49 -> -12345 Inexact Rounded rsux322 add -12345 0.499 -> -12345 Inexact Rounded rsux323 add -12345 0.49999 -> -12345 Inexact Rounded rsux324 add -12345 0.5 -> -12345 Inexact Rounded rsux325 add -12345 0.50001 -> -12345 Inexact Rounded rsux326 add -12345 0.5001 -> -12345 Inexact Rounded rsux327 add -12345 0.501 -> -12345 Inexact Rounded rsux328 add -12345 0.51 -> -12345 Inexact Rounded rsux329 add -12345 0.6 -> -12345 Inexact Rounded rounding: ceiling rsux330 add -12345 -0.1 -> -12345 Inexact Rounded rsux331 add -12345 -0.01 -> -12345 Inexact Rounded rsux332 add -12345 -0.001 -> -12345 Inexact Rounded rsux333 add -12345 -0.00001 -> -12345 Inexact Rounded rsux334 add -12345 -0.000001 -> -12345 Inexact Rounded rsux335 add -12345 -0.0000001 -> -12345 Inexact Rounded rsux336 add -12345 0 -> -12345 rsux337 add -12345 0.0000001 -> -12344 Inexact Rounded rsux338 add -12345 0.000001 -> -12344 Inexact Rounded rsux339 add -12345 0.00001 -> -12344 Inexact Rounded rsux340 add -12345 0.0001 -> -12344 Inexact Rounded rsux341 add -12345 0.001 -> -12344 Inexact Rounded rsux342 add -12345 0.01 -> -12344 Inexact Rounded rsux343 add -12345 0.1 -> -12344 Inexact Rounded rsux345 add -12346 0.49999 -> -12345 Inexact Rounded rsux346 add -12346 0.5 -> -12345 Inexact Rounded rsux347 add -12346 0.50001 -> -12345 Inexact Rounded rsux350 add -12345 0.4 -> -12344 Inexact Rounded rsux351 add -12345 0.49 -> -12344 Inexact Rounded rsux352 add -12345 0.499 -> -12344 Inexact Rounded rsux353 add -12345 0.49999 -> -12344 Inexact Rounded rsux354 add -12345 0.5 -> -12344 Inexact Rounded rsux355 add -12345 0.50001 -> -12344 Inexact Rounded rsux356 add -12345 0.5001 -> -12344 Inexact Rounded rsux357 add -12345 0.501 -> -12344 Inexact Rounded rsux358 add -12345 0.51 -> -12344 Inexact Rounded rsux359 add -12345 0.6 -> -12344 Inexact Rounded -- Check cancellation subtractions -- (The IEEE 854 'curious rule' in $6.3) rounding: down rzex001 add 0 0 -> 0 rzex002 add 0 -0 -> 0 rzex003 add -0 0 -> 0 rzex004 add -0 -0 -> -0 rzex005 add 1 -1 -> 0 rzex006 add -1 1 -> 0 rzex007 add 1.5 -1.5 -> 0.0 rzex008 add -1.5 1.5 -> 0.0 rzex009 add 2 -2 -> 0 rzex010 add -2 2 -> 0 rounding: up rzex011 add 0 0 -> 0 rzex012 add 0 -0 -> 0 rzex013 add -0 0 -> 0 rzex014 add -0 -0 -> -0 rzex015 add 1 -1 -> 0 rzex016 add -1 1 -> 0 rzex017 add 1.5 -1.5 -> 0.0 rzex018 add -1.5 1.5 -> 0.0 rzex019 add 2 -2 -> 0 rzex020 add -2 2 -> 0 rounding: half_up rzex021 add 0 0 -> 0 rzex022 add 0 -0 -> 0 rzex023 add -0 0 -> 0 rzex024 add -0 -0 -> -0 rzex025 add 1 -1 -> 0 rzex026 add -1 1 -> 0 rzex027 add 1.5 -1.5 -> 0.0 rzex028 add -1.5 1.5 -> 0.0 rzex029 add 2 -2 -> 0 rzex030 add -2 2 -> 0 rounding: half_down rzex031 add 0 0 -> 0 rzex032 add 0 -0 -> 0 rzex033 add -0 0 -> 0 rzex034 add -0 -0 -> -0 rzex035 add 1 -1 -> 0 rzex036 add -1 1 -> 0 rzex037 add 1.5 -1.5 -> 0.0 rzex038 add -1.5 1.5 -> 0.0 rzex039 add 2 -2 -> 0 rzex040 add -2 2 -> 0 rounding: half_even rzex041 add 0 0 -> 0 rzex042 add 0 -0 -> 0 rzex043 add -0 0 -> 0 rzex044 add -0 -0 -> -0 rzex045 add 1 -1 -> 0 rzex046 add -1 1 -> 0 rzex047 add 1.5 -1.5 -> 0.0 rzex048 add -1.5 1.5 -> 0.0 rzex049 add 2 -2 -> 0 rzex050 add -2 2 -> 0 rounding: floor rzex051 add 0 0 -> 0 rzex052 add 0 -0 -> -0 -- here are two 'curious' rzex053 add -0 0 -> -0 -- rzex054 add -0 -0 -> -0 rzex055 add 1 -1 -> -0 -- here are the rest rzex056 add -1 1 -> -0 -- .. rzex057 add 1.5 -1.5 -> -0.0 -- .. rzex058 add -1.5 1.5 -> -0.0 -- .. rzex059 add 2 -2 -> -0 -- .. rzex060 add -2 2 -> -0 -- .. rounding: ceiling rzex061 add 0 0 -> 0 rzex062 add 0 -0 -> 0 rzex063 add -0 0 -> 0 rzex064 add -0 -0 -> -0 rzex065 add 1 -1 -> 0 rzex066 add -1 1 -> 0 rzex067 add 1.5 -1.5 -> 0.0 rzex068 add -1.5 1.5 -> 0.0 rzex069 add 2 -2 -> 0 rzex070 add -2 2 -> 0 -- Division operators ------------------------------------------------- rounding: down rdvx101 divide 12345 1 -> 12345 rdvx102 divide 12345 1.0001 -> 12343 Inexact Rounded rdvx103 divide 12345 1.001 -> 12332 Inexact Rounded rdvx104 divide 12345 1.01 -> 12222 Inexact Rounded rdvx105 divide 12345 1.1 -> 11222 Inexact Rounded rdvx106 divide 12355 4 -> 3088.7 Inexact Rounded rdvx107 divide 12345 4 -> 3086.2 Inexact Rounded rdvx108 divide 12355 4.0001 -> 3088.6 Inexact Rounded rdvx109 divide 12345 4.0001 -> 3086.1 Inexact Rounded rdvx110 divide 12345 4.9 -> 2519.3 Inexact Rounded rdvx111 divide 12345 4.99 -> 2473.9 Inexact Rounded rdvx112 divide 12345 4.999 -> 2469.4 Inexact Rounded rdvx113 divide 12345 4.9999 -> 2469.0 Inexact Rounded rdvx114 divide 12345 5 -> 2469 rdvx115 divide 12345 5.0001 -> 2468.9 Inexact Rounded rdvx116 divide 12345 5.001 -> 2468.5 Inexact Rounded rdvx117 divide 12345 5.01 -> 2464.0 Inexact Rounded rdvx118 divide 12345 5.1 -> 2420.5 Inexact Rounded rounding: half_down rdvx201 divide 12345 1 -> 12345 rdvx202 divide 12345 1.0001 -> 12344 Inexact Rounded rdvx203 divide 12345 1.001 -> 12333 Inexact Rounded rdvx204 divide 12345 1.01 -> 12223 Inexact Rounded rdvx205 divide 12345 1.1 -> 11223 Inexact Rounded rdvx206 divide 12355 4 -> 3088.7 Inexact Rounded rdvx207 divide 12345 4 -> 3086.2 Inexact Rounded rdvx208 divide 12355 4.0001 -> 3088.7 Inexact Rounded rdvx209 divide 12345 4.0001 -> 3086.2 Inexact Rounded rdvx210 divide 12345 4.9 -> 2519.4 Inexact Rounded rdvx211 divide 12345 4.99 -> 2473.9 Inexact Rounded rdvx212 divide 12345 4.999 -> 2469.5 Inexact Rounded rdvx213 divide 12345 4.9999 -> 2469.0 Inexact Rounded rdvx214 divide 12345 5 -> 2469 rdvx215 divide 12345 5.0001 -> 2469.0 Inexact Rounded rdvx216 divide 12345 5.001 -> 2468.5 Inexact Rounded rdvx217 divide 12345 5.01 -> 2464.1 Inexact Rounded rdvx218 divide 12345 5.1 -> 2420.6 Inexact Rounded rounding: half_even rdvx301 divide 12345 1 -> 12345 rdvx302 divide 12345 1.0001 -> 12344 Inexact Rounded rdvx303 divide 12345 1.001 -> 12333 Inexact Rounded rdvx304 divide 12345 1.01 -> 12223 Inexact Rounded rdvx305 divide 12345 1.1 -> 11223 Inexact Rounded rdvx306 divide 12355 4 -> 3088.8 Inexact Rounded rdvx307 divide 12345 4 -> 3086.2 Inexact Rounded rdvx308 divide 12355 4.0001 -> 3088.7 Inexact Rounded rdvx309 divide 12345 4.0001 -> 3086.2 Inexact Rounded rdvx310 divide 12345 4.9 -> 2519.4 Inexact Rounded rdvx311 divide 12345 4.99 -> 2473.9 Inexact Rounded rdvx312 divide 12345 4.999 -> 2469.5 Inexact Rounded rdvx313 divide 12345 4.9999 -> 2469.0 Inexact Rounded rdvx314 divide 12345 5 -> 2469 rdvx315 divide 12345 5.0001 -> 2469.0 Inexact Rounded rdvx316 divide 12345 5.001 -> 2468.5 Inexact Rounded rdvx317 divide 12345 5.01 -> 2464.1 Inexact Rounded rdvx318 divide 12345 5.1 -> 2420.6 Inexact Rounded rounding: half_up rdvx401 divide 12345 1 -> 12345 rdvx402 divide 12345 1.0001 -> 12344 Inexact Rounded rdvx403 divide 12345 1.001 -> 12333 Inexact Rounded rdvx404 divide 12345 1.01 -> 12223 Inexact Rounded rdvx405 divide 12345 1.1 -> 11223 Inexact Rounded rdvx406 divide 12355 4 -> 3088.8 Inexact Rounded rdvx407 divide 12345 4 -> 3086.3 Inexact Rounded rdvx408 divide 12355 4.0001 -> 3088.7 Inexact Rounded rdvx409 divide 12345 4.0001 -> 3086.2 Inexact Rounded rdvx410 divide 12345 4.9 -> 2519.4 Inexact Rounded rdvx411 divide 12345 4.99 -> 2473.9 Inexact Rounded rdvx412 divide 12345 4.999 -> 2469.5 Inexact Rounded rdvx413 divide 12345 4.9999 -> 2469.0 Inexact Rounded rdvx414 divide 12345 5 -> 2469 rdvx415 divide 12345 5.0001 -> 2469.0 Inexact Rounded rdvx416 divide 12345 5.001 -> 2468.5 Inexact Rounded rdvx417 divide 12345 5.01 -> 2464.1 Inexact Rounded rdvx418 divide 12345 5.1 -> 2420.6 Inexact Rounded rounding: up rdvx501 divide 12345 1 -> 12345 rdvx502 divide 12345 1.0001 -> 12344 Inexact Rounded rdvx503 divide 12345 1.001 -> 12333 Inexact Rounded rdvx504 divide 12345 1.01 -> 12223 Inexact Rounded rdvx505 divide 12345 1.1 -> 11223 Inexact Rounded rdvx506 divide 12355 4 -> 3088.8 Inexact Rounded rdvx507 divide 12345 4 -> 3086.3 Inexact Rounded rdvx508 divide 12355 4.0001 -> 3088.7 Inexact Rounded rdvx509 divide 12345 4.0001 -> 3086.2 Inexact Rounded rdvx510 divide 12345 4.9 -> 2519.4 Inexact Rounded rdvx511 divide 12345 4.99 -> 2474.0 Inexact Rounded rdvx512 divide 12345 4.999 -> 2469.5 Inexact Rounded rdvx513 divide 12345 4.9999 -> 2469.1 Inexact Rounded rdvx514 divide 12345 5 -> 2469 rdvx515 divide 12345 5.0001 -> 2469.0 Inexact Rounded rdvx516 divide 12345 5.001 -> 2468.6 Inexact Rounded rdvx517 divide 12345 5.01 -> 2464.1 Inexact Rounded rdvx518 divide 12345 5.1 -> 2420.6 Inexact Rounded rounding: floor rdvx601 divide 12345 1 -> 12345 rdvx602 divide 12345 1.0001 -> 12343 Inexact Rounded rdvx603 divide 12345 1.001 -> 12332 Inexact Rounded rdvx604 divide 12345 1.01 -> 12222 Inexact Rounded rdvx605 divide 12345 1.1 -> 11222 Inexact Rounded rdvx606 divide 12355 4 -> 3088.7 Inexact Rounded rdvx607 divide 12345 4 -> 3086.2 Inexact Rounded rdvx608 divide 12355 4.0001 -> 3088.6 Inexact Rounded rdvx609 divide 12345 4.0001 -> 3086.1 Inexact Rounded rdvx610 divide 12345 4.9 -> 2519.3 Inexact Rounded rdvx611 divide 12345 4.99 -> 2473.9 Inexact Rounded rdvx612 divide 12345 4.999 -> 2469.4 Inexact Rounded rdvx613 divide 12345 4.9999 -> 2469.0 Inexact Rounded rdvx614 divide 12345 5 -> 2469 rdvx615 divide 12345 5.0001 -> 2468.9 Inexact Rounded rdvx616 divide 12345 5.001 -> 2468.5 Inexact Rounded rdvx617 divide 12345 5.01 -> 2464.0 Inexact Rounded rdvx618 divide 12345 5.1 -> 2420.5 Inexact Rounded rounding: ceiling rdvx701 divide 12345 1 -> 12345 rdvx702 divide 12345 1.0001 -> 12344 Inexact Rounded rdvx703 divide 12345 1.001 -> 12333 Inexact Rounded rdvx704 divide 12345 1.01 -> 12223 Inexact Rounded rdvx705 divide 12345 1.1 -> 11223 Inexact Rounded rdvx706 divide 12355 4 -> 3088.8 Inexact Rounded rdvx707 divide 12345 4 -> 3086.3 Inexact Rounded rdvx708 divide 12355 4.0001 -> 3088.7 Inexact Rounded rdvx709 divide 12345 4.0001 -> 3086.2 Inexact Rounded rdvx710 divide 12345 4.9 -> 2519.4 Inexact Rounded rdvx711 divide 12345 4.99 -> 2474.0 Inexact Rounded rdvx712 divide 12345 4.999 -> 2469.5 Inexact Rounded rdvx713 divide 12345 4.9999 -> 2469.1 Inexact Rounded rdvx714 divide 12345 5 -> 2469 rdvx715 divide 12345 5.0001 -> 2469.0 Inexact Rounded rdvx716 divide 12345 5.001 -> 2468.6 Inexact Rounded rdvx717 divide 12345 5.01 -> 2464.1 Inexact Rounded rdvx718 divide 12345 5.1 -> 2420.6 Inexact Rounded -- [divideInteger and remainder unaffected] -- Multiplication operator -------------------------------------------- rounding: down rmux101 multiply 12345 1 -> 12345 rmux102 multiply 12345 1.0001 -> 12346 Inexact Rounded rmux103 multiply 12345 1.001 -> 12357 Inexact Rounded rmux104 multiply 12345 1.01 -> 12468 Inexact Rounded rmux105 multiply 12345 1.1 -> 13579 Inexact Rounded rmux106 multiply 12345 4 -> 49380 rmux107 multiply 12345 4.0001 -> 49381 Inexact Rounded rmux108 multiply 12345 4.9 -> 60490 Inexact Rounded rmux109 multiply 12345 4.99 -> 61601 Inexact Rounded rmux110 multiply 12345 4.999 -> 61712 Inexact Rounded rmux111 multiply 12345 4.9999 -> 61723 Inexact Rounded rmux112 multiply 12345 5 -> 61725 rmux113 multiply 12345 5.0001 -> 61726 Inexact Rounded rmux114 multiply 12345 5.001 -> 61737 Inexact Rounded rmux115 multiply 12345 5.01 -> 61848 Inexact Rounded rmux116 multiply 12345 12 -> 1.4814E+5 Rounded rmux117 multiply 12345 13 -> 1.6048E+5 Inexact Rounded rmux118 multiply 12355 12 -> 1.4826E+5 Rounded rmux119 multiply 12355 13 -> 1.6061E+5 Inexact Rounded rounding: half_down rmux201 multiply 12345 1 -> 12345 rmux202 multiply 12345 1.0001 -> 12346 Inexact Rounded rmux203 multiply 12345 1.001 -> 12357 Inexact Rounded rmux204 multiply 12345 1.01 -> 12468 Inexact Rounded rmux205 multiply 12345 1.1 -> 13579 Inexact Rounded rmux206 multiply 12345 4 -> 49380 rmux207 multiply 12345 4.0001 -> 49381 Inexact Rounded rmux208 multiply 12345 4.9 -> 60490 Inexact Rounded rmux209 multiply 12345 4.99 -> 61602 Inexact Rounded rmux210 multiply 12345 4.999 -> 61713 Inexact Rounded rmux211 multiply 12345 4.9999 -> 61724 Inexact Rounded rmux212 multiply 12345 5 -> 61725 rmux213 multiply 12345 5.0001 -> 61726 Inexact Rounded rmux214 multiply 12345 5.001 -> 61737 Inexact Rounded rmux215 multiply 12345 5.01 -> 61848 Inexact Rounded rmux216 multiply 12345 12 -> 1.4814E+5 Rounded rmux217 multiply 12345 13 -> 1.6048E+5 Inexact Rounded rmux218 multiply 12355 12 -> 1.4826E+5 Rounded rmux219 multiply 12355 13 -> 1.6061E+5 Inexact Rounded rounding: half_even rmux301 multiply 12345 1 -> 12345 rmux302 multiply 12345 1.0001 -> 12346 Inexact Rounded rmux303 multiply 12345 1.001 -> 12357 Inexact Rounded rmux304 multiply 12345 1.01 -> 12468 Inexact Rounded rmux305 multiply 12345 1.1 -> 13580 Inexact Rounded rmux306 multiply 12345 4 -> 49380 rmux307 multiply 12345 4.0001 -> 49381 Inexact Rounded rmux308 multiply 12345 4.9 -> 60490 Inexact Rounded rmux309 multiply 12345 4.99 -> 61602 Inexact Rounded rmux310 multiply 12345 4.999 -> 61713 Inexact Rounded rmux311 multiply 12345 4.9999 -> 61724 Inexact Rounded rmux312 multiply 12345 5 -> 61725 rmux313 multiply 12345 5.0001 -> 61726 Inexact Rounded rmux314 multiply 12345 5.001 -> 61737 Inexact Rounded rmux315 multiply 12345 5.01 -> 61848 Inexact Rounded rmux316 multiply 12345 12 -> 1.4814E+5 Rounded rmux317 multiply 12345 13 -> 1.6048E+5 Inexact Rounded rmux318 multiply 12355 12 -> 1.4826E+5 Rounded rmux319 multiply 12355 13 -> 1.6062E+5 Inexact Rounded rounding: half_up rmux401 multiply 12345 1 -> 12345 rmux402 multiply 12345 1.0001 -> 12346 Inexact Rounded rmux403 multiply 12345 1.001 -> 12357 Inexact Rounded rmux404 multiply 12345 1.01 -> 12468 Inexact Rounded rmux405 multiply 12345 1.1 -> 13580 Inexact Rounded rmux406 multiply 12345 4 -> 49380 rmux407 multiply 12345 4.0001 -> 49381 Inexact Rounded rmux408 multiply 12345 4.9 -> 60491 Inexact Rounded rmux409 multiply 12345 4.99 -> 61602 Inexact Rounded rmux410 multiply 12345 4.999 -> 61713 Inexact Rounded rmux411 multiply 12345 4.9999 -> 61724 Inexact Rounded rmux412 multiply 12345 5 -> 61725 rmux413 multiply 12345 5.0001 -> 61726 Inexact Rounded rmux414 multiply 12345 5.001 -> 61737 Inexact Rounded rmux415 multiply 12345 5.01 -> 61848 Inexact Rounded rmux416 multiply 12345 12 -> 1.4814E+5 Rounded rmux417 multiply 12345 13 -> 1.6049E+5 Inexact Rounded rmux418 multiply 12355 12 -> 1.4826E+5 Rounded rmux419 multiply 12355 13 -> 1.6062E+5 Inexact Rounded rounding: up rmux501 multiply 12345 1 -> 12345 rmux502 multiply 12345 1.0001 -> 12347 Inexact Rounded rmux503 multiply 12345 1.001 -> 12358 Inexact Rounded rmux504 multiply 12345 1.01 -> 12469 Inexact Rounded rmux505 multiply 12345 1.1 -> 13580 Inexact Rounded rmux506 multiply 12345 4 -> 49380 rmux507 multiply 12345 4.0001 -> 49382 Inexact Rounded rmux508 multiply 12345 4.9 -> 60491 Inexact Rounded rmux509 multiply 12345 4.99 -> 61602 Inexact Rounded rmux510 multiply 12345 4.999 -> 61713 Inexact Rounded rmux511 multiply 12345 4.9999 -> 61724 Inexact Rounded rmux512 multiply 12345 5 -> 61725 rmux513 multiply 12345 5.0001 -> 61727 Inexact Rounded rmux514 multiply 12345 5.001 -> 61738 Inexact Rounded rmux515 multiply 12345 5.01 -> 61849 Inexact Rounded rmux516 multiply 12345 12 -> 1.4814E+5 Rounded rmux517 multiply 12345 13 -> 1.6049E+5 Inexact Rounded rmux518 multiply 12355 12 -> 1.4826E+5 Rounded rmux519 multiply 12355 13 -> 1.6062E+5 Inexact Rounded -- [rmux516 & rmux518] can surprise rounding: floor rmux601 multiply 12345 1 -> 12345 rmux602 multiply 12345 1.0001 -> 12346 Inexact Rounded rmux603 multiply 12345 1.001 -> 12357 Inexact Rounded rmux604 multiply 12345 1.01 -> 12468 Inexact Rounded rmux605 multiply 12345 1.1 -> 13579 Inexact Rounded rmux606 multiply 12345 4 -> 49380 rmux607 multiply 12345 4.0001 -> 49381 Inexact Rounded rmux608 multiply 12345 4.9 -> 60490 Inexact Rounded rmux609 multiply 12345 4.99 -> 61601 Inexact Rounded rmux610 multiply 12345 4.999 -> 61712 Inexact Rounded rmux611 multiply 12345 4.9999 -> 61723 Inexact Rounded rmux612 multiply 12345 5 -> 61725 rmux613 multiply 12345 5.0001 -> 61726 Inexact Rounded rmux614 multiply 12345 5.001 -> 61737 Inexact Rounded rmux615 multiply 12345 5.01 -> 61848 Inexact Rounded rmux616 multiply 12345 12 -> 1.4814E+5 Rounded rmux617 multiply 12345 13 -> 1.6048E+5 Inexact Rounded rmux618 multiply 12355 12 -> 1.4826E+5 Rounded rmux619 multiply 12355 13 -> 1.6061E+5 Inexact Rounded rounding: ceiling rmux701 multiply 12345 1 -> 12345 rmux702 multiply 12345 1.0001 -> 12347 Inexact Rounded rmux703 multiply 12345 1.001 -> 12358 Inexact Rounded rmux704 multiply 12345 1.01 -> 12469 Inexact Rounded rmux705 multiply 12345 1.1 -> 13580 Inexact Rounded rmux706 multiply 12345 4 -> 49380 rmux707 multiply 12345 4.0001 -> 49382 Inexact Rounded rmux708 multiply 12345 4.9 -> 60491 Inexact Rounded rmux709 multiply 12345 4.99 -> 61602 Inexact Rounded rmux710 multiply 12345 4.999 -> 61713 Inexact Rounded rmux711 multiply 12345 4.9999 -> 61724 Inexact Rounded rmux712 multiply 12345 5 -> 61725 rmux713 multiply 12345 5.0001 -> 61727 Inexact Rounded rmux714 multiply 12345 5.001 -> 61738 Inexact Rounded rmux715 multiply 12345 5.01 -> 61849 Inexact Rounded rmux716 multiply 12345 12 -> 1.4814E+5 Rounded rmux717 multiply 12345 13 -> 1.6049E+5 Inexact Rounded rmux718 multiply 12355 12 -> 1.4826E+5 Rounded rmux719 multiply 12355 13 -> 1.6062E+5 Inexact Rounded -- Power operator ----------------------------------------------------- rounding: down rpox101 power 12345 -5 -> 3.4877E-21 Inexact Rounded rpox102 power 12345 -4 -> 4.3056E-17 Inexact Rounded rpox103 power 12345 -3 -> 5.3152E-13 Inexact Rounded rpox104 power 12345 -2 -> 6.5617E-9 Inexact Rounded rpox105 power 12345 -1 -> 0.000081004 Inexact Rounded rpox106 power 12345 0 -> 1 rpox107 power 12345 1 -> 12345 rpox108 power 12345 2 -> 1.5239E+8 Inexact Rounded rpox109 power 12345 3 -> 1.8813E+12 Inexact Rounded rpox110 power 12345 4 -> 2.3225E+16 Inexact Rounded rpox111 power 12345 5 -> 2.8671E+20 Inexact Rounded rpox112 power 415 2 -> 1.7222E+5 Inexact Rounded rpox113 power 75 3 -> 4.2187E+5 Inexact Rounded rounding: half_down rpox201 power 12345 -5 -> 3.4877E-21 Inexact Rounded rpox202 power 12345 -4 -> 4.3056E-17 Inexact Rounded rpox203 power 12345 -3 -> 5.3153E-13 Inexact Rounded rpox204 power 12345 -2 -> 6.5617E-9 Inexact Rounded rpox205 power 12345 -1 -> 0.000081004 Inexact Rounded rpox206 power 12345 0 -> 1 rpox207 power 12345 1 -> 12345 rpox208 power 12345 2 -> 1.5240E+8 Inexact Rounded rpox209 power 12345 3 -> 1.8814E+12 Inexact Rounded rpox210 power 12345 4 -> 2.3225E+16 Inexact Rounded rpox211 power 12345 5 -> 2.8672E+20 Inexact Rounded rpox212 power 415 2 -> 1.7222E+5 Inexact Rounded rpox213 power 75 3 -> 4.2187E+5 Inexact Rounded rounding: half_even rpox301 power 12345 -5 -> 3.4877E-21 Inexact Rounded rpox302 power 12345 -4 -> 4.3056E-17 Inexact Rounded rpox303 power 12345 -3 -> 5.3153E-13 Inexact Rounded rpox304 power 12345 -2 -> 6.5617E-9 Inexact Rounded rpox305 power 12345 -1 -> 0.000081004 Inexact Rounded rpox306 power 12345 0 -> 1 rpox307 power 12345 1 -> 12345 rpox308 power 12345 2 -> 1.5240E+8 Inexact Rounded rpox309 power 12345 3 -> 1.8814E+12 Inexact Rounded rpox310 power 12345 4 -> 2.3225E+16 Inexact Rounded rpox311 power 12345 5 -> 2.8672E+20 Inexact Rounded rpox312 power 415 2 -> 1.7222E+5 Inexact Rounded rpox313 power 75 3 -> 4.2188E+5 Inexact Rounded rounding: half_up rpox401 power 12345 -5 -> 3.4877E-21 Inexact Rounded rpox402 power 12345 -4 -> 4.3056E-17 Inexact Rounded rpox403 power 12345 -3 -> 5.3153E-13 Inexact Rounded rpox404 power 12345 -2 -> 6.5617E-9 Inexact Rounded rpox405 power 12345 -1 -> 0.000081004 Inexact Rounded rpox406 power 12345 0 -> 1 rpox407 power 12345 1 -> 12345 rpox408 power 12345 2 -> 1.5240E+8 Inexact Rounded rpox409 power 12345 3 -> 1.8814E+12 Inexact Rounded rpox410 power 12345 4 -> 2.3225E+16 Inexact Rounded rpox411 power 12345 5 -> 2.8672E+20 Inexact Rounded rpox412 power 415 2 -> 1.7223E+5 Inexact Rounded rpox413 power 75 3 -> 4.2188E+5 Inexact Rounded rounding: up rpox501 power 12345 -5 -> 3.4878E-21 Inexact Rounded rpox502 power 12345 -4 -> 4.3057E-17 Inexact Rounded rpox503 power 12345 -3 -> 5.3153E-13 Inexact Rounded rpox504 power 12345 -2 -> 6.5618E-9 Inexact Rounded rpox505 power 12345 -1 -> 0.000081005 Inexact Rounded rpox506 power 12345 0 -> 1 rpox507 power 12345 1 -> 12345 rpox508 power 12345 2 -> 1.5240E+8 Inexact Rounded rpox509 power 12345 3 -> 1.8814E+12 Inexact Rounded rpox510 power 12345 4 -> 2.3226E+16 Inexact Rounded rpox511 power 12345 5 -> 2.8672E+20 Inexact Rounded rpox512 power 415 2 -> 1.7223E+5 Inexact Rounded rpox513 power 75 3 -> 4.2188E+5 Inexact Rounded rounding: floor rpox601 power 12345 -5 -> 3.4877E-21 Inexact Rounded rpox602 power 12345 -4 -> 4.3056E-17 Inexact Rounded rpox603 power 12345 -3 -> 5.3152E-13 Inexact Rounded rpox604 power 12345 -2 -> 6.5617E-9 Inexact Rounded rpox605 power 12345 -1 -> 0.000081004 Inexact Rounded rpox606 power 12345 0 -> 1 rpox607 power 12345 1 -> 12345 rpox608 power 12345 2 -> 1.5239E+8 Inexact Rounded rpox609 power 12345 3 -> 1.8813E+12 Inexact Rounded rpox610 power 12345 4 -> 2.3225E+16 Inexact Rounded rpox611 power 12345 5 -> 2.8671E+20 Inexact Rounded rpox612 power 415 2 -> 1.7222E+5 Inexact Rounded rpox613 power 75 3 -> 4.2187E+5 Inexact Rounded rounding: ceiling rpox701 power 12345 -5 -> 3.4878E-21 Inexact Rounded rpox702 power 12345 -4 -> 4.3057E-17 Inexact Rounded rpox703 power 12345 -3 -> 5.3153E-13 Inexact Rounded rpox704 power 12345 -2 -> 6.5618E-9 Inexact Rounded rpox705 power 12345 -1 -> 0.000081005 Inexact Rounded rpox706 power 12345 0 -> 1 rpox707 power 12345 1 -> 12345 rpox708 power 12345 2 -> 1.5240E+8 Inexact Rounded rpox709 power 12345 3 -> 1.8814E+12 Inexact Rounded rpox710 power 12345 4 -> 2.3226E+16 Inexact Rounded rpox711 power 12345 5 -> 2.8672E+20 Inexact Rounded rpox712 power 415 2 -> 1.7223E+5 Inexact Rounded rpox713 power 75 3 -> 4.2188E+5 Inexact Rounded -- Underflow Subnormal and overflow values vary with rounding mode and sign maxexponent: 999999999 minexponent: -999999999 rounding: down rovx100 multiply 10 9E+999999999 -> 9.9999E+999999999 Overflow Inexact Rounded rovx101 multiply -10 9E+999999999 -> -9.9999E+999999999 Overflow Inexact Rounded rovx102 divide 1E-9 9E+999999999 -> 0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rovx104 divide -1E-9 9E+999999999 -> -0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rounding: up rovx110 multiply 10 9E+999999999 -> Infinity Overflow Inexact Rounded rovx111 multiply -10 9E+999999999 -> -Infinity Overflow Inexact Rounded rovx112 divide 1E-9 9E+999999999 -> 1E-1000000003 Underflow Subnormal Inexact Rounded rovx114 divide -1E-9 9E+999999999 -> -1E-1000000003 Underflow Subnormal Inexact Rounded rounding: ceiling rovx120 multiply 10 9E+999999999 -> Infinity Overflow Inexact Rounded rovx121 multiply -10 9E+999999999 -> -9.9999E+999999999 Overflow Inexact Rounded rovx122 divide 1E-9 9E+999999999 -> 1E-1000000003 Underflow Subnormal Inexact Rounded rovx124 divide -1E-9 9E+999999999 -> -0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rounding: floor rovx130 multiply 10 9E+999999999 -> 9.9999E+999999999 Overflow Inexact Rounded rovx131 multiply -10 9E+999999999 -> -Infinity Overflow Inexact Rounded rovx132 divide 1E-9 9E+999999999 -> 0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rovx134 divide -1E-9 9E+999999999 -> -1E-1000000003 Underflow Subnormal Inexact Rounded rounding: half_up rovx140 multiply 10 9E+999999999 -> Infinity Overflow Inexact Rounded rovx141 multiply -10 9E+999999999 -> -Infinity Overflow Inexact Rounded rovx142 divide 1E-9 9E+999999999 -> 0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rovx144 divide -1E-9 9E+999999999 -> -0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rounding: half_even rovx150 multiply 10 9E+999999999 -> Infinity Overflow Inexact Rounded rovx151 multiply -10 9E+999999999 -> -Infinity Overflow Inexact Rounded rovx152 divide 1E-9 9E+999999999 -> 0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rovx154 divide -1E-9 9E+999999999 -> -0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rounding: half_down rovx160 multiply 10 9E+999999999 -> Infinity Overflow Inexact Rounded rovx161 multiply -10 9E+999999999 -> -Infinity Overflow Inexact Rounded rovx162 divide 1E-9 9E+999999999 -> 0E-1000000003 Underflow Subnormal Inexact Rounded Clamped rovx164 divide -1E-9 9E+999999999 -> -0E-1000000003 Underflow Subnormal Inexact Rounded Clamped -- check maximum finite value over a range of precisions rounding: down precision: 1 rovx200 multiply 10 9E+999999999 -> 9E+999999999 Overflow Inexact Rounded rovx201 multiply -10 9E+999999999 -> -9E+999999999 Overflow Inexact Rounded precision: 2 rovx210 multiply 10 9E+999999999 -> 9.9E+999999999 Overflow Inexact Rounded rovx211 multiply -10 9E+999999999 -> -9.9E+999999999 Overflow Inexact Rounded precision: 3 rovx220 multiply 10 9E+999999999 -> 9.99E+999999999 Overflow Inexact Rounded rovx221 multiply -10 9E+999999999 -> -9.99E+999999999 Overflow Inexact Rounded precision: 4 rovx230 multiply 10 9E+999999999 -> 9.999E+999999999 Overflow Inexact Rounded rovx231 multiply -10 9E+999999999 -> -9.999E+999999999 Overflow Inexact Rounded precision: 5 rovx240 multiply 10 9E+999999999 -> 9.9999E+999999999 Overflow Inexact Rounded rovx241 multiply -10 9E+999999999 -> -9.9999E+999999999 Overflow Inexact Rounded precision: 6 rovx250 multiply 10 9E+999999999 -> 9.99999E+999999999 Overflow Inexact Rounded rovx251 multiply -10 9E+999999999 -> -9.99999E+999999999 Overflow Inexact Rounded precision: 7 rovx260 multiply 10 9E+999999999 -> 9.999999E+999999999 Overflow Inexact Rounded rovx261 multiply -10 9E+999999999 -> -9.999999E+999999999 Overflow Inexact Rounded precision: 8 rovx270 multiply 10 9E+999999999 -> 9.9999999E+999999999 Overflow Inexact Rounded rovx271 multiply -10 9E+999999999 -> -9.9999999E+999999999 Overflow Inexact Rounded precision: 9 rovx280 multiply 10 9E+999999999 -> 9.99999999E+999999999 Overflow Inexact Rounded rovx281 multiply -10 9E+999999999 -> -9.99999999E+999999999 Overflow Inexact Rounded precision: 10 rovx290 multiply 10 9E+999999999 -> 9.999999999E+999999999 Overflow Inexact Rounded rovx291 multiply -10 9E+999999999 -> -9.999999999E+999999999 Overflow Inexact Rounded -- reprise rounding mode effect (using multiplies so precision directive used) precision: 9 maxexponent: 999999999 rounding: half_up rmex400 multiply -9.999E+999999999 10 -> -Infinity Overflow Inexact Rounded rmex401 multiply 9.999E+999999999 10 -> Infinity Overflow Inexact Rounded rounding: half_down rmex402 multiply -9.999E+999999999 10 -> -Infinity Overflow Inexact Rounded rmex403 multiply 9.999E+999999999 10 -> Infinity Overflow Inexact Rounded rounding: half_even rmex404 multiply -9.999E+999999999 10 -> -Infinity Overflow Inexact Rounded rmex405 multiply 9.999E+999999999 10 -> Infinity Overflow Inexact Rounded rounding: floor rmex406 multiply -9.999E+999999999 10 -> -Infinity Overflow Inexact Rounded rmex407 multiply 9.999E+999999999 10 -> 9.99999999E+999999999 Overflow Inexact Rounded rounding: ceiling rmex408 multiply -9.999E+999999999 10 -> -9.99999999E+999999999 Overflow Inexact Rounded rmex409 multiply 9.999E+999999999 10 -> Infinity Overflow Inexact Rounded rounding: up rmex410 multiply -9.999E+999999999 10 -> -Infinity Overflow Inexact Rounded rmex411 multiply 9.999E+999999999 10 -> Infinity Overflow Inexact Rounded rounding: down rmex412 multiply -9.999E+999999999 10 -> -9.99999999E+999999999 Overflow Inexact Rounded rmex413 multiply 9.999E+999999999 10 -> 9.99999999E+999999999 Overflow Inexact Rounded ----- Round-for-reround ----- rounding: 05up precision: 5 -- for easier visual inspection maxExponent: 999 minexponent: -999 -- basic rounding; really is just 0 and 5 up r05up001 add 12340 0.001 -> 12341 Inexact Rounded r05up002 add 12341 0.001 -> 12341 Inexact Rounded r05up003 add 12342 0.001 -> 12342 Inexact Rounded r05up004 add 12343 0.001 -> 12343 Inexact Rounded r05up005 add 12344 0.001 -> 12344 Inexact Rounded r05up006 add 12345 0.001 -> 12346 Inexact Rounded r05up007 add 12346 0.001 -> 12346 Inexact Rounded r05up008 add 12347 0.001 -> 12347 Inexact Rounded r05up009 add 12348 0.001 -> 12348 Inexact Rounded r05up010 add 12349 0.001 -> 12349 Inexact Rounded r05up011 add 12340 0.000 -> 12340 Rounded r05up012 add 12341 0.000 -> 12341 Rounded r05up013 add 12342 0.000 -> 12342 Rounded r05up014 add 12343 0.000 -> 12343 Rounded r05up015 add 12344 0.000 -> 12344 Rounded r05up016 add 12345 0.000 -> 12345 Rounded r05up017 add 12346 0.000 -> 12346 Rounded r05up018 add 12347 0.000 -> 12347 Rounded r05up019 add 12348 0.000 -> 12348 Rounded r05up020 add 12349 0.000 -> 12349 Rounded r05up021 add 12340 0.901 -> 12341 Inexact Rounded r05up022 add 12341 0.901 -> 12341 Inexact Rounded r05up023 add 12342 0.901 -> 12342 Inexact Rounded r05up024 add 12343 0.901 -> 12343 Inexact Rounded r05up025 add 12344 0.901 -> 12344 Inexact Rounded r05up026 add 12345 0.901 -> 12346 Inexact Rounded r05up027 add 12346 0.901 -> 12346 Inexact Rounded r05up028 add 12347 0.901 -> 12347 Inexact Rounded r05up029 add 12348 0.901 -> 12348 Inexact Rounded r05up030 add 12349 0.901 -> 12349 Inexact Rounded r05up031 add -12340 -0.001 -> -12341 Inexact Rounded r05up032 add -12341 -0.001 -> -12341 Inexact Rounded r05up033 add -12342 -0.001 -> -12342 Inexact Rounded r05up034 add -12343 -0.001 -> -12343 Inexact Rounded r05up035 add -12344 -0.001 -> -12344 Inexact Rounded r05up036 add -12345 -0.001 -> -12346 Inexact Rounded r05up037 add -12346 -0.001 -> -12346 Inexact Rounded r05up038 add -12347 -0.001 -> -12347 Inexact Rounded r05up039 add -12348 -0.001 -> -12348 Inexact Rounded r05up040 add -12349 -0.001 -> -12349 Inexact Rounded r05up041 add -12340 0.001 -> -12339 Inexact Rounded r05up042 add -12341 0.001 -> -12341 Inexact Rounded r05up043 add -12342 0.001 -> -12341 Inexact Rounded r05up044 add -12343 0.001 -> -12342 Inexact Rounded r05up045 add -12344 0.001 -> -12343 Inexact Rounded r05up046 add -12345 0.001 -> -12344 Inexact Rounded r05up047 add -12346 0.001 -> -12346 Inexact Rounded r05up048 add -12347 0.001 -> -12346 Inexact Rounded r05up049 add -12348 0.001 -> -12347 Inexact Rounded r05up050 add -12349 0.001 -> -12348 Inexact Rounded -- Addition operators ------------------------------------------------- -- [The first few of these check negative residue possibilities; these -- cases may be implemented as a negative residue in fastpaths] r0adx100 add 12345 -0.1 -> 12344 Inexact Rounded r0adx101 add 12345 -0.01 -> 12344 Inexact Rounded r0adx102 add 12345 -0.001 -> 12344 Inexact Rounded r0adx103 add 12345 -0.00001 -> 12344 Inexact Rounded r0adx104 add 12345 -0.000001 -> 12344 Inexact Rounded r0adx105 add 12345 -0.0000001 -> 12344 Inexact Rounded r0adx106 add 12345 0 -> 12345 r0adx107 add 12345 0.0000001 -> 12346 Inexact Rounded r0adx108 add 12345 0.000001 -> 12346 Inexact Rounded r0adx109 add 12345 0.00001 -> 12346 Inexact Rounded r0adx110 add 12345 0.0001 -> 12346 Inexact Rounded r0adx111 add 12345 0.001 -> 12346 Inexact Rounded r0adx112 add 12345 0.01 -> 12346 Inexact Rounded r0adx113 add 12345 0.1 -> 12346 Inexact Rounded r0adx115 add 12346 0.49999 -> 12346 Inexact Rounded r0adx116 add 12346 0.5 -> 12346 Inexact Rounded r0adx117 add 12346 0.50001 -> 12346 Inexact Rounded r0adx120 add 12345 0.4 -> 12346 Inexact Rounded r0adx121 add 12345 0.49 -> 12346 Inexact Rounded r0adx122 add 12345 0.499 -> 12346 Inexact Rounded r0adx123 add 12345 0.49999 -> 12346 Inexact Rounded r0adx124 add 12345 0.5 -> 12346 Inexact Rounded r0adx125 add 12345 0.50001 -> 12346 Inexact Rounded r0adx126 add 12345 0.5001 -> 12346 Inexact Rounded r0adx127 add 12345 0.501 -> 12346 Inexact Rounded r0adx128 add 12345 0.51 -> 12346 Inexact Rounded r0adx129 add 12345 0.6 -> 12346 Inexact Rounded -- negatives... r0sux100 add -12345 -0.1 -> -12346 Inexact Rounded r0sux101 add -12345 -0.01 -> -12346 Inexact Rounded r0sux102 add -12345 -0.001 -> -12346 Inexact Rounded r0sux103 add -12345 -0.00001 -> -12346 Inexact Rounded r0sux104 add -12345 -0.000001 -> -12346 Inexact Rounded r0sux105 add -12345 -0.0000001 -> -12346 Inexact Rounded r0sux106 add -12345 0 -> -12345 r0sux107 add -12345 0.0000001 -> -12344 Inexact Rounded r0sux108 add -12345 0.000001 -> -12344 Inexact Rounded r0sux109 add -12345 0.00001 -> -12344 Inexact Rounded r0sux110 add -12345 0.0001 -> -12344 Inexact Rounded r0sux111 add -12345 0.001 -> -12344 Inexact Rounded r0sux112 add -12345 0.01 -> -12344 Inexact Rounded r0sux113 add -12345 0.1 -> -12344 Inexact Rounded r0sux115 add -12346 0.49999 -> -12346 Inexact Rounded r0sux116 add -12346 0.5 -> -12346 Inexact Rounded r0sux117 add -12346 0.50001 -> -12346 Inexact Rounded r0sux120 add -12345 0.4 -> -12344 Inexact Rounded r0sux121 add -12345 0.49 -> -12344 Inexact Rounded r0sux122 add -12345 0.499 -> -12344 Inexact Rounded r0sux123 add -12345 0.49999 -> -12344 Inexact Rounded r0sux124 add -12345 0.5 -> -12344 Inexact Rounded r0sux125 add -12345 0.50001 -> -12344 Inexact Rounded r0sux126 add -12345 0.5001 -> -12344 Inexact Rounded r0sux127 add -12345 0.501 -> -12344 Inexact Rounded r0sux128 add -12345 0.51 -> -12344 Inexact Rounded r0sux129 add -12345 0.6 -> -12344 Inexact Rounded -- Check cancellation subtractions -- (The IEEE 854 'curious rule' in $6.3) r0zex001 add 0 0 -> 0 r0zex002 add 0 -0 -> 0 r0zex003 add -0 0 -> 0 r0zex004 add -0 -0 -> -0 r0zex005 add 1 -1 -> 0 r0zex006 add -1 1 -> 0 r0zex007 add 1.5 -1.5 -> 0.0 r0zex008 add -1.5 1.5 -> 0.0 r0zex009 add 2 -2 -> 0 r0zex010 add -2 2 -> 0 -- Division operators ------------------------------------------------- r0dvx101 divide 12345 1 -> 12345 r0dvx102 divide 12345 1.0001 -> 12343 Inexact Rounded r0dvx103 divide 12345 1.001 -> 12332 Inexact Rounded r0dvx104 divide 12345 1.01 -> 12222 Inexact Rounded r0dvx105 divide 12345 1.1 -> 11222 Inexact Rounded r0dvx106 divide 12355 4 -> 3088.7 Inexact Rounded r0dvx107 divide 12345 4 -> 3086.2 Inexact Rounded r0dvx108 divide 12355 4.0001 -> 3088.6 Inexact Rounded r0dvx109 divide 12345 4.0001 -> 3086.1 Inexact Rounded r0dvx110 divide 12345 4.9 -> 2519.3 Inexact Rounded r0dvx111 divide 12345 4.99 -> 2473.9 Inexact Rounded r0dvx112 divide 12345 4.999 -> 2469.4 Inexact Rounded r0dvx113 divide 12345 4.9999 -> 2469.1 Inexact Rounded r0dvx114 divide 12345 5 -> 2469 r0dvx115 divide 12345 5.0001 -> 2468.9 Inexact Rounded r0dvx116 divide 12345 5.001 -> 2468.6 Inexact Rounded r0dvx117 divide 12345 5.01 -> 2464.1 Inexact Rounded r0dvx118 divide 12345 5.1 -> 2420.6 Inexact Rounded -- [divideInteger and remainder unaffected] -- Multiplication operator -------------------------------------------- r0mux101 multiply 12345 1 -> 12345 r0mux102 multiply 12345 1.0001 -> 12346 Inexact Rounded r0mux103 multiply 12345 1.001 -> 12357 Inexact Rounded r0mux104 multiply 12345 1.01 -> 12468 Inexact Rounded r0mux105 multiply 12345 1.1 -> 13579 Inexact Rounded r0mux106 multiply 12345 4 -> 49380 r0mux107 multiply 12345 4.0001 -> 49381 Inexact Rounded r0mux108 multiply 12345 4.9 -> 60491 Inexact Rounded r0mux109 multiply 12345 4.99 -> 61601 Inexact Rounded r0mux110 multiply 12345 4.999 -> 61712 Inexact Rounded r0mux111 multiply 12345 4.9999 -> 61723 Inexact Rounded r0mux112 multiply 12345 5 -> 61725 r0mux113 multiply 12345 5.0001 -> 61726 Inexact Rounded r0mux114 multiply 12345 5.001 -> 61737 Inexact Rounded r0mux115 multiply 12345 5.01 -> 61848 Inexact Rounded r0mux116 multiply 12345 12 -> 1.4814E+5 Rounded r0mux117 multiply 12345 13 -> 1.6048E+5 Inexact Rounded r0mux118 multiply 12355 12 -> 1.4826E+5 Rounded r0mux119 multiply 12355 13 -> 1.6061E+5 Inexact Rounded -- Power operator ----------------------------------------------------- r0pox101 power 12345 -5 -> 3.4877E-21 Inexact Rounded r0pox102 power 12345 -4 -> 4.3056E-17 Inexact Rounded r0pox103 power 12345 -3 -> 5.3152E-13 Inexact Rounded r0pox104 power 12345 -2 -> 6.5617E-9 Inexact Rounded r0pox105 power 12345 -1 -> 0.000081004 Inexact Rounded r0pox106 power 12345 0 -> 1 r0pox107 power 12345 1 -> 12345 r0pox108 power 12345 2 -> 1.5239E+8 Inexact Rounded r0pox109 power 12345 3 -> 1.8813E+12 Inexact Rounded r0pox110 power 12345 4 -> 2.3226E+16 Inexact Rounded r0pox111 power 12345 5 -> 2.8671E+20 Inexact Rounded r0pox112 power 415 2 -> 1.7222E+5 Inexact Rounded r0pox113 power 75 3 -> 4.2187E+5 Inexact Rounded -- Underflow Subnormal and overflow values vary with rounding mode and sign maxexponent: 999999999 minexponent: -999999999 -- [round down gives Nmax on first two and .0E... on the next two] r0ovx100 multiply 10 9E+999999999 -> 9.9999E+999999999 Overflow Inexact Rounded r0ovx101 multiply -10 9E+999999999 -> -9.9999E+999999999 Overflow Inexact Rounded r0ovx102 divide 1E-9 9E+999999999 -> 1E-1000000003 Underflow Subnormal Inexact Rounded r0ovx104 divide -1E-9 9E+999999999 -> -1E-1000000003 Underflow Subnormal Inexact Rounded -- reprise rounding mode effect (using multiplies so precision directive used) precision: 9 maxexponent: 999999999 r0mex412 multiply -9.999E+999999999 10 -> -9.99999999E+999999999 Overflow Inexact Rounded r0mex413 multiply 9.999E+999999999 10 -> 9.99999999E+999999999 Overflow Inexact Rounded apd-3.2.1/testdata/squareroot.decTest000066400000000000000000005771731450022325000176300ustar00rootroot00000000000000------------------------------------------------------------------------ -- squareroot.decTest -- decimal square root -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 -- basics sqtx001 squareroot 1 -> 1 sqtx002 squareroot -1 -> NaN Invalid_operation sqtx003 squareroot 1.00 -> 1.0 sqtx004 squareroot -1.00 -> NaN Invalid_operation sqtx005 squareroot 0 -> 0 sqtx006 squareroot 00.0 -> 0.0 sqtx007 squareroot 0.00 -> 0.0 sqtx008 squareroot 00.00 -> 0.0 sqtx009 squareroot 00.000 -> 0.00 sqtx010 squareroot 00.0000 -> 0.00 sqtx011 squareroot 00 -> 0 sqtx012 squareroot -2 -> NaN Invalid_operation sqtx013 squareroot 2 -> 1.41421356 Inexact Rounded sqtx014 squareroot -2.00 -> NaN Invalid_operation sqtx015 squareroot 2.00 -> 1.41421356 Inexact Rounded sqtx016 squareroot -0 -> -0 sqtx017 squareroot -0.0 -> -0.0 sqtx018 squareroot -00.00 -> -0.0 sqtx019 squareroot -00.000 -> -0.00 sqtx020 squareroot -0.0000 -> -0.00 sqtx021 squareroot -0E+9 -> -0E+4 sqtx022 squareroot -0E+10 -> -0E+5 sqtx023 squareroot -0E+11 -> -0E+5 sqtx024 squareroot -0E+12 -> -0E+6 sqtx025 squareroot -00 -> -0 sqtx026 squareroot 0E+5 -> 0E+2 sqtx027 squareroot 4.0 -> 2.0 sqtx028 squareroot 4.00 -> 2.0 sqtx030 squareroot +0.1 -> 0.316227766 Inexact Rounded sqtx031 squareroot -0.1 -> NaN Invalid_operation sqtx032 squareroot +0.01 -> 0.1 sqtx033 squareroot -0.01 -> NaN Invalid_operation sqtx034 squareroot +0.001 -> 0.0316227766 Inexact Rounded sqtx035 squareroot -0.001 -> NaN Invalid_operation sqtx036 squareroot +0.000001 -> 0.001 sqtx037 squareroot -0.000001 -> NaN Invalid_operation sqtx038 squareroot +0.000000000001 -> 0.000001 sqtx039 squareroot -0.000000000001 -> NaN Invalid_operation sqtx041 squareroot 1.1 -> 1.04880885 Inexact Rounded sqtx042 squareroot 1.10 -> 1.04880885 Inexact Rounded sqtx043 squareroot 1.100 -> 1.04880885 Inexact Rounded sqtx044 squareroot 1.110 -> 1.05356538 Inexact Rounded sqtx045 squareroot -1.1 -> NaN Invalid_operation sqtx046 squareroot -1.10 -> NaN Invalid_operation sqtx047 squareroot -1.100 -> NaN Invalid_operation sqtx048 squareroot -1.110 -> NaN Invalid_operation sqtx049 squareroot 9.9 -> 3.14642654 Inexact Rounded sqtx050 squareroot 9.90 -> 3.14642654 Inexact Rounded sqtx051 squareroot 9.900 -> 3.14642654 Inexact Rounded sqtx052 squareroot 9.990 -> 3.16069613 Inexact Rounded sqtx053 squareroot -9.9 -> NaN Invalid_operation sqtx054 squareroot -9.90 -> NaN Invalid_operation sqtx055 squareroot -9.900 -> NaN Invalid_operation sqtx056 squareroot -9.990 -> NaN Invalid_operation sqtx060 squareroot 1 -> 1 sqtx061 squareroot 1.0 -> 1.0 sqtx062 squareroot 1.00 -> 1.0 sqtx063 squareroot 10.0 -> 3.16227766 Inexact Rounded sqtx064 squareroot 10.0 -> 3.16227766 Inexact Rounded sqtx065 squareroot 10.0 -> 3.16227766 Inexact Rounded sqtx066 squareroot 10.00 -> 3.16227766 Inexact Rounded sqtx067 squareroot 100 -> 10 sqtx068 squareroot 100.0 -> 10.0 sqtx069 squareroot 100.00 -> 10.0 sqtx070 squareroot 1.1000E+3 -> 33.1662479 Inexact Rounded sqtx071 squareroot 1.10000E+3 -> 33.1662479 Inexact Rounded sqtx072 squareroot -10.0 -> NaN Invalid_operation sqtx073 squareroot -10.00 -> NaN Invalid_operation sqtx074 squareroot -100.0 -> NaN Invalid_operation sqtx075 squareroot -100.00 -> NaN Invalid_operation sqtx076 squareroot -1.1000E+3 -> NaN Invalid_operation sqtx077 squareroot -1.10000E+3 -> NaN Invalid_operation sqtx078 squareroot 1.000 -> 1.00 sqtx079 squareroot 1.0000 -> 1.00 -- famous squares sqtx080 squareroot 1 -> 1 sqtx081 squareroot 4 -> 2 sqtx082 squareroot 9 -> 3 sqtx083 squareroot 16 -> 4 sqtx084 squareroot 25 -> 5 sqtx085 squareroot 36 -> 6 sqtx086 squareroot 49 -> 7 sqtx087 squareroot 64 -> 8 sqtx088 squareroot 81 -> 9 sqtx089 squareroot 100 -> 10 sqtx090 squareroot 121 -> 11 sqtx091 squareroot 144 -> 12 sqtx092 squareroot 169 -> 13 sqtx093 squareroot 256 -> 16 sqtx094 squareroot 1024 -> 32 sqtx095 squareroot 4096 -> 64 sqtx100 squareroot 0.01 -> 0.1 sqtx101 squareroot 0.04 -> 0.2 sqtx102 squareroot 0.09 -> 0.3 sqtx103 squareroot 0.16 -> 0.4 sqtx104 squareroot 0.25 -> 0.5 sqtx105 squareroot 0.36 -> 0.6 sqtx106 squareroot 0.49 -> 0.7 sqtx107 squareroot 0.64 -> 0.8 sqtx108 squareroot 0.81 -> 0.9 sqtx109 squareroot 1.00 -> 1.0 sqtx110 squareroot 1.21 -> 1.1 sqtx111 squareroot 1.44 -> 1.2 sqtx112 squareroot 1.69 -> 1.3 sqtx113 squareroot 2.56 -> 1.6 sqtx114 squareroot 10.24 -> 3.2 sqtx115 squareroot 40.96 -> 6.4 -- Precision 1 squareroot tests [exhaustive, plus exponent adjusts] rounding: half_even maxExponent: 999 minexponent: -999 precision: 1 sqtx1201 squareroot 0.1 -> 0.3 Inexact Rounded sqtx1202 squareroot 0.01 -> 0.1 sqtx1203 squareroot 1.0E-1 -> 0.3 Inexact Rounded sqtx1204 squareroot 1.00E-2 -> 0.1 Rounded sqtx1205 squareroot 1E-3 -> 0.03 Inexact Rounded sqtx1206 squareroot 1E+1 -> 3 Inexact Rounded sqtx1207 squareroot 1E+2 -> 1E+1 sqtx1208 squareroot 1E+3 -> 3E+1 Inexact Rounded sqtx1209 squareroot 0.2 -> 0.4 Inexact Rounded sqtx1210 squareroot 0.02 -> 0.1 Inexact Rounded sqtx1211 squareroot 2.0E-1 -> 0.4 Inexact Rounded sqtx1212 squareroot 2.00E-2 -> 0.1 Inexact Rounded sqtx1213 squareroot 2E-3 -> 0.04 Inexact Rounded sqtx1214 squareroot 2E+1 -> 4 Inexact Rounded sqtx1215 squareroot 2E+2 -> 1E+1 Inexact Rounded sqtx1216 squareroot 2E+3 -> 4E+1 Inexact Rounded sqtx1217 squareroot 0.3 -> 0.5 Inexact Rounded sqtx1218 squareroot 0.03 -> 0.2 Inexact Rounded sqtx1219 squareroot 3.0E-1 -> 0.5 Inexact Rounded sqtx1220 squareroot 3.00E-2 -> 0.2 Inexact Rounded sqtx1221 squareroot 3E-3 -> 0.05 Inexact Rounded sqtx1222 squareroot 3E+1 -> 5 Inexact Rounded sqtx1223 squareroot 3E+2 -> 2E+1 Inexact Rounded sqtx1224 squareroot 3E+3 -> 5E+1 Inexact Rounded sqtx1225 squareroot 0.4 -> 0.6 Inexact Rounded sqtx1226 squareroot 0.04 -> 0.2 sqtx1227 squareroot 4.0E-1 -> 0.6 Inexact Rounded sqtx1228 squareroot 4.00E-2 -> 0.2 Rounded sqtx1229 squareroot 4E-3 -> 0.06 Inexact Rounded sqtx1230 squareroot 4E+1 -> 6 Inexact Rounded sqtx1231 squareroot 4E+2 -> 2E+1 sqtx1232 squareroot 4E+3 -> 6E+1 Inexact Rounded sqtx1233 squareroot 0.5 -> 0.7 Inexact Rounded sqtx1234 squareroot 0.05 -> 0.2 Inexact Rounded sqtx1235 squareroot 5.0E-1 -> 0.7 Inexact Rounded sqtx1236 squareroot 5.00E-2 -> 0.2 Inexact Rounded sqtx1237 squareroot 5E-3 -> 0.07 Inexact Rounded sqtx1238 squareroot 5E+1 -> 7 Inexact Rounded sqtx1239 squareroot 5E+2 -> 2E+1 Inexact Rounded sqtx1240 squareroot 5E+3 -> 7E+1 Inexact Rounded sqtx1241 squareroot 0.6 -> 0.8 Inexact Rounded sqtx1242 squareroot 0.06 -> 0.2 Inexact Rounded sqtx1243 squareroot 6.0E-1 -> 0.8 Inexact Rounded sqtx1244 squareroot 6.00E-2 -> 0.2 Inexact Rounded sqtx1245 squareroot 6E-3 -> 0.08 Inexact Rounded sqtx1246 squareroot 6E+1 -> 8 Inexact Rounded sqtx1247 squareroot 6E+2 -> 2E+1 Inexact Rounded sqtx1248 squareroot 6E+3 -> 8E+1 Inexact Rounded sqtx1249 squareroot 0.7 -> 0.8 Inexact Rounded sqtx1250 squareroot 0.07 -> 0.3 Inexact Rounded sqtx1251 squareroot 7.0E-1 -> 0.8 Inexact Rounded sqtx1252 squareroot 7.00E-2 -> 0.3 Inexact Rounded sqtx1253 squareroot 7E-3 -> 0.08 Inexact Rounded sqtx1254 squareroot 7E+1 -> 8 Inexact Rounded sqtx1255 squareroot 7E+2 -> 3E+1 Inexact Rounded sqtx1256 squareroot 7E+3 -> 8E+1 Inexact Rounded sqtx1257 squareroot 0.8 -> 0.9 Inexact Rounded sqtx1258 squareroot 0.08 -> 0.3 Inexact Rounded sqtx1259 squareroot 8.0E-1 -> 0.9 Inexact Rounded sqtx1260 squareroot 8.00E-2 -> 0.3 Inexact Rounded sqtx1261 squareroot 8E-3 -> 0.09 Inexact Rounded sqtx1262 squareroot 8E+1 -> 9 Inexact Rounded sqtx1263 squareroot 8E+2 -> 3E+1 Inexact Rounded sqtx1264 squareroot 8E+3 -> 9E+1 Inexact Rounded sqtx1265 squareroot 0.9 -> 0.9 Inexact Rounded sqtx1266 squareroot 0.09 -> 0.3 sqtx1267 squareroot 9.0E-1 -> 0.9 Inexact Rounded sqtx1268 squareroot 9.00E-2 -> 0.3 Rounded sqtx1269 squareroot 9E-3 -> 0.09 Inexact Rounded sqtx1270 squareroot 9E+1 -> 9 Inexact Rounded sqtx1271 squareroot 9E+2 -> 3E+1 sqtx1272 squareroot 9E+3 -> 9E+1 Inexact Rounded -- Precision 2 squareroot tests [exhaustive, plus exponent adjusts] rounding: half_even maxExponent: 999 minexponent: -999 precision: 2 sqtx2201 squareroot 0.1 -> 0.32 Inexact Rounded sqtx2202 squareroot 0.01 -> 0.1 sqtx2203 squareroot 1.0E-1 -> 0.32 Inexact Rounded sqtx2204 squareroot 1.00E-2 -> 0.10 sqtx2205 squareroot 1E-3 -> 0.032 Inexact Rounded sqtx2206 squareroot 1E+1 -> 3.2 Inexact Rounded sqtx2207 squareroot 1E+2 -> 1E+1 sqtx2208 squareroot 1E+3 -> 32 Inexact Rounded sqtx2209 squareroot 0.2 -> 0.45 Inexact Rounded sqtx2210 squareroot 0.02 -> 0.14 Inexact Rounded sqtx2211 squareroot 2.0E-1 -> 0.45 Inexact Rounded sqtx2212 squareroot 2.00E-2 -> 0.14 Inexact Rounded sqtx2213 squareroot 2E-3 -> 0.045 Inexact Rounded sqtx2214 squareroot 2E+1 -> 4.5 Inexact Rounded sqtx2215 squareroot 2E+2 -> 14 Inexact Rounded sqtx2216 squareroot 2E+3 -> 45 Inexact Rounded sqtx2217 squareroot 0.3 -> 0.55 Inexact Rounded sqtx2218 squareroot 0.03 -> 0.17 Inexact Rounded sqtx2219 squareroot 3.0E-1 -> 0.55 Inexact Rounded sqtx2220 squareroot 3.00E-2 -> 0.17 Inexact Rounded sqtx2221 squareroot 3E-3 -> 0.055 Inexact Rounded sqtx2222 squareroot 3E+1 -> 5.5 Inexact Rounded sqtx2223 squareroot 3E+2 -> 17 Inexact Rounded sqtx2224 squareroot 3E+3 -> 55 Inexact Rounded sqtx2225 squareroot 0.4 -> 0.63 Inexact Rounded sqtx2226 squareroot 0.04 -> 0.2 sqtx2227 squareroot 4.0E-1 -> 0.63 Inexact Rounded sqtx2228 squareroot 4.00E-2 -> 0.20 sqtx2229 squareroot 4E-3 -> 0.063 Inexact Rounded sqtx2230 squareroot 4E+1 -> 6.3 Inexact Rounded sqtx2231 squareroot 4E+2 -> 2E+1 sqtx2232 squareroot 4E+3 -> 63 Inexact Rounded sqtx2233 squareroot 0.5 -> 0.71 Inexact Rounded sqtx2234 squareroot 0.05 -> 0.22 Inexact Rounded sqtx2235 squareroot 5.0E-1 -> 0.71 Inexact Rounded sqtx2236 squareroot 5.00E-2 -> 0.22 Inexact Rounded sqtx2237 squareroot 5E-3 -> 0.071 Inexact Rounded sqtx2238 squareroot 5E+1 -> 7.1 Inexact Rounded sqtx2239 squareroot 5E+2 -> 22 Inexact Rounded sqtx2240 squareroot 5E+3 -> 71 Inexact Rounded sqtx2241 squareroot 0.6 -> 0.77 Inexact Rounded sqtx2242 squareroot 0.06 -> 0.24 Inexact Rounded sqtx2243 squareroot 6.0E-1 -> 0.77 Inexact Rounded sqtx2244 squareroot 6.00E-2 -> 0.24 Inexact Rounded sqtx2245 squareroot 6E-3 -> 0.077 Inexact Rounded sqtx2246 squareroot 6E+1 -> 7.7 Inexact Rounded sqtx2247 squareroot 6E+2 -> 24 Inexact Rounded sqtx2248 squareroot 6E+3 -> 77 Inexact Rounded sqtx2249 squareroot 0.7 -> 0.84 Inexact Rounded sqtx2250 squareroot 0.07 -> 0.26 Inexact Rounded sqtx2251 squareroot 7.0E-1 -> 0.84 Inexact Rounded sqtx2252 squareroot 7.00E-2 -> 0.26 Inexact Rounded sqtx2253 squareroot 7E-3 -> 0.084 Inexact Rounded sqtx2254 squareroot 7E+1 -> 8.4 Inexact Rounded sqtx2255 squareroot 7E+2 -> 26 Inexact Rounded sqtx2256 squareroot 7E+3 -> 84 Inexact Rounded sqtx2257 squareroot 0.8 -> 0.89 Inexact Rounded sqtx2258 squareroot 0.08 -> 0.28 Inexact Rounded sqtx2259 squareroot 8.0E-1 -> 0.89 Inexact Rounded sqtx2260 squareroot 8.00E-2 -> 0.28 Inexact Rounded sqtx2261 squareroot 8E-3 -> 0.089 Inexact Rounded sqtx2262 squareroot 8E+1 -> 8.9 Inexact Rounded sqtx2263 squareroot 8E+2 -> 28 Inexact Rounded sqtx2264 squareroot 8E+3 -> 89 Inexact Rounded sqtx2265 squareroot 0.9 -> 0.95 Inexact Rounded sqtx2266 squareroot 0.09 -> 0.3 sqtx2267 squareroot 9.0E-1 -> 0.95 Inexact Rounded sqtx2268 squareroot 9.00E-2 -> 0.30 sqtx2269 squareroot 9E-3 -> 0.095 Inexact Rounded sqtx2270 squareroot 9E+1 -> 9.5 Inexact Rounded sqtx2271 squareroot 9E+2 -> 3E+1 sqtx2272 squareroot 9E+3 -> 95 Inexact Rounded sqtx2273 squareroot 0.10 -> 0.32 Inexact Rounded sqtx2274 squareroot 0.010 -> 0.10 sqtx2275 squareroot 10.0E-1 -> 1.0 sqtx2276 squareroot 10.00E-2 -> 0.32 Inexact Rounded sqtx2277 squareroot 10E-3 -> 0.10 sqtx2278 squareroot 10E+1 -> 10 sqtx2279 squareroot 10E+2 -> 32 Inexact Rounded sqtx2280 squareroot 10E+3 -> 1.0E+2 sqtx2281 squareroot 0.11 -> 0.33 Inexact Rounded sqtx2282 squareroot 0.011 -> 0.10 Inexact Rounded sqtx2283 squareroot 11.0E-1 -> 1.0 Inexact Rounded sqtx2284 squareroot 11.00E-2 -> 0.33 Inexact Rounded sqtx2285 squareroot 11E-3 -> 0.10 Inexact Rounded sqtx2286 squareroot 11E+1 -> 10 Inexact Rounded sqtx2287 squareroot 11E+2 -> 33 Inexact Rounded sqtx2288 squareroot 11E+3 -> 1.0E+2 Inexact Rounded sqtx2289 squareroot 0.12 -> 0.35 Inexact Rounded sqtx2290 squareroot 0.012 -> 0.11 Inexact Rounded sqtx2291 squareroot 12.0E-1 -> 1.1 Inexact Rounded sqtx2292 squareroot 12.00E-2 -> 0.35 Inexact Rounded sqtx2293 squareroot 12E-3 -> 0.11 Inexact Rounded sqtx2294 squareroot 12E+1 -> 11 Inexact Rounded sqtx2295 squareroot 12E+2 -> 35 Inexact Rounded sqtx2296 squareroot 12E+3 -> 1.1E+2 Inexact Rounded sqtx2297 squareroot 0.13 -> 0.36 Inexact Rounded sqtx2298 squareroot 0.013 -> 0.11 Inexact Rounded sqtx2299 squareroot 13.0E-1 -> 1.1 Inexact Rounded sqtx2300 squareroot 13.00E-2 -> 0.36 Inexact Rounded sqtx2301 squareroot 13E-3 -> 0.11 Inexact Rounded sqtx2302 squareroot 13E+1 -> 11 Inexact Rounded sqtx2303 squareroot 13E+2 -> 36 Inexact Rounded sqtx2304 squareroot 13E+3 -> 1.1E+2 Inexact Rounded sqtx2305 squareroot 0.14 -> 0.37 Inexact Rounded sqtx2306 squareroot 0.014 -> 0.12 Inexact Rounded sqtx2307 squareroot 14.0E-1 -> 1.2 Inexact Rounded sqtx2308 squareroot 14.00E-2 -> 0.37 Inexact Rounded sqtx2309 squareroot 14E-3 -> 0.12 Inexact Rounded sqtx2310 squareroot 14E+1 -> 12 Inexact Rounded sqtx2311 squareroot 14E+2 -> 37 Inexact Rounded sqtx2312 squareroot 14E+3 -> 1.2E+2 Inexact Rounded sqtx2313 squareroot 0.15 -> 0.39 Inexact Rounded sqtx2314 squareroot 0.015 -> 0.12 Inexact Rounded sqtx2315 squareroot 15.0E-1 -> 1.2 Inexact Rounded sqtx2316 squareroot 15.00E-2 -> 0.39 Inexact Rounded sqtx2317 squareroot 15E-3 -> 0.12 Inexact Rounded sqtx2318 squareroot 15E+1 -> 12 Inexact Rounded sqtx2319 squareroot 15E+2 -> 39 Inexact Rounded sqtx2320 squareroot 15E+3 -> 1.2E+2 Inexact Rounded sqtx2321 squareroot 0.16 -> 0.4 sqtx2322 squareroot 0.016 -> 0.13 Inexact Rounded sqtx2323 squareroot 16.0E-1 -> 1.3 Inexact Rounded sqtx2324 squareroot 16.00E-2 -> 0.40 sqtx2325 squareroot 16E-3 -> 0.13 Inexact Rounded sqtx2326 squareroot 16E+1 -> 13 Inexact Rounded sqtx2327 squareroot 16E+2 -> 4E+1 sqtx2328 squareroot 16E+3 -> 1.3E+2 Inexact Rounded sqtx2329 squareroot 0.17 -> 0.41 Inexact Rounded sqtx2330 squareroot 0.017 -> 0.13 Inexact Rounded sqtx2331 squareroot 17.0E-1 -> 1.3 Inexact Rounded sqtx2332 squareroot 17.00E-2 -> 0.41 Inexact Rounded sqtx2333 squareroot 17E-3 -> 0.13 Inexact Rounded sqtx2334 squareroot 17E+1 -> 13 Inexact Rounded sqtx2335 squareroot 17E+2 -> 41 Inexact Rounded sqtx2336 squareroot 17E+3 -> 1.3E+2 Inexact Rounded sqtx2337 squareroot 0.18 -> 0.42 Inexact Rounded sqtx2338 squareroot 0.018 -> 0.13 Inexact Rounded sqtx2339 squareroot 18.0E-1 -> 1.3 Inexact Rounded sqtx2340 squareroot 18.00E-2 -> 0.42 Inexact Rounded sqtx2341 squareroot 18E-3 -> 0.13 Inexact Rounded sqtx2342 squareroot 18E+1 -> 13 Inexact Rounded sqtx2343 squareroot 18E+2 -> 42 Inexact Rounded sqtx2344 squareroot 18E+3 -> 1.3E+2 Inexact Rounded sqtx2345 squareroot 0.19 -> 0.44 Inexact Rounded sqtx2346 squareroot 0.019 -> 0.14 Inexact Rounded sqtx2347 squareroot 19.0E-1 -> 1.4 Inexact Rounded sqtx2348 squareroot 19.00E-2 -> 0.44 Inexact Rounded sqtx2349 squareroot 19E-3 -> 0.14 Inexact Rounded sqtx2350 squareroot 19E+1 -> 14 Inexact Rounded sqtx2351 squareroot 19E+2 -> 44 Inexact Rounded sqtx2352 squareroot 19E+3 -> 1.4E+2 Inexact Rounded sqtx2353 squareroot 0.20 -> 0.45 Inexact Rounded sqtx2354 squareroot 0.020 -> 0.14 Inexact Rounded sqtx2355 squareroot 20.0E-1 -> 1.4 Inexact Rounded sqtx2356 squareroot 20.00E-2 -> 0.45 Inexact Rounded sqtx2357 squareroot 20E-3 -> 0.14 Inexact Rounded sqtx2358 squareroot 20E+1 -> 14 Inexact Rounded sqtx2359 squareroot 20E+2 -> 45 Inexact Rounded sqtx2360 squareroot 20E+3 -> 1.4E+2 Inexact Rounded sqtx2361 squareroot 0.21 -> 0.46 Inexact Rounded sqtx2362 squareroot 0.021 -> 0.14 Inexact Rounded sqtx2363 squareroot 21.0E-1 -> 1.4 Inexact Rounded sqtx2364 squareroot 21.00E-2 -> 0.46 Inexact Rounded sqtx2365 squareroot 21E-3 -> 0.14 Inexact Rounded sqtx2366 squareroot 21E+1 -> 14 Inexact Rounded sqtx2367 squareroot 21E+2 -> 46 Inexact Rounded sqtx2368 squareroot 21E+3 -> 1.4E+2 Inexact Rounded sqtx2369 squareroot 0.22 -> 0.47 Inexact Rounded sqtx2370 squareroot 0.022 -> 0.15 Inexact Rounded sqtx2371 squareroot 22.0E-1 -> 1.5 Inexact Rounded sqtx2372 squareroot 22.00E-2 -> 0.47 Inexact Rounded sqtx2373 squareroot 22E-3 -> 0.15 Inexact Rounded sqtx2374 squareroot 22E+1 -> 15 Inexact Rounded sqtx2375 squareroot 22E+2 -> 47 Inexact Rounded sqtx2376 squareroot 22E+3 -> 1.5E+2 Inexact Rounded sqtx2377 squareroot 0.23 -> 0.48 Inexact Rounded sqtx2378 squareroot 0.023 -> 0.15 Inexact Rounded sqtx2379 squareroot 23.0E-1 -> 1.5 Inexact Rounded sqtx2380 squareroot 23.00E-2 -> 0.48 Inexact Rounded sqtx2381 squareroot 23E-3 -> 0.15 Inexact Rounded sqtx2382 squareroot 23E+1 -> 15 Inexact Rounded sqtx2383 squareroot 23E+2 -> 48 Inexact Rounded sqtx2384 squareroot 23E+3 -> 1.5E+2 Inexact Rounded sqtx2385 squareroot 0.24 -> 0.49 Inexact Rounded sqtx2386 squareroot 0.024 -> 0.15 Inexact Rounded sqtx2387 squareroot 24.0E-1 -> 1.5 Inexact Rounded sqtx2388 squareroot 24.00E-2 -> 0.49 Inexact Rounded sqtx2389 squareroot 24E-3 -> 0.15 Inexact Rounded sqtx2390 squareroot 24E+1 -> 15 Inexact Rounded sqtx2391 squareroot 24E+2 -> 49 Inexact Rounded sqtx2392 squareroot 24E+3 -> 1.5E+2 Inexact Rounded sqtx2393 squareroot 0.25 -> 0.5 sqtx2394 squareroot 0.025 -> 0.16 Inexact Rounded sqtx2395 squareroot 25.0E-1 -> 1.6 Inexact Rounded sqtx2396 squareroot 25.00E-2 -> 0.50 sqtx2397 squareroot 25E-3 -> 0.16 Inexact Rounded sqtx2398 squareroot 25E+1 -> 16 Inexact Rounded sqtx2399 squareroot 25E+2 -> 5E+1 sqtx2400 squareroot 25E+3 -> 1.6E+2 Inexact Rounded sqtx2401 squareroot 0.26 -> 0.51 Inexact Rounded sqtx2402 squareroot 0.026 -> 0.16 Inexact Rounded sqtx2403 squareroot 26.0E-1 -> 1.6 Inexact Rounded sqtx2404 squareroot 26.00E-2 -> 0.51 Inexact Rounded sqtx2405 squareroot 26E-3 -> 0.16 Inexact Rounded sqtx2406 squareroot 26E+1 -> 16 Inexact Rounded sqtx2407 squareroot 26E+2 -> 51 Inexact Rounded sqtx2408 squareroot 26E+3 -> 1.6E+2 Inexact Rounded sqtx2409 squareroot 0.27 -> 0.52 Inexact Rounded sqtx2410 squareroot 0.027 -> 0.16 Inexact Rounded sqtx2411 squareroot 27.0E-1 -> 1.6 Inexact Rounded sqtx2412 squareroot 27.00E-2 -> 0.52 Inexact Rounded sqtx2413 squareroot 27E-3 -> 0.16 Inexact Rounded sqtx2414 squareroot 27E+1 -> 16 Inexact Rounded sqtx2415 squareroot 27E+2 -> 52 Inexact Rounded sqtx2416 squareroot 27E+3 -> 1.6E+2 Inexact Rounded sqtx2417 squareroot 0.28 -> 0.53 Inexact Rounded sqtx2418 squareroot 0.028 -> 0.17 Inexact Rounded sqtx2419 squareroot 28.0E-1 -> 1.7 Inexact Rounded sqtx2420 squareroot 28.00E-2 -> 0.53 Inexact Rounded sqtx2421 squareroot 28E-3 -> 0.17 Inexact Rounded sqtx2422 squareroot 28E+1 -> 17 Inexact Rounded sqtx2423 squareroot 28E+2 -> 53 Inexact Rounded sqtx2424 squareroot 28E+3 -> 1.7E+2 Inexact Rounded sqtx2425 squareroot 0.29 -> 0.54 Inexact Rounded sqtx2426 squareroot 0.029 -> 0.17 Inexact Rounded sqtx2427 squareroot 29.0E-1 -> 1.7 Inexact Rounded sqtx2428 squareroot 29.00E-2 -> 0.54 Inexact Rounded sqtx2429 squareroot 29E-3 -> 0.17 Inexact Rounded sqtx2430 squareroot 29E+1 -> 17 Inexact Rounded sqtx2431 squareroot 29E+2 -> 54 Inexact Rounded sqtx2432 squareroot 29E+3 -> 1.7E+2 Inexact Rounded sqtx2433 squareroot 0.30 -> 0.55 Inexact Rounded sqtx2434 squareroot 0.030 -> 0.17 Inexact Rounded sqtx2435 squareroot 30.0E-1 -> 1.7 Inexact Rounded sqtx2436 squareroot 30.00E-2 -> 0.55 Inexact Rounded sqtx2437 squareroot 30E-3 -> 0.17 Inexact Rounded sqtx2438 squareroot 30E+1 -> 17 Inexact Rounded sqtx2439 squareroot 30E+2 -> 55 Inexact Rounded sqtx2440 squareroot 30E+3 -> 1.7E+2 Inexact Rounded sqtx2441 squareroot 0.31 -> 0.56 Inexact Rounded sqtx2442 squareroot 0.031 -> 0.18 Inexact Rounded sqtx2443 squareroot 31.0E-1 -> 1.8 Inexact Rounded sqtx2444 squareroot 31.00E-2 -> 0.56 Inexact Rounded sqtx2445 squareroot 31E-3 -> 0.18 Inexact Rounded sqtx2446 squareroot 31E+1 -> 18 Inexact Rounded sqtx2447 squareroot 31E+2 -> 56 Inexact Rounded sqtx2448 squareroot 31E+3 -> 1.8E+2 Inexact Rounded sqtx2449 squareroot 0.32 -> 0.57 Inexact Rounded sqtx2450 squareroot 0.032 -> 0.18 Inexact Rounded sqtx2451 squareroot 32.0E-1 -> 1.8 Inexact Rounded sqtx2452 squareroot 32.00E-2 -> 0.57 Inexact Rounded sqtx2453 squareroot 32E-3 -> 0.18 Inexact Rounded sqtx2454 squareroot 32E+1 -> 18 Inexact Rounded sqtx2455 squareroot 32E+2 -> 57 Inexact Rounded sqtx2456 squareroot 32E+3 -> 1.8E+2 Inexact Rounded sqtx2457 squareroot 0.33 -> 0.57 Inexact Rounded sqtx2458 squareroot 0.033 -> 0.18 Inexact Rounded sqtx2459 squareroot 33.0E-1 -> 1.8 Inexact Rounded sqtx2460 squareroot 33.00E-2 -> 0.57 Inexact Rounded sqtx2461 squareroot 33E-3 -> 0.18 Inexact Rounded sqtx2462 squareroot 33E+1 -> 18 Inexact Rounded sqtx2463 squareroot 33E+2 -> 57 Inexact Rounded sqtx2464 squareroot 33E+3 -> 1.8E+2 Inexact Rounded sqtx2465 squareroot 0.34 -> 0.58 Inexact Rounded sqtx2466 squareroot 0.034 -> 0.18 Inexact Rounded sqtx2467 squareroot 34.0E-1 -> 1.8 Inexact Rounded sqtx2468 squareroot 34.00E-2 -> 0.58 Inexact Rounded sqtx2469 squareroot 34E-3 -> 0.18 Inexact Rounded sqtx2470 squareroot 34E+1 -> 18 Inexact Rounded sqtx2471 squareroot 34E+2 -> 58 Inexact Rounded sqtx2472 squareroot 34E+3 -> 1.8E+2 Inexact Rounded sqtx2473 squareroot 0.35 -> 0.59 Inexact Rounded sqtx2474 squareroot 0.035 -> 0.19 Inexact Rounded sqtx2475 squareroot 35.0E-1 -> 1.9 Inexact Rounded sqtx2476 squareroot 35.00E-2 -> 0.59 Inexact Rounded sqtx2477 squareroot 35E-3 -> 0.19 Inexact Rounded sqtx2478 squareroot 35E+1 -> 19 Inexact Rounded sqtx2479 squareroot 35E+2 -> 59 Inexact Rounded sqtx2480 squareroot 35E+3 -> 1.9E+2 Inexact Rounded sqtx2481 squareroot 0.36 -> 0.6 sqtx2482 squareroot 0.036 -> 0.19 Inexact Rounded sqtx2483 squareroot 36.0E-1 -> 1.9 Inexact Rounded sqtx2484 squareroot 36.00E-2 -> 0.60 sqtx2485 squareroot 36E-3 -> 0.19 Inexact Rounded sqtx2486 squareroot 36E+1 -> 19 Inexact Rounded sqtx2487 squareroot 36E+2 -> 6E+1 sqtx2488 squareroot 36E+3 -> 1.9E+2 Inexact Rounded sqtx2489 squareroot 0.37 -> 0.61 Inexact Rounded sqtx2490 squareroot 0.037 -> 0.19 Inexact Rounded sqtx2491 squareroot 37.0E-1 -> 1.9 Inexact Rounded sqtx2492 squareroot 37.00E-2 -> 0.61 Inexact Rounded sqtx2493 squareroot 37E-3 -> 0.19 Inexact Rounded sqtx2494 squareroot 37E+1 -> 19 Inexact Rounded sqtx2495 squareroot 37E+2 -> 61 Inexact Rounded sqtx2496 squareroot 37E+3 -> 1.9E+2 Inexact Rounded sqtx2497 squareroot 0.38 -> 0.62 Inexact Rounded sqtx2498 squareroot 0.038 -> 0.19 Inexact Rounded sqtx2499 squareroot 38.0E-1 -> 1.9 Inexact Rounded sqtx2500 squareroot 38.00E-2 -> 0.62 Inexact Rounded sqtx2501 squareroot 38E-3 -> 0.19 Inexact Rounded sqtx2502 squareroot 38E+1 -> 19 Inexact Rounded sqtx2503 squareroot 38E+2 -> 62 Inexact Rounded sqtx2504 squareroot 38E+3 -> 1.9E+2 Inexact Rounded sqtx2505 squareroot 0.39 -> 0.62 Inexact Rounded sqtx2506 squareroot 0.039 -> 0.20 Inexact Rounded sqtx2507 squareroot 39.0E-1 -> 2.0 Inexact Rounded sqtx2508 squareroot 39.00E-2 -> 0.62 Inexact Rounded sqtx2509 squareroot 39E-3 -> 0.20 Inexact Rounded sqtx2510 squareroot 39E+1 -> 20 Inexact Rounded sqtx2511 squareroot 39E+2 -> 62 Inexact Rounded sqtx2512 squareroot 39E+3 -> 2.0E+2 Inexact Rounded sqtx2513 squareroot 0.40 -> 0.63 Inexact Rounded sqtx2514 squareroot 0.040 -> 0.20 sqtx2515 squareroot 40.0E-1 -> 2.0 sqtx2516 squareroot 40.00E-2 -> 0.63 Inexact Rounded sqtx2517 squareroot 40E-3 -> 0.20 sqtx2518 squareroot 40E+1 -> 20 sqtx2519 squareroot 40E+2 -> 63 Inexact Rounded sqtx2520 squareroot 40E+3 -> 2.0E+2 sqtx2521 squareroot 0.41 -> 0.64 Inexact Rounded sqtx2522 squareroot 0.041 -> 0.20 Inexact Rounded sqtx2523 squareroot 41.0E-1 -> 2.0 Inexact Rounded sqtx2524 squareroot 41.00E-2 -> 0.64 Inexact Rounded sqtx2525 squareroot 41E-3 -> 0.20 Inexact Rounded sqtx2526 squareroot 41E+1 -> 20 Inexact Rounded sqtx2527 squareroot 41E+2 -> 64 Inexact Rounded sqtx2528 squareroot 41E+3 -> 2.0E+2 Inexact Rounded sqtx2529 squareroot 0.42 -> 0.65 Inexact Rounded sqtx2530 squareroot 0.042 -> 0.20 Inexact Rounded sqtx2531 squareroot 42.0E-1 -> 2.0 Inexact Rounded sqtx2532 squareroot 42.00E-2 -> 0.65 Inexact Rounded sqtx2533 squareroot 42E-3 -> 0.20 Inexact Rounded sqtx2534 squareroot 42E+1 -> 20 Inexact Rounded sqtx2535 squareroot 42E+2 -> 65 Inexact Rounded sqtx2536 squareroot 42E+3 -> 2.0E+2 Inexact Rounded sqtx2537 squareroot 0.43 -> 0.66 Inexact Rounded sqtx2538 squareroot 0.043 -> 0.21 Inexact Rounded sqtx2539 squareroot 43.0E-1 -> 2.1 Inexact Rounded sqtx2540 squareroot 43.00E-2 -> 0.66 Inexact Rounded sqtx2541 squareroot 43E-3 -> 0.21 Inexact Rounded sqtx2542 squareroot 43E+1 -> 21 Inexact Rounded sqtx2543 squareroot 43E+2 -> 66 Inexact Rounded sqtx2544 squareroot 43E+3 -> 2.1E+2 Inexact Rounded sqtx2545 squareroot 0.44 -> 0.66 Inexact Rounded sqtx2546 squareroot 0.044 -> 0.21 Inexact Rounded sqtx2547 squareroot 44.0E-1 -> 2.1 Inexact Rounded sqtx2548 squareroot 44.00E-2 -> 0.66 Inexact Rounded sqtx2549 squareroot 44E-3 -> 0.21 Inexact Rounded sqtx2550 squareroot 44E+1 -> 21 Inexact Rounded sqtx2551 squareroot 44E+2 -> 66 Inexact Rounded sqtx2552 squareroot 44E+3 -> 2.1E+2 Inexact Rounded sqtx2553 squareroot 0.45 -> 0.67 Inexact Rounded sqtx2554 squareroot 0.045 -> 0.21 Inexact Rounded sqtx2555 squareroot 45.0E-1 -> 2.1 Inexact Rounded sqtx2556 squareroot 45.00E-2 -> 0.67 Inexact Rounded sqtx2557 squareroot 45E-3 -> 0.21 Inexact Rounded sqtx2558 squareroot 45E+1 -> 21 Inexact Rounded sqtx2559 squareroot 45E+2 -> 67 Inexact Rounded sqtx2560 squareroot 45E+3 -> 2.1E+2 Inexact Rounded sqtx2561 squareroot 0.46 -> 0.68 Inexact Rounded sqtx2562 squareroot 0.046 -> 0.21 Inexact Rounded sqtx2563 squareroot 46.0E-1 -> 2.1 Inexact Rounded sqtx2564 squareroot 46.00E-2 -> 0.68 Inexact Rounded sqtx2565 squareroot 46E-3 -> 0.21 Inexact Rounded sqtx2566 squareroot 46E+1 -> 21 Inexact Rounded sqtx2567 squareroot 46E+2 -> 68 Inexact Rounded sqtx2568 squareroot 46E+3 -> 2.1E+2 Inexact Rounded sqtx2569 squareroot 0.47 -> 0.69 Inexact Rounded sqtx2570 squareroot 0.047 -> 0.22 Inexact Rounded sqtx2571 squareroot 47.0E-1 -> 2.2 Inexact Rounded sqtx2572 squareroot 47.00E-2 -> 0.69 Inexact Rounded sqtx2573 squareroot 47E-3 -> 0.22 Inexact Rounded sqtx2574 squareroot 47E+1 -> 22 Inexact Rounded sqtx2575 squareroot 47E+2 -> 69 Inexact Rounded sqtx2576 squareroot 47E+3 -> 2.2E+2 Inexact Rounded sqtx2577 squareroot 0.48 -> 0.69 Inexact Rounded sqtx2578 squareroot 0.048 -> 0.22 Inexact Rounded sqtx2579 squareroot 48.0E-1 -> 2.2 Inexact Rounded sqtx2580 squareroot 48.00E-2 -> 0.69 Inexact Rounded sqtx2581 squareroot 48E-3 -> 0.22 Inexact Rounded sqtx2582 squareroot 48E+1 -> 22 Inexact Rounded sqtx2583 squareroot 48E+2 -> 69 Inexact Rounded sqtx2584 squareroot 48E+3 -> 2.2E+2 Inexact Rounded sqtx2585 squareroot 0.49 -> 0.7 sqtx2586 squareroot 0.049 -> 0.22 Inexact Rounded sqtx2587 squareroot 49.0E-1 -> 2.2 Inexact Rounded sqtx2588 squareroot 49.00E-2 -> 0.70 sqtx2589 squareroot 49E-3 -> 0.22 Inexact Rounded sqtx2590 squareroot 49E+1 -> 22 Inexact Rounded sqtx2591 squareroot 49E+2 -> 7E+1 sqtx2592 squareroot 49E+3 -> 2.2E+2 Inexact Rounded sqtx2593 squareroot 0.50 -> 0.71 Inexact Rounded sqtx2594 squareroot 0.050 -> 0.22 Inexact Rounded sqtx2595 squareroot 50.0E-1 -> 2.2 Inexact Rounded sqtx2596 squareroot 50.00E-2 -> 0.71 Inexact Rounded sqtx2597 squareroot 50E-3 -> 0.22 Inexact Rounded sqtx2598 squareroot 50E+1 -> 22 Inexact Rounded sqtx2599 squareroot 50E+2 -> 71 Inexact Rounded sqtx2600 squareroot 50E+3 -> 2.2E+2 Inexact Rounded sqtx2601 squareroot 0.51 -> 0.71 Inexact Rounded sqtx2602 squareroot 0.051 -> 0.23 Inexact Rounded sqtx2603 squareroot 51.0E-1 -> 2.3 Inexact Rounded sqtx2604 squareroot 51.00E-2 -> 0.71 Inexact Rounded sqtx2605 squareroot 51E-3 -> 0.23 Inexact Rounded sqtx2606 squareroot 51E+1 -> 23 Inexact Rounded sqtx2607 squareroot 51E+2 -> 71 Inexact Rounded sqtx2608 squareroot 51E+3 -> 2.3E+2 Inexact Rounded sqtx2609 squareroot 0.52 -> 0.72 Inexact Rounded sqtx2610 squareroot 0.052 -> 0.23 Inexact Rounded sqtx2611 squareroot 52.0E-1 -> 2.3 Inexact Rounded sqtx2612 squareroot 52.00E-2 -> 0.72 Inexact Rounded sqtx2613 squareroot 52E-3 -> 0.23 Inexact Rounded sqtx2614 squareroot 52E+1 -> 23 Inexact Rounded sqtx2615 squareroot 52E+2 -> 72 Inexact Rounded sqtx2616 squareroot 52E+3 -> 2.3E+2 Inexact Rounded sqtx2617 squareroot 0.53 -> 0.73 Inexact Rounded sqtx2618 squareroot 0.053 -> 0.23 Inexact Rounded sqtx2619 squareroot 53.0E-1 -> 2.3 Inexact Rounded sqtx2620 squareroot 53.00E-2 -> 0.73 Inexact Rounded sqtx2621 squareroot 53E-3 -> 0.23 Inexact Rounded sqtx2622 squareroot 53E+1 -> 23 Inexact Rounded sqtx2623 squareroot 53E+2 -> 73 Inexact Rounded sqtx2624 squareroot 53E+3 -> 2.3E+2 Inexact Rounded sqtx2625 squareroot 0.54 -> 0.73 Inexact Rounded sqtx2626 squareroot 0.054 -> 0.23 Inexact Rounded sqtx2627 squareroot 54.0E-1 -> 2.3 Inexact Rounded sqtx2628 squareroot 54.00E-2 -> 0.73 Inexact Rounded sqtx2629 squareroot 54E-3 -> 0.23 Inexact Rounded sqtx2630 squareroot 54E+1 -> 23 Inexact Rounded sqtx2631 squareroot 54E+2 -> 73 Inexact Rounded sqtx2632 squareroot 54E+3 -> 2.3E+2 Inexact Rounded sqtx2633 squareroot 0.55 -> 0.74 Inexact Rounded sqtx2634 squareroot 0.055 -> 0.23 Inexact Rounded sqtx2635 squareroot 55.0E-1 -> 2.3 Inexact Rounded sqtx2636 squareroot 55.00E-2 -> 0.74 Inexact Rounded sqtx2637 squareroot 55E-3 -> 0.23 Inexact Rounded sqtx2638 squareroot 55E+1 -> 23 Inexact Rounded sqtx2639 squareroot 55E+2 -> 74 Inexact Rounded sqtx2640 squareroot 55E+3 -> 2.3E+2 Inexact Rounded sqtx2641 squareroot 0.56 -> 0.75 Inexact Rounded sqtx2642 squareroot 0.056 -> 0.24 Inexact Rounded sqtx2643 squareroot 56.0E-1 -> 2.4 Inexact Rounded sqtx2644 squareroot 56.00E-2 -> 0.75 Inexact Rounded sqtx2645 squareroot 56E-3 -> 0.24 Inexact Rounded sqtx2646 squareroot 56E+1 -> 24 Inexact Rounded sqtx2647 squareroot 56E+2 -> 75 Inexact Rounded sqtx2648 squareroot 56E+3 -> 2.4E+2 Inexact Rounded sqtx2649 squareroot 0.57 -> 0.75 Inexact Rounded sqtx2650 squareroot 0.057 -> 0.24 Inexact Rounded sqtx2651 squareroot 57.0E-1 -> 2.4 Inexact Rounded sqtx2652 squareroot 57.00E-2 -> 0.75 Inexact Rounded sqtx2653 squareroot 57E-3 -> 0.24 Inexact Rounded sqtx2654 squareroot 57E+1 -> 24 Inexact Rounded sqtx2655 squareroot 57E+2 -> 75 Inexact Rounded sqtx2656 squareroot 57E+3 -> 2.4E+2 Inexact Rounded sqtx2657 squareroot 0.58 -> 0.76 Inexact Rounded sqtx2658 squareroot 0.058 -> 0.24 Inexact Rounded sqtx2659 squareroot 58.0E-1 -> 2.4 Inexact Rounded sqtx2660 squareroot 58.00E-2 -> 0.76 Inexact Rounded sqtx2661 squareroot 58E-3 -> 0.24 Inexact Rounded sqtx2662 squareroot 58E+1 -> 24 Inexact Rounded sqtx2663 squareroot 58E+2 -> 76 Inexact Rounded sqtx2664 squareroot 58E+3 -> 2.4E+2 Inexact Rounded sqtx2665 squareroot 0.59 -> 0.77 Inexact Rounded sqtx2666 squareroot 0.059 -> 0.24 Inexact Rounded sqtx2667 squareroot 59.0E-1 -> 2.4 Inexact Rounded sqtx2668 squareroot 59.00E-2 -> 0.77 Inexact Rounded sqtx2669 squareroot 59E-3 -> 0.24 Inexact Rounded sqtx2670 squareroot 59E+1 -> 24 Inexact Rounded sqtx2671 squareroot 59E+2 -> 77 Inexact Rounded sqtx2672 squareroot 59E+3 -> 2.4E+2 Inexact Rounded sqtx2673 squareroot 0.60 -> 0.77 Inexact Rounded sqtx2674 squareroot 0.060 -> 0.24 Inexact Rounded sqtx2675 squareroot 60.0E-1 -> 2.4 Inexact Rounded sqtx2676 squareroot 60.00E-2 -> 0.77 Inexact Rounded sqtx2677 squareroot 60E-3 -> 0.24 Inexact Rounded sqtx2678 squareroot 60E+1 -> 24 Inexact Rounded sqtx2679 squareroot 60E+2 -> 77 Inexact Rounded sqtx2680 squareroot 60E+3 -> 2.4E+2 Inexact Rounded sqtx2681 squareroot 0.61 -> 0.78 Inexact Rounded sqtx2682 squareroot 0.061 -> 0.25 Inexact Rounded sqtx2683 squareroot 61.0E-1 -> 2.5 Inexact Rounded sqtx2684 squareroot 61.00E-2 -> 0.78 Inexact Rounded sqtx2685 squareroot 61E-3 -> 0.25 Inexact Rounded sqtx2686 squareroot 61E+1 -> 25 Inexact Rounded sqtx2687 squareroot 61E+2 -> 78 Inexact Rounded sqtx2688 squareroot 61E+3 -> 2.5E+2 Inexact Rounded sqtx2689 squareroot 0.62 -> 0.79 Inexact Rounded sqtx2690 squareroot 0.062 -> 0.25 Inexact Rounded sqtx2691 squareroot 62.0E-1 -> 2.5 Inexact Rounded sqtx2692 squareroot 62.00E-2 -> 0.79 Inexact Rounded sqtx2693 squareroot 62E-3 -> 0.25 Inexact Rounded sqtx2694 squareroot 62E+1 -> 25 Inexact Rounded sqtx2695 squareroot 62E+2 -> 79 Inexact Rounded sqtx2696 squareroot 62E+3 -> 2.5E+2 Inexact Rounded sqtx2697 squareroot 0.63 -> 0.79 Inexact Rounded sqtx2698 squareroot 0.063 -> 0.25 Inexact Rounded sqtx2699 squareroot 63.0E-1 -> 2.5 Inexact Rounded sqtx2700 squareroot 63.00E-2 -> 0.79 Inexact Rounded sqtx2701 squareroot 63E-3 -> 0.25 Inexact Rounded sqtx2702 squareroot 63E+1 -> 25 Inexact Rounded sqtx2703 squareroot 63E+2 -> 79 Inexact Rounded sqtx2704 squareroot 63E+3 -> 2.5E+2 Inexact Rounded sqtx2705 squareroot 0.64 -> 0.8 sqtx2706 squareroot 0.064 -> 0.25 Inexact Rounded sqtx2707 squareroot 64.0E-1 -> 2.5 Inexact Rounded sqtx2708 squareroot 64.00E-2 -> 0.80 sqtx2709 squareroot 64E-3 -> 0.25 Inexact Rounded sqtx2710 squareroot 64E+1 -> 25 Inexact Rounded sqtx2711 squareroot 64E+2 -> 8E+1 sqtx2712 squareroot 64E+3 -> 2.5E+2 Inexact Rounded sqtx2713 squareroot 0.65 -> 0.81 Inexact Rounded sqtx2714 squareroot 0.065 -> 0.25 Inexact Rounded sqtx2715 squareroot 65.0E-1 -> 2.5 Inexact Rounded sqtx2716 squareroot 65.00E-2 -> 0.81 Inexact Rounded sqtx2717 squareroot 65E-3 -> 0.25 Inexact Rounded sqtx2718 squareroot 65E+1 -> 25 Inexact Rounded sqtx2719 squareroot 65E+2 -> 81 Inexact Rounded sqtx2720 squareroot 65E+3 -> 2.5E+2 Inexact Rounded sqtx2721 squareroot 0.66 -> 0.81 Inexact Rounded sqtx2722 squareroot 0.066 -> 0.26 Inexact Rounded sqtx2723 squareroot 66.0E-1 -> 2.6 Inexact Rounded sqtx2724 squareroot 66.00E-2 -> 0.81 Inexact Rounded sqtx2725 squareroot 66E-3 -> 0.26 Inexact Rounded sqtx2726 squareroot 66E+1 -> 26 Inexact Rounded sqtx2727 squareroot 66E+2 -> 81 Inexact Rounded sqtx2728 squareroot 66E+3 -> 2.6E+2 Inexact Rounded sqtx2729 squareroot 0.67 -> 0.82 Inexact Rounded sqtx2730 squareroot 0.067 -> 0.26 Inexact Rounded sqtx2731 squareroot 67.0E-1 -> 2.6 Inexact Rounded sqtx2732 squareroot 67.00E-2 -> 0.82 Inexact Rounded sqtx2733 squareroot 67E-3 -> 0.26 Inexact Rounded sqtx2734 squareroot 67E+1 -> 26 Inexact Rounded sqtx2735 squareroot 67E+2 -> 82 Inexact Rounded sqtx2736 squareroot 67E+3 -> 2.6E+2 Inexact Rounded sqtx2737 squareroot 0.68 -> 0.82 Inexact Rounded sqtx2738 squareroot 0.068 -> 0.26 Inexact Rounded sqtx2739 squareroot 68.0E-1 -> 2.6 Inexact Rounded sqtx2740 squareroot 68.00E-2 -> 0.82 Inexact Rounded sqtx2741 squareroot 68E-3 -> 0.26 Inexact Rounded sqtx2742 squareroot 68E+1 -> 26 Inexact Rounded sqtx2743 squareroot 68E+2 -> 82 Inexact Rounded sqtx2744 squareroot 68E+3 -> 2.6E+2 Inexact Rounded sqtx2745 squareroot 0.69 -> 0.83 Inexact Rounded sqtx2746 squareroot 0.069 -> 0.26 Inexact Rounded sqtx2747 squareroot 69.0E-1 -> 2.6 Inexact Rounded sqtx2748 squareroot 69.00E-2 -> 0.83 Inexact Rounded sqtx2749 squareroot 69E-3 -> 0.26 Inexact Rounded sqtx2750 squareroot 69E+1 -> 26 Inexact Rounded sqtx2751 squareroot 69E+2 -> 83 Inexact Rounded sqtx2752 squareroot 69E+3 -> 2.6E+2 Inexact Rounded sqtx2753 squareroot 0.70 -> 0.84 Inexact Rounded sqtx2754 squareroot 0.070 -> 0.26 Inexact Rounded sqtx2755 squareroot 70.0E-1 -> 2.6 Inexact Rounded sqtx2756 squareroot 70.00E-2 -> 0.84 Inexact Rounded sqtx2757 squareroot 70E-3 -> 0.26 Inexact Rounded sqtx2758 squareroot 70E+1 -> 26 Inexact Rounded sqtx2759 squareroot 70E+2 -> 84 Inexact Rounded sqtx2760 squareroot 70E+3 -> 2.6E+2 Inexact Rounded sqtx2761 squareroot 0.71 -> 0.84 Inexact Rounded sqtx2762 squareroot 0.071 -> 0.27 Inexact Rounded sqtx2763 squareroot 71.0E-1 -> 2.7 Inexact Rounded sqtx2764 squareroot 71.00E-2 -> 0.84 Inexact Rounded sqtx2765 squareroot 71E-3 -> 0.27 Inexact Rounded sqtx2766 squareroot 71E+1 -> 27 Inexact Rounded sqtx2767 squareroot 71E+2 -> 84 Inexact Rounded sqtx2768 squareroot 71E+3 -> 2.7E+2 Inexact Rounded sqtx2769 squareroot 0.72 -> 0.85 Inexact Rounded sqtx2770 squareroot 0.072 -> 0.27 Inexact Rounded sqtx2771 squareroot 72.0E-1 -> 2.7 Inexact Rounded sqtx2772 squareroot 72.00E-2 -> 0.85 Inexact Rounded sqtx2773 squareroot 72E-3 -> 0.27 Inexact Rounded sqtx2774 squareroot 72E+1 -> 27 Inexact Rounded sqtx2775 squareroot 72E+2 -> 85 Inexact Rounded sqtx2776 squareroot 72E+3 -> 2.7E+2 Inexact Rounded sqtx2777 squareroot 0.73 -> 0.85 Inexact Rounded sqtx2778 squareroot 0.073 -> 0.27 Inexact Rounded sqtx2779 squareroot 73.0E-1 -> 2.7 Inexact Rounded sqtx2780 squareroot 73.00E-2 -> 0.85 Inexact Rounded sqtx2781 squareroot 73E-3 -> 0.27 Inexact Rounded sqtx2782 squareroot 73E+1 -> 27 Inexact Rounded sqtx2783 squareroot 73E+2 -> 85 Inexact Rounded sqtx2784 squareroot 73E+3 -> 2.7E+2 Inexact Rounded sqtx2785 squareroot 0.74 -> 0.86 Inexact Rounded sqtx2786 squareroot 0.074 -> 0.27 Inexact Rounded sqtx2787 squareroot 74.0E-1 -> 2.7 Inexact Rounded sqtx2788 squareroot 74.00E-2 -> 0.86 Inexact Rounded sqtx2789 squareroot 74E-3 -> 0.27 Inexact Rounded sqtx2790 squareroot 74E+1 -> 27 Inexact Rounded sqtx2791 squareroot 74E+2 -> 86 Inexact Rounded sqtx2792 squareroot 74E+3 -> 2.7E+2 Inexact Rounded sqtx2793 squareroot 0.75 -> 0.87 Inexact Rounded sqtx2794 squareroot 0.075 -> 0.27 Inexact Rounded sqtx2795 squareroot 75.0E-1 -> 2.7 Inexact Rounded sqtx2796 squareroot 75.00E-2 -> 0.87 Inexact Rounded sqtx2797 squareroot 75E-3 -> 0.27 Inexact Rounded sqtx2798 squareroot 75E+1 -> 27 Inexact Rounded sqtx2799 squareroot 75E+2 -> 87 Inexact Rounded sqtx2800 squareroot 75E+3 -> 2.7E+2 Inexact Rounded sqtx2801 squareroot 0.76 -> 0.87 Inexact Rounded sqtx2802 squareroot 0.076 -> 0.28 Inexact Rounded sqtx2803 squareroot 76.0E-1 -> 2.8 Inexact Rounded sqtx2804 squareroot 76.00E-2 -> 0.87 Inexact Rounded sqtx2805 squareroot 76E-3 -> 0.28 Inexact Rounded sqtx2806 squareroot 76E+1 -> 28 Inexact Rounded sqtx2807 squareroot 76E+2 -> 87 Inexact Rounded sqtx2808 squareroot 76E+3 -> 2.8E+2 Inexact Rounded sqtx2809 squareroot 0.77 -> 0.88 Inexact Rounded sqtx2810 squareroot 0.077 -> 0.28 Inexact Rounded sqtx2811 squareroot 77.0E-1 -> 2.8 Inexact Rounded sqtx2812 squareroot 77.00E-2 -> 0.88 Inexact Rounded sqtx2813 squareroot 77E-3 -> 0.28 Inexact Rounded sqtx2814 squareroot 77E+1 -> 28 Inexact Rounded sqtx2815 squareroot 77E+2 -> 88 Inexact Rounded sqtx2816 squareroot 77E+3 -> 2.8E+2 Inexact Rounded sqtx2817 squareroot 0.78 -> 0.88 Inexact Rounded sqtx2818 squareroot 0.078 -> 0.28 Inexact Rounded sqtx2819 squareroot 78.0E-1 -> 2.8 Inexact Rounded sqtx2820 squareroot 78.00E-2 -> 0.88 Inexact Rounded sqtx2821 squareroot 78E-3 -> 0.28 Inexact Rounded sqtx2822 squareroot 78E+1 -> 28 Inexact Rounded sqtx2823 squareroot 78E+2 -> 88 Inexact Rounded sqtx2824 squareroot 78E+3 -> 2.8E+2 Inexact Rounded sqtx2825 squareroot 0.79 -> 0.89 Inexact Rounded sqtx2826 squareroot 0.079 -> 0.28 Inexact Rounded sqtx2827 squareroot 79.0E-1 -> 2.8 Inexact Rounded sqtx2828 squareroot 79.00E-2 -> 0.89 Inexact Rounded sqtx2829 squareroot 79E-3 -> 0.28 Inexact Rounded sqtx2830 squareroot 79E+1 -> 28 Inexact Rounded sqtx2831 squareroot 79E+2 -> 89 Inexact Rounded sqtx2832 squareroot 79E+3 -> 2.8E+2 Inexact Rounded sqtx2833 squareroot 0.80 -> 0.89 Inexact Rounded sqtx2834 squareroot 0.080 -> 0.28 Inexact Rounded sqtx2835 squareroot 80.0E-1 -> 2.8 Inexact Rounded sqtx2836 squareroot 80.00E-2 -> 0.89 Inexact Rounded sqtx2837 squareroot 80E-3 -> 0.28 Inexact Rounded sqtx2838 squareroot 80E+1 -> 28 Inexact Rounded sqtx2839 squareroot 80E+2 -> 89 Inexact Rounded sqtx2840 squareroot 80E+3 -> 2.8E+2 Inexact Rounded sqtx2841 squareroot 0.81 -> 0.9 sqtx2842 squareroot 0.081 -> 0.28 Inexact Rounded sqtx2843 squareroot 81.0E-1 -> 2.8 Inexact Rounded sqtx2844 squareroot 81.00E-2 -> 0.90 sqtx2845 squareroot 81E-3 -> 0.28 Inexact Rounded sqtx2846 squareroot 81E+1 -> 28 Inexact Rounded sqtx2847 squareroot 81E+2 -> 9E+1 sqtx2848 squareroot 81E+3 -> 2.8E+2 Inexact Rounded sqtx2849 squareroot 0.82 -> 0.91 Inexact Rounded sqtx2850 squareroot 0.082 -> 0.29 Inexact Rounded sqtx2851 squareroot 82.0E-1 -> 2.9 Inexact Rounded sqtx2852 squareroot 82.00E-2 -> 0.91 Inexact Rounded sqtx2853 squareroot 82E-3 -> 0.29 Inexact Rounded sqtx2854 squareroot 82E+1 -> 29 Inexact Rounded sqtx2855 squareroot 82E+2 -> 91 Inexact Rounded sqtx2856 squareroot 82E+3 -> 2.9E+2 Inexact Rounded sqtx2857 squareroot 0.83 -> 0.91 Inexact Rounded sqtx2858 squareroot 0.083 -> 0.29 Inexact Rounded sqtx2859 squareroot 83.0E-1 -> 2.9 Inexact Rounded sqtx2860 squareroot 83.00E-2 -> 0.91 Inexact Rounded sqtx2861 squareroot 83E-3 -> 0.29 Inexact Rounded sqtx2862 squareroot 83E+1 -> 29 Inexact Rounded sqtx2863 squareroot 83E+2 -> 91 Inexact Rounded sqtx2864 squareroot 83E+3 -> 2.9E+2 Inexact Rounded sqtx2865 squareroot 0.84 -> 0.92 Inexact Rounded sqtx2866 squareroot 0.084 -> 0.29 Inexact Rounded sqtx2867 squareroot 84.0E-1 -> 2.9 Inexact Rounded sqtx2868 squareroot 84.00E-2 -> 0.92 Inexact Rounded sqtx2869 squareroot 84E-3 -> 0.29 Inexact Rounded sqtx2870 squareroot 84E+1 -> 29 Inexact Rounded sqtx2871 squareroot 84E+2 -> 92 Inexact Rounded sqtx2872 squareroot 84E+3 -> 2.9E+2 Inexact Rounded sqtx2873 squareroot 0.85 -> 0.92 Inexact Rounded sqtx2874 squareroot 0.085 -> 0.29 Inexact Rounded sqtx2875 squareroot 85.0E-1 -> 2.9 Inexact Rounded sqtx2876 squareroot 85.00E-2 -> 0.92 Inexact Rounded sqtx2877 squareroot 85E-3 -> 0.29 Inexact Rounded sqtx2878 squareroot 85E+1 -> 29 Inexact Rounded sqtx2879 squareroot 85E+2 -> 92 Inexact Rounded sqtx2880 squareroot 85E+3 -> 2.9E+2 Inexact Rounded sqtx2881 squareroot 0.86 -> 0.93 Inexact Rounded sqtx2882 squareroot 0.086 -> 0.29 Inexact Rounded sqtx2883 squareroot 86.0E-1 -> 2.9 Inexact Rounded sqtx2884 squareroot 86.00E-2 -> 0.93 Inexact Rounded sqtx2885 squareroot 86E-3 -> 0.29 Inexact Rounded sqtx2886 squareroot 86E+1 -> 29 Inexact Rounded sqtx2887 squareroot 86E+2 -> 93 Inexact Rounded sqtx2888 squareroot 86E+3 -> 2.9E+2 Inexact Rounded sqtx2889 squareroot 0.87 -> 0.93 Inexact Rounded sqtx2890 squareroot 0.087 -> 0.29 Inexact Rounded sqtx2891 squareroot 87.0E-1 -> 2.9 Inexact Rounded sqtx2892 squareroot 87.00E-2 -> 0.93 Inexact Rounded sqtx2893 squareroot 87E-3 -> 0.29 Inexact Rounded sqtx2894 squareroot 87E+1 -> 29 Inexact Rounded sqtx2895 squareroot 87E+2 -> 93 Inexact Rounded sqtx2896 squareroot 87E+3 -> 2.9E+2 Inexact Rounded sqtx2897 squareroot 0.88 -> 0.94 Inexact Rounded sqtx2898 squareroot 0.088 -> 0.30 Inexact Rounded sqtx2899 squareroot 88.0E-1 -> 3.0 Inexact Rounded sqtx2900 squareroot 88.00E-2 -> 0.94 Inexact Rounded sqtx2901 squareroot 88E-3 -> 0.30 Inexact Rounded sqtx2902 squareroot 88E+1 -> 30 Inexact Rounded sqtx2903 squareroot 88E+2 -> 94 Inexact Rounded sqtx2904 squareroot 88E+3 -> 3.0E+2 Inexact Rounded sqtx2905 squareroot 0.89 -> 0.94 Inexact Rounded sqtx2906 squareroot 0.089 -> 0.30 Inexact Rounded sqtx2907 squareroot 89.0E-1 -> 3.0 Inexact Rounded sqtx2908 squareroot 89.00E-2 -> 0.94 Inexact Rounded sqtx2909 squareroot 89E-3 -> 0.30 Inexact Rounded sqtx2910 squareroot 89E+1 -> 30 Inexact Rounded sqtx2911 squareroot 89E+2 -> 94 Inexact Rounded sqtx2912 squareroot 89E+3 -> 3.0E+2 Inexact Rounded sqtx2913 squareroot 0.90 -> 0.95 Inexact Rounded sqtx2914 squareroot 0.090 -> 0.30 sqtx2915 squareroot 90.0E-1 -> 3.0 sqtx2916 squareroot 90.00E-2 -> 0.95 Inexact Rounded sqtx2917 squareroot 90E-3 -> 0.30 sqtx2918 squareroot 90E+1 -> 30 sqtx2919 squareroot 90E+2 -> 95 Inexact Rounded sqtx2920 squareroot 90E+3 -> 3.0E+2 sqtx2921 squareroot 0.91 -> 0.95 Inexact Rounded sqtx2922 squareroot 0.091 -> 0.30 Inexact Rounded sqtx2923 squareroot 91.0E-1 -> 3.0 Inexact Rounded sqtx2924 squareroot 91.00E-2 -> 0.95 Inexact Rounded sqtx2925 squareroot 91E-3 -> 0.30 Inexact Rounded sqtx2926 squareroot 91E+1 -> 30 Inexact Rounded sqtx2927 squareroot 91E+2 -> 95 Inexact Rounded sqtx2928 squareroot 91E+3 -> 3.0E+2 Inexact Rounded sqtx2929 squareroot 0.92 -> 0.96 Inexact Rounded sqtx2930 squareroot 0.092 -> 0.30 Inexact Rounded sqtx2931 squareroot 92.0E-1 -> 3.0 Inexact Rounded sqtx2932 squareroot 92.00E-2 -> 0.96 Inexact Rounded sqtx2933 squareroot 92E-3 -> 0.30 Inexact Rounded sqtx2934 squareroot 92E+1 -> 30 Inexact Rounded sqtx2935 squareroot 92E+2 -> 96 Inexact Rounded sqtx2936 squareroot 92E+3 -> 3.0E+2 Inexact Rounded sqtx2937 squareroot 0.93 -> 0.96 Inexact Rounded sqtx2938 squareroot 0.093 -> 0.30 Inexact Rounded sqtx2939 squareroot 93.0E-1 -> 3.0 Inexact Rounded sqtx2940 squareroot 93.00E-2 -> 0.96 Inexact Rounded sqtx2941 squareroot 93E-3 -> 0.30 Inexact Rounded sqtx2942 squareroot 93E+1 -> 30 Inexact Rounded sqtx2943 squareroot 93E+2 -> 96 Inexact Rounded sqtx2944 squareroot 93E+3 -> 3.0E+2 Inexact Rounded sqtx2945 squareroot 0.94 -> 0.97 Inexact Rounded sqtx2946 squareroot 0.094 -> 0.31 Inexact Rounded sqtx2947 squareroot 94.0E-1 -> 3.1 Inexact Rounded sqtx2948 squareroot 94.00E-2 -> 0.97 Inexact Rounded sqtx2949 squareroot 94E-3 -> 0.31 Inexact Rounded sqtx2950 squareroot 94E+1 -> 31 Inexact Rounded sqtx2951 squareroot 94E+2 -> 97 Inexact Rounded sqtx2952 squareroot 94E+3 -> 3.1E+2 Inexact Rounded sqtx2953 squareroot 0.95 -> 0.97 Inexact Rounded sqtx2954 squareroot 0.095 -> 0.31 Inexact Rounded sqtx2955 squareroot 95.0E-1 -> 3.1 Inexact Rounded sqtx2956 squareroot 95.00E-2 -> 0.97 Inexact Rounded sqtx2957 squareroot 95E-3 -> 0.31 Inexact Rounded sqtx2958 squareroot 95E+1 -> 31 Inexact Rounded sqtx2959 squareroot 95E+2 -> 97 Inexact Rounded sqtx2960 squareroot 95E+3 -> 3.1E+2 Inexact Rounded sqtx2961 squareroot 0.96 -> 0.98 Inexact Rounded sqtx2962 squareroot 0.096 -> 0.31 Inexact Rounded sqtx2963 squareroot 96.0E-1 -> 3.1 Inexact Rounded sqtx2964 squareroot 96.00E-2 -> 0.98 Inexact Rounded sqtx2965 squareroot 96E-3 -> 0.31 Inexact Rounded sqtx2966 squareroot 96E+1 -> 31 Inexact Rounded sqtx2967 squareroot 96E+2 -> 98 Inexact Rounded sqtx2968 squareroot 96E+3 -> 3.1E+2 Inexact Rounded sqtx2969 squareroot 0.97 -> 0.98 Inexact Rounded sqtx2970 squareroot 0.097 -> 0.31 Inexact Rounded sqtx2971 squareroot 97.0E-1 -> 3.1 Inexact Rounded sqtx2972 squareroot 97.00E-2 -> 0.98 Inexact Rounded sqtx2973 squareroot 97E-3 -> 0.31 Inexact Rounded sqtx2974 squareroot 97E+1 -> 31 Inexact Rounded sqtx2975 squareroot 97E+2 -> 98 Inexact Rounded sqtx2976 squareroot 97E+3 -> 3.1E+2 Inexact Rounded sqtx2977 squareroot 0.98 -> 0.99 Inexact Rounded sqtx2978 squareroot 0.098 -> 0.31 Inexact Rounded sqtx2979 squareroot 98.0E-1 -> 3.1 Inexact Rounded sqtx2980 squareroot 98.00E-2 -> 0.99 Inexact Rounded sqtx2981 squareroot 98E-3 -> 0.31 Inexact Rounded sqtx2982 squareroot 98E+1 -> 31 Inexact Rounded sqtx2983 squareroot 98E+2 -> 99 Inexact Rounded sqtx2984 squareroot 98E+3 -> 3.1E+2 Inexact Rounded sqtx2985 squareroot 0.99 -> 0.99 Inexact Rounded sqtx2986 squareroot 0.099 -> 0.31 Inexact Rounded sqtx2987 squareroot 99.0E-1 -> 3.1 Inexact Rounded sqtx2988 squareroot 99.00E-2 -> 0.99 Inexact Rounded sqtx2989 squareroot 99E-3 -> 0.31 Inexact Rounded sqtx2990 squareroot 99E+1 -> 31 Inexact Rounded sqtx2991 squareroot 99E+2 -> 99 Inexact Rounded sqtx2992 squareroot 99E+3 -> 3.1E+2 Inexact Rounded -- Precision 3 squareroot tests [exhaustive, f and f/10] rounding: half_even maxExponent: 999 minexponent: -999 precision: 3 sqtx3001 squareroot 0.1 -> 0.316 Inexact Rounded sqtx3002 squareroot 0.01 -> 0.1 sqtx3003 squareroot 0.2 -> 0.447 Inexact Rounded sqtx3004 squareroot 0.02 -> 0.141 Inexact Rounded sqtx3005 squareroot 0.3 -> 0.548 Inexact Rounded sqtx3006 squareroot 0.03 -> 0.173 Inexact Rounded sqtx3007 squareroot 0.4 -> 0.632 Inexact Rounded sqtx3008 squareroot 0.04 -> 0.2 sqtx3009 squareroot 0.5 -> 0.707 Inexact Rounded sqtx3010 squareroot 0.05 -> 0.224 Inexact Rounded sqtx3011 squareroot 0.6 -> 0.775 Inexact Rounded sqtx3012 squareroot 0.06 -> 0.245 Inexact Rounded sqtx3013 squareroot 0.7 -> 0.837 Inexact Rounded sqtx3014 squareroot 0.07 -> 0.265 Inexact Rounded sqtx3015 squareroot 0.8 -> 0.894 Inexact Rounded sqtx3016 squareroot 0.08 -> 0.283 Inexact Rounded sqtx3017 squareroot 0.9 -> 0.949 Inexact Rounded sqtx3018 squareroot 0.09 -> 0.3 sqtx3019 squareroot 0.11 -> 0.332 Inexact Rounded sqtx3020 squareroot 0.011 -> 0.105 Inexact Rounded sqtx3021 squareroot 0.12 -> 0.346 Inexact Rounded sqtx3022 squareroot 0.012 -> 0.110 Inexact Rounded sqtx3023 squareroot 0.13 -> 0.361 Inexact Rounded sqtx3024 squareroot 0.013 -> 0.114 Inexact Rounded sqtx3025 squareroot 0.14 -> 0.374 Inexact Rounded sqtx3026 squareroot 0.014 -> 0.118 Inexact Rounded sqtx3027 squareroot 0.15 -> 0.387 Inexact Rounded sqtx3028 squareroot 0.015 -> 0.122 Inexact Rounded sqtx3029 squareroot 0.16 -> 0.4 sqtx3030 squareroot 0.016 -> 0.126 Inexact Rounded sqtx3031 squareroot 0.17 -> 0.412 Inexact Rounded sqtx3032 squareroot 0.017 -> 0.130 Inexact Rounded sqtx3033 squareroot 0.18 -> 0.424 Inexact Rounded sqtx3034 squareroot 0.018 -> 0.134 Inexact Rounded sqtx3035 squareroot 0.19 -> 0.436 Inexact Rounded sqtx3036 squareroot 0.019 -> 0.138 Inexact Rounded sqtx3037 squareroot 0.21 -> 0.458 Inexact Rounded sqtx3038 squareroot 0.021 -> 0.145 Inexact Rounded sqtx3039 squareroot 0.22 -> 0.469 Inexact Rounded sqtx3040 squareroot 0.022 -> 0.148 Inexact Rounded sqtx3041 squareroot 0.23 -> 0.480 Inexact Rounded sqtx3042 squareroot 0.023 -> 0.152 Inexact Rounded sqtx3043 squareroot 0.24 -> 0.490 Inexact Rounded sqtx3044 squareroot 0.024 -> 0.155 Inexact Rounded sqtx3045 squareroot 0.25 -> 0.5 sqtx3046 squareroot 0.025 -> 0.158 Inexact Rounded sqtx3047 squareroot 0.26 -> 0.510 Inexact Rounded sqtx3048 squareroot 0.026 -> 0.161 Inexact Rounded sqtx3049 squareroot 0.27 -> 0.520 Inexact Rounded sqtx3050 squareroot 0.027 -> 0.164 Inexact Rounded sqtx3051 squareroot 0.28 -> 0.529 Inexact Rounded sqtx3052 squareroot 0.028 -> 0.167 Inexact Rounded sqtx3053 squareroot 0.29 -> 0.539 Inexact Rounded sqtx3054 squareroot 0.029 -> 0.170 Inexact Rounded sqtx3055 squareroot 0.31 -> 0.557 Inexact Rounded sqtx3056 squareroot 0.031 -> 0.176 Inexact Rounded sqtx3057 squareroot 0.32 -> 0.566 Inexact Rounded sqtx3058 squareroot 0.032 -> 0.179 Inexact Rounded sqtx3059 squareroot 0.33 -> 0.574 Inexact Rounded sqtx3060 squareroot 0.033 -> 0.182 Inexact Rounded sqtx3061 squareroot 0.34 -> 0.583 Inexact Rounded sqtx3062 squareroot 0.034 -> 0.184 Inexact Rounded sqtx3063 squareroot 0.35 -> 0.592 Inexact Rounded sqtx3064 squareroot 0.035 -> 0.187 Inexact Rounded sqtx3065 squareroot 0.36 -> 0.6 sqtx3066 squareroot 0.036 -> 0.190 Inexact Rounded sqtx3067 squareroot 0.37 -> 0.608 Inexact Rounded sqtx3068 squareroot 0.037 -> 0.192 Inexact Rounded sqtx3069 squareroot 0.38 -> 0.616 Inexact Rounded sqtx3070 squareroot 0.038 -> 0.195 Inexact Rounded sqtx3071 squareroot 0.39 -> 0.624 Inexact Rounded sqtx3072 squareroot 0.039 -> 0.197 Inexact Rounded sqtx3073 squareroot 0.41 -> 0.640 Inexact Rounded sqtx3074 squareroot 0.041 -> 0.202 Inexact Rounded sqtx3075 squareroot 0.42 -> 0.648 Inexact Rounded sqtx3076 squareroot 0.042 -> 0.205 Inexact Rounded sqtx3077 squareroot 0.43 -> 0.656 Inexact Rounded sqtx3078 squareroot 0.043 -> 0.207 Inexact Rounded sqtx3079 squareroot 0.44 -> 0.663 Inexact Rounded sqtx3080 squareroot 0.044 -> 0.210 Inexact Rounded sqtx3081 squareroot 0.45 -> 0.671 Inexact Rounded sqtx3082 squareroot 0.045 -> 0.212 Inexact Rounded sqtx3083 squareroot 0.46 -> 0.678 Inexact Rounded sqtx3084 squareroot 0.046 -> 0.214 Inexact Rounded sqtx3085 squareroot 0.47 -> 0.686 Inexact Rounded sqtx3086 squareroot 0.047 -> 0.217 Inexact Rounded sqtx3087 squareroot 0.48 -> 0.693 Inexact Rounded sqtx3088 squareroot 0.048 -> 0.219 Inexact Rounded sqtx3089 squareroot 0.49 -> 0.7 sqtx3090 squareroot 0.049 -> 0.221 Inexact Rounded sqtx3091 squareroot 0.51 -> 0.714 Inexact Rounded sqtx3092 squareroot 0.051 -> 0.226 Inexact Rounded sqtx3093 squareroot 0.52 -> 0.721 Inexact Rounded sqtx3094 squareroot 0.052 -> 0.228 Inexact Rounded sqtx3095 squareroot 0.53 -> 0.728 Inexact Rounded sqtx3096 squareroot 0.053 -> 0.230 Inexact Rounded sqtx3097 squareroot 0.54 -> 0.735 Inexact Rounded sqtx3098 squareroot 0.054 -> 0.232 Inexact Rounded sqtx3099 squareroot 0.55 -> 0.742 Inexact Rounded sqtx3100 squareroot 0.055 -> 0.235 Inexact Rounded sqtx3101 squareroot 0.56 -> 0.748 Inexact Rounded sqtx3102 squareroot 0.056 -> 0.237 Inexact Rounded sqtx3103 squareroot 0.57 -> 0.755 Inexact Rounded sqtx3104 squareroot 0.057 -> 0.239 Inexact Rounded sqtx3105 squareroot 0.58 -> 0.762 Inexact Rounded sqtx3106 squareroot 0.058 -> 0.241 Inexact Rounded sqtx3107 squareroot 0.59 -> 0.768 Inexact Rounded sqtx3108 squareroot 0.059 -> 0.243 Inexact Rounded sqtx3109 squareroot 0.61 -> 0.781 Inexact Rounded sqtx3110 squareroot 0.061 -> 0.247 Inexact Rounded sqtx3111 squareroot 0.62 -> 0.787 Inexact Rounded sqtx3112 squareroot 0.062 -> 0.249 Inexact Rounded sqtx3113 squareroot 0.63 -> 0.794 Inexact Rounded sqtx3114 squareroot 0.063 -> 0.251 Inexact Rounded sqtx3115 squareroot 0.64 -> 0.8 sqtx3116 squareroot 0.064 -> 0.253 Inexact Rounded sqtx3117 squareroot 0.65 -> 0.806 Inexact Rounded sqtx3118 squareroot 0.065 -> 0.255 Inexact Rounded sqtx3119 squareroot 0.66 -> 0.812 Inexact Rounded sqtx3120 squareroot 0.066 -> 0.257 Inexact Rounded sqtx3121 squareroot 0.67 -> 0.819 Inexact Rounded sqtx3122 squareroot 0.067 -> 0.259 Inexact Rounded sqtx3123 squareroot 0.68 -> 0.825 Inexact Rounded sqtx3124 squareroot 0.068 -> 0.261 Inexact Rounded sqtx3125 squareroot 0.69 -> 0.831 Inexact Rounded sqtx3126 squareroot 0.069 -> 0.263 Inexact Rounded sqtx3127 squareroot 0.71 -> 0.843 Inexact Rounded sqtx3128 squareroot 0.071 -> 0.266 Inexact Rounded sqtx3129 squareroot 0.72 -> 0.849 Inexact Rounded sqtx3130 squareroot 0.072 -> 0.268 Inexact Rounded sqtx3131 squareroot 0.73 -> 0.854 Inexact Rounded sqtx3132 squareroot 0.073 -> 0.270 Inexact Rounded sqtx3133 squareroot 0.74 -> 0.860 Inexact Rounded sqtx3134 squareroot 0.074 -> 0.272 Inexact Rounded sqtx3135 squareroot 0.75 -> 0.866 Inexact Rounded sqtx3136 squareroot 0.075 -> 0.274 Inexact Rounded sqtx3137 squareroot 0.76 -> 0.872 Inexact Rounded sqtx3138 squareroot 0.076 -> 0.276 Inexact Rounded sqtx3139 squareroot 0.77 -> 0.877 Inexact Rounded sqtx3140 squareroot 0.077 -> 0.277 Inexact Rounded sqtx3141 squareroot 0.78 -> 0.883 Inexact Rounded sqtx3142 squareroot 0.078 -> 0.279 Inexact Rounded sqtx3143 squareroot 0.79 -> 0.889 Inexact Rounded sqtx3144 squareroot 0.079 -> 0.281 Inexact Rounded sqtx3145 squareroot 0.81 -> 0.9 sqtx3146 squareroot 0.081 -> 0.285 Inexact Rounded sqtx3147 squareroot 0.82 -> 0.906 Inexact Rounded sqtx3148 squareroot 0.082 -> 0.286 Inexact Rounded sqtx3149 squareroot 0.83 -> 0.911 Inexact Rounded sqtx3150 squareroot 0.083 -> 0.288 Inexact Rounded sqtx3151 squareroot 0.84 -> 0.917 Inexact Rounded sqtx3152 squareroot 0.084 -> 0.290 Inexact Rounded sqtx3153 squareroot 0.85 -> 0.922 Inexact Rounded sqtx3154 squareroot 0.085 -> 0.292 Inexact Rounded sqtx3155 squareroot 0.86 -> 0.927 Inexact Rounded sqtx3156 squareroot 0.086 -> 0.293 Inexact Rounded sqtx3157 squareroot 0.87 -> 0.933 Inexact Rounded sqtx3158 squareroot 0.087 -> 0.295 Inexact Rounded sqtx3159 squareroot 0.88 -> 0.938 Inexact Rounded sqtx3160 squareroot 0.088 -> 0.297 Inexact Rounded sqtx3161 squareroot 0.89 -> 0.943 Inexact Rounded sqtx3162 squareroot 0.089 -> 0.298 Inexact Rounded sqtx3163 squareroot 0.91 -> 0.954 Inexact Rounded sqtx3164 squareroot 0.091 -> 0.302 Inexact Rounded sqtx3165 squareroot 0.92 -> 0.959 Inexact Rounded sqtx3166 squareroot 0.092 -> 0.303 Inexact Rounded sqtx3167 squareroot 0.93 -> 0.964 Inexact Rounded sqtx3168 squareroot 0.093 -> 0.305 Inexact Rounded sqtx3169 squareroot 0.94 -> 0.970 Inexact Rounded sqtx3170 squareroot 0.094 -> 0.307 Inexact Rounded sqtx3171 squareroot 0.95 -> 0.975 Inexact Rounded sqtx3172 squareroot 0.095 -> 0.308 Inexact Rounded sqtx3173 squareroot 0.96 -> 0.980 Inexact Rounded sqtx3174 squareroot 0.096 -> 0.310 Inexact Rounded sqtx3175 squareroot 0.97 -> 0.985 Inexact Rounded sqtx3176 squareroot 0.097 -> 0.311 Inexact Rounded sqtx3177 squareroot 0.98 -> 0.990 Inexact Rounded sqtx3178 squareroot 0.098 -> 0.313 Inexact Rounded sqtx3179 squareroot 0.99 -> 0.995 Inexact Rounded sqtx3180 squareroot 0.099 -> 0.315 Inexact Rounded sqtx3181 squareroot 0.101 -> 0.318 Inexact Rounded sqtx3182 squareroot 0.0101 -> 0.100 Inexact Rounded sqtx3183 squareroot 0.102 -> 0.319 Inexact Rounded sqtx3184 squareroot 0.0102 -> 0.101 Inexact Rounded sqtx3185 squareroot 0.103 -> 0.321 Inexact Rounded sqtx3186 squareroot 0.0103 -> 0.101 Inexact Rounded sqtx3187 squareroot 0.104 -> 0.322 Inexact Rounded sqtx3188 squareroot 0.0104 -> 0.102 Inexact Rounded sqtx3189 squareroot 0.105 -> 0.324 Inexact Rounded sqtx3190 squareroot 0.0105 -> 0.102 Inexact Rounded sqtx3191 squareroot 0.106 -> 0.326 Inexact Rounded sqtx3192 squareroot 0.0106 -> 0.103 Inexact Rounded sqtx3193 squareroot 0.107 -> 0.327 Inexact Rounded sqtx3194 squareroot 0.0107 -> 0.103 Inexact Rounded sqtx3195 squareroot 0.108 -> 0.329 Inexact Rounded sqtx3196 squareroot 0.0108 -> 0.104 Inexact Rounded sqtx3197 squareroot 0.109 -> 0.330 Inexact Rounded sqtx3198 squareroot 0.0109 -> 0.104 Inexact Rounded sqtx3199 squareroot 0.111 -> 0.333 Inexact Rounded sqtx3200 squareroot 0.0111 -> 0.105 Inexact Rounded sqtx3201 squareroot 0.112 -> 0.335 Inexact Rounded sqtx3202 squareroot 0.0112 -> 0.106 Inexact Rounded sqtx3203 squareroot 0.113 -> 0.336 Inexact Rounded sqtx3204 squareroot 0.0113 -> 0.106 Inexact Rounded sqtx3205 squareroot 0.114 -> 0.338 Inexact Rounded sqtx3206 squareroot 0.0114 -> 0.107 Inexact Rounded sqtx3207 squareroot 0.115 -> 0.339 Inexact Rounded sqtx3208 squareroot 0.0115 -> 0.107 Inexact Rounded sqtx3209 squareroot 0.116 -> 0.341 Inexact Rounded sqtx3210 squareroot 0.0116 -> 0.108 Inexact Rounded sqtx3211 squareroot 0.117 -> 0.342 Inexact Rounded sqtx3212 squareroot 0.0117 -> 0.108 Inexact Rounded sqtx3213 squareroot 0.118 -> 0.344 Inexact Rounded sqtx3214 squareroot 0.0118 -> 0.109 Inexact Rounded sqtx3215 squareroot 0.119 -> 0.345 Inexact Rounded sqtx3216 squareroot 0.0119 -> 0.109 Inexact Rounded sqtx3217 squareroot 0.121 -> 0.348 Inexact Rounded sqtx3218 squareroot 0.0121 -> 0.11 sqtx3219 squareroot 0.122 -> 0.349 Inexact Rounded sqtx3220 squareroot 0.0122 -> 0.110 Inexact Rounded sqtx3221 squareroot 0.123 -> 0.351 Inexact Rounded sqtx3222 squareroot 0.0123 -> 0.111 Inexact Rounded sqtx3223 squareroot 0.124 -> 0.352 Inexact Rounded sqtx3224 squareroot 0.0124 -> 0.111 Inexact Rounded sqtx3225 squareroot 0.125 -> 0.354 Inexact Rounded sqtx3226 squareroot 0.0125 -> 0.112 Inexact Rounded sqtx3227 squareroot 0.126 -> 0.355 Inexact Rounded sqtx3228 squareroot 0.0126 -> 0.112 Inexact Rounded sqtx3229 squareroot 0.127 -> 0.356 Inexact Rounded sqtx3230 squareroot 0.0127 -> 0.113 Inexact Rounded sqtx3231 squareroot 0.128 -> 0.358 Inexact Rounded sqtx3232 squareroot 0.0128 -> 0.113 Inexact Rounded sqtx3233 squareroot 0.129 -> 0.359 Inexact Rounded sqtx3234 squareroot 0.0129 -> 0.114 Inexact Rounded sqtx3235 squareroot 0.131 -> 0.362 Inexact Rounded sqtx3236 squareroot 0.0131 -> 0.114 Inexact Rounded sqtx3237 squareroot 0.132 -> 0.363 Inexact Rounded sqtx3238 squareroot 0.0132 -> 0.115 Inexact Rounded sqtx3239 squareroot 0.133 -> 0.365 Inexact Rounded sqtx3240 squareroot 0.0133 -> 0.115 Inexact Rounded sqtx3241 squareroot 0.134 -> 0.366 Inexact Rounded sqtx3242 squareroot 0.0134 -> 0.116 Inexact Rounded sqtx3243 squareroot 0.135 -> 0.367 Inexact Rounded sqtx3244 squareroot 0.0135 -> 0.116 Inexact Rounded sqtx3245 squareroot 0.136 -> 0.369 Inexact Rounded sqtx3246 squareroot 0.0136 -> 0.117 Inexact Rounded sqtx3247 squareroot 0.137 -> 0.370 Inexact Rounded sqtx3248 squareroot 0.0137 -> 0.117 Inexact Rounded sqtx3249 squareroot 0.138 -> 0.371 Inexact Rounded sqtx3250 squareroot 0.0138 -> 0.117 Inexact Rounded sqtx3251 squareroot 0.139 -> 0.373 Inexact Rounded sqtx3252 squareroot 0.0139 -> 0.118 Inexact Rounded sqtx3253 squareroot 0.141 -> 0.375 Inexact Rounded sqtx3254 squareroot 0.0141 -> 0.119 Inexact Rounded sqtx3255 squareroot 0.142 -> 0.377 Inexact Rounded sqtx3256 squareroot 0.0142 -> 0.119 Inexact Rounded sqtx3257 squareroot 0.143 -> 0.378 Inexact Rounded sqtx3258 squareroot 0.0143 -> 0.120 Inexact Rounded sqtx3259 squareroot 0.144 -> 0.379 Inexact Rounded sqtx3260 squareroot 0.0144 -> 0.12 sqtx3261 squareroot 0.145 -> 0.381 Inexact Rounded sqtx3262 squareroot 0.0145 -> 0.120 Inexact Rounded sqtx3263 squareroot 0.146 -> 0.382 Inexact Rounded sqtx3264 squareroot 0.0146 -> 0.121 Inexact Rounded sqtx3265 squareroot 0.147 -> 0.383 Inexact Rounded sqtx3266 squareroot 0.0147 -> 0.121 Inexact Rounded sqtx3267 squareroot 0.148 -> 0.385 Inexact Rounded sqtx3268 squareroot 0.0148 -> 0.122 Inexact Rounded sqtx3269 squareroot 0.149 -> 0.386 Inexact Rounded sqtx3270 squareroot 0.0149 -> 0.122 Inexact Rounded sqtx3271 squareroot 0.151 -> 0.389 Inexact Rounded sqtx3272 squareroot 0.0151 -> 0.123 Inexact Rounded sqtx3273 squareroot 0.152 -> 0.390 Inexact Rounded sqtx3274 squareroot 0.0152 -> 0.123 Inexact Rounded sqtx3275 squareroot 0.153 -> 0.391 Inexact Rounded sqtx3276 squareroot 0.0153 -> 0.124 Inexact Rounded sqtx3277 squareroot 0.154 -> 0.392 Inexact Rounded sqtx3278 squareroot 0.0154 -> 0.124 Inexact Rounded sqtx3279 squareroot 0.155 -> 0.394 Inexact Rounded sqtx3280 squareroot 0.0155 -> 0.124 Inexact Rounded sqtx3281 squareroot 0.156 -> 0.395 Inexact Rounded sqtx3282 squareroot 0.0156 -> 0.125 Inexact Rounded sqtx3283 squareroot 0.157 -> 0.396 Inexact Rounded sqtx3284 squareroot 0.0157 -> 0.125 Inexact Rounded sqtx3285 squareroot 0.158 -> 0.397 Inexact Rounded sqtx3286 squareroot 0.0158 -> 0.126 Inexact Rounded sqtx3287 squareroot 0.159 -> 0.399 Inexact Rounded sqtx3288 squareroot 0.0159 -> 0.126 Inexact Rounded sqtx3289 squareroot 0.161 -> 0.401 Inexact Rounded sqtx3290 squareroot 0.0161 -> 0.127 Inexact Rounded sqtx3291 squareroot 0.162 -> 0.402 Inexact Rounded sqtx3292 squareroot 0.0162 -> 0.127 Inexact Rounded sqtx3293 squareroot 0.163 -> 0.404 Inexact Rounded sqtx3294 squareroot 0.0163 -> 0.128 Inexact Rounded sqtx3295 squareroot 0.164 -> 0.405 Inexact Rounded sqtx3296 squareroot 0.0164 -> 0.128 Inexact Rounded sqtx3297 squareroot 0.165 -> 0.406 Inexact Rounded sqtx3298 squareroot 0.0165 -> 0.128 Inexact Rounded sqtx3299 squareroot 0.166 -> 0.407 Inexact Rounded sqtx3300 squareroot 0.0166 -> 0.129 Inexact Rounded sqtx3301 squareroot 0.167 -> 0.409 Inexact Rounded sqtx3302 squareroot 0.0167 -> 0.129 Inexact Rounded sqtx3303 squareroot 0.168 -> 0.410 Inexact Rounded sqtx3304 squareroot 0.0168 -> 0.130 Inexact Rounded sqtx3305 squareroot 0.169 -> 0.411 Inexact Rounded sqtx3306 squareroot 0.0169 -> 0.13 sqtx3307 squareroot 0.171 -> 0.414 Inexact Rounded sqtx3308 squareroot 0.0171 -> 0.131 Inexact Rounded sqtx3309 squareroot 0.172 -> 0.415 Inexact Rounded sqtx3310 squareroot 0.0172 -> 0.131 Inexact Rounded sqtx3311 squareroot 0.173 -> 0.416 Inexact Rounded sqtx3312 squareroot 0.0173 -> 0.132 Inexact Rounded sqtx3313 squareroot 0.174 -> 0.417 Inexact Rounded sqtx3314 squareroot 0.0174 -> 0.132 Inexact Rounded sqtx3315 squareroot 0.175 -> 0.418 Inexact Rounded sqtx3316 squareroot 0.0175 -> 0.132 Inexact Rounded sqtx3317 squareroot 0.176 -> 0.420 Inexact Rounded sqtx3318 squareroot 0.0176 -> 0.133 Inexact Rounded sqtx3319 squareroot 0.177 -> 0.421 Inexact Rounded sqtx3320 squareroot 0.0177 -> 0.133 Inexact Rounded sqtx3321 squareroot 0.178 -> 0.422 Inexact Rounded sqtx3322 squareroot 0.0178 -> 0.133 Inexact Rounded sqtx3323 squareroot 0.179 -> 0.423 Inexact Rounded sqtx3324 squareroot 0.0179 -> 0.134 Inexact Rounded sqtx3325 squareroot 0.181 -> 0.425 Inexact Rounded sqtx3326 squareroot 0.0181 -> 0.135 Inexact Rounded sqtx3327 squareroot 0.182 -> 0.427 Inexact Rounded sqtx3328 squareroot 0.0182 -> 0.135 Inexact Rounded sqtx3329 squareroot 0.183 -> 0.428 Inexact Rounded sqtx3330 squareroot 0.0183 -> 0.135 Inexact Rounded sqtx3331 squareroot 0.184 -> 0.429 Inexact Rounded sqtx3332 squareroot 0.0184 -> 0.136 Inexact Rounded sqtx3333 squareroot 0.185 -> 0.430 Inexact Rounded sqtx3334 squareroot 0.0185 -> 0.136 Inexact Rounded sqtx3335 squareroot 0.186 -> 0.431 Inexact Rounded sqtx3336 squareroot 0.0186 -> 0.136 Inexact Rounded sqtx3337 squareroot 0.187 -> 0.432 Inexact Rounded sqtx3338 squareroot 0.0187 -> 0.137 Inexact Rounded sqtx3339 squareroot 0.188 -> 0.434 Inexact Rounded sqtx3340 squareroot 0.0188 -> 0.137 Inexact Rounded sqtx3341 squareroot 0.189 -> 0.435 Inexact Rounded sqtx3342 squareroot 0.0189 -> 0.137 Inexact Rounded sqtx3343 squareroot 0.191 -> 0.437 Inexact Rounded sqtx3344 squareroot 0.0191 -> 0.138 Inexact Rounded sqtx3345 squareroot 0.192 -> 0.438 Inexact Rounded sqtx3346 squareroot 0.0192 -> 0.139 Inexact Rounded sqtx3347 squareroot 0.193 -> 0.439 Inexact Rounded sqtx3348 squareroot 0.0193 -> 0.139 Inexact Rounded sqtx3349 squareroot 0.194 -> 0.440 Inexact Rounded sqtx3350 squareroot 0.0194 -> 0.139 Inexact Rounded sqtx3351 squareroot 0.195 -> 0.442 Inexact Rounded sqtx3352 squareroot 0.0195 -> 0.140 Inexact Rounded sqtx3353 squareroot 0.196 -> 0.443 Inexact Rounded sqtx3354 squareroot 0.0196 -> 0.14 sqtx3355 squareroot 0.197 -> 0.444 Inexact Rounded sqtx3356 squareroot 0.0197 -> 0.140 Inexact Rounded sqtx3357 squareroot 0.198 -> 0.445 Inexact Rounded sqtx3358 squareroot 0.0198 -> 0.141 Inexact Rounded sqtx3359 squareroot 0.199 -> 0.446 Inexact Rounded sqtx3360 squareroot 0.0199 -> 0.141 Inexact Rounded sqtx3361 squareroot 0.201 -> 0.448 Inexact Rounded sqtx3362 squareroot 0.0201 -> 0.142 Inexact Rounded sqtx3363 squareroot 0.202 -> 0.449 Inexact Rounded sqtx3364 squareroot 0.0202 -> 0.142 Inexact Rounded sqtx3365 squareroot 0.203 -> 0.451 Inexact Rounded sqtx3366 squareroot 0.0203 -> 0.142 Inexact Rounded sqtx3367 squareroot 0.204 -> 0.452 Inexact Rounded sqtx3368 squareroot 0.0204 -> 0.143 Inexact Rounded sqtx3369 squareroot 0.205 -> 0.453 Inexact Rounded sqtx3370 squareroot 0.0205 -> 0.143 Inexact Rounded sqtx3371 squareroot 0.206 -> 0.454 Inexact Rounded sqtx3372 squareroot 0.0206 -> 0.144 Inexact Rounded sqtx3373 squareroot 0.207 -> 0.455 Inexact Rounded sqtx3374 squareroot 0.0207 -> 0.144 Inexact Rounded sqtx3375 squareroot 0.208 -> 0.456 Inexact Rounded sqtx3376 squareroot 0.0208 -> 0.144 Inexact Rounded sqtx3377 squareroot 0.209 -> 0.457 Inexact Rounded sqtx3378 squareroot 0.0209 -> 0.145 Inexact Rounded sqtx3379 squareroot 0.211 -> 0.459 Inexact Rounded sqtx3380 squareroot 0.0211 -> 0.145 Inexact Rounded sqtx3381 squareroot 0.212 -> 0.460 Inexact Rounded sqtx3382 squareroot 0.0212 -> 0.146 Inexact Rounded sqtx3383 squareroot 0.213 -> 0.462 Inexact Rounded sqtx3384 squareroot 0.0213 -> 0.146 Inexact Rounded sqtx3385 squareroot 0.214 -> 0.463 Inexact Rounded sqtx3386 squareroot 0.0214 -> 0.146 Inexact Rounded sqtx3387 squareroot 0.215 -> 0.464 Inexact Rounded sqtx3388 squareroot 0.0215 -> 0.147 Inexact Rounded sqtx3389 squareroot 0.216 -> 0.465 Inexact Rounded sqtx3390 squareroot 0.0216 -> 0.147 Inexact Rounded sqtx3391 squareroot 0.217 -> 0.466 Inexact Rounded sqtx3392 squareroot 0.0217 -> 0.147 Inexact Rounded sqtx3393 squareroot 0.218 -> 0.467 Inexact Rounded sqtx3394 squareroot 0.0218 -> 0.148 Inexact Rounded sqtx3395 squareroot 0.219 -> 0.468 Inexact Rounded sqtx3396 squareroot 0.0219 -> 0.148 Inexact Rounded sqtx3397 squareroot 0.221 -> 0.470 Inexact Rounded sqtx3398 squareroot 0.0221 -> 0.149 Inexact Rounded sqtx3399 squareroot 0.222 -> 0.471 Inexact Rounded sqtx3400 squareroot 0.0222 -> 0.149 Inexact Rounded sqtx3401 squareroot 0.223 -> 0.472 Inexact Rounded sqtx3402 squareroot 0.0223 -> 0.149 Inexact Rounded sqtx3403 squareroot 0.224 -> 0.473 Inexact Rounded sqtx3404 squareroot 0.0224 -> 0.150 Inexact Rounded sqtx3405 squareroot 0.225 -> 0.474 Inexact Rounded sqtx3406 squareroot 0.0225 -> 0.15 sqtx3407 squareroot 0.226 -> 0.475 Inexact Rounded sqtx3408 squareroot 0.0226 -> 0.150 Inexact Rounded sqtx3409 squareroot 0.227 -> 0.476 Inexact Rounded sqtx3410 squareroot 0.0227 -> 0.151 Inexact Rounded sqtx3411 squareroot 0.228 -> 0.477 Inexact Rounded sqtx3412 squareroot 0.0228 -> 0.151 Inexact Rounded sqtx3413 squareroot 0.229 -> 0.479 Inexact Rounded sqtx3414 squareroot 0.0229 -> 0.151 Inexact Rounded sqtx3415 squareroot 0.231 -> 0.481 Inexact Rounded sqtx3416 squareroot 0.0231 -> 0.152 Inexact Rounded sqtx3417 squareroot 0.232 -> 0.482 Inexact Rounded sqtx3418 squareroot 0.0232 -> 0.152 Inexact Rounded sqtx3419 squareroot 0.233 -> 0.483 Inexact Rounded sqtx3420 squareroot 0.0233 -> 0.153 Inexact Rounded sqtx3421 squareroot 0.234 -> 0.484 Inexact Rounded sqtx3422 squareroot 0.0234 -> 0.153 Inexact Rounded sqtx3423 squareroot 0.235 -> 0.485 Inexact Rounded sqtx3424 squareroot 0.0235 -> 0.153 Inexact Rounded sqtx3425 squareroot 0.236 -> 0.486 Inexact Rounded sqtx3426 squareroot 0.0236 -> 0.154 Inexact Rounded sqtx3427 squareroot 0.237 -> 0.487 Inexact Rounded sqtx3428 squareroot 0.0237 -> 0.154 Inexact Rounded sqtx3429 squareroot 0.238 -> 0.488 Inexact Rounded sqtx3430 squareroot 0.0238 -> 0.154 Inexact Rounded sqtx3431 squareroot 0.239 -> 0.489 Inexact Rounded sqtx3432 squareroot 0.0239 -> 0.155 Inexact Rounded sqtx3433 squareroot 0.241 -> 0.491 Inexact Rounded sqtx3434 squareroot 0.0241 -> 0.155 Inexact Rounded sqtx3435 squareroot 0.242 -> 0.492 Inexact Rounded sqtx3436 squareroot 0.0242 -> 0.156 Inexact Rounded sqtx3437 squareroot 0.243 -> 0.493 Inexact Rounded sqtx3438 squareroot 0.0243 -> 0.156 Inexact Rounded sqtx3439 squareroot 0.244 -> 0.494 Inexact Rounded sqtx3440 squareroot 0.0244 -> 0.156 Inexact Rounded sqtx3441 squareroot 0.245 -> 0.495 Inexact Rounded sqtx3442 squareroot 0.0245 -> 0.157 Inexact Rounded sqtx3443 squareroot 0.246 -> 0.496 Inexact Rounded sqtx3444 squareroot 0.0246 -> 0.157 Inexact Rounded sqtx3445 squareroot 0.247 -> 0.497 Inexact Rounded sqtx3446 squareroot 0.0247 -> 0.157 Inexact Rounded sqtx3447 squareroot 0.248 -> 0.498 Inexact Rounded sqtx3448 squareroot 0.0248 -> 0.157 Inexact Rounded sqtx3449 squareroot 0.249 -> 0.499 Inexact Rounded sqtx3450 squareroot 0.0249 -> 0.158 Inexact Rounded sqtx3451 squareroot 0.251 -> 0.501 Inexact Rounded sqtx3452 squareroot 0.0251 -> 0.158 Inexact Rounded sqtx3453 squareroot 0.252 -> 0.502 Inexact Rounded sqtx3454 squareroot 0.0252 -> 0.159 Inexact Rounded sqtx3455 squareroot 0.253 -> 0.503 Inexact Rounded sqtx3456 squareroot 0.0253 -> 0.159 Inexact Rounded sqtx3457 squareroot 0.254 -> 0.504 Inexact Rounded sqtx3458 squareroot 0.0254 -> 0.159 Inexact Rounded sqtx3459 squareroot 0.255 -> 0.505 Inexact Rounded sqtx3460 squareroot 0.0255 -> 0.160 Inexact Rounded sqtx3461 squareroot 0.256 -> 0.506 Inexact Rounded sqtx3462 squareroot 0.0256 -> 0.16 sqtx3463 squareroot 0.257 -> 0.507 Inexact Rounded sqtx3464 squareroot 0.0257 -> 0.160 Inexact Rounded sqtx3465 squareroot 0.258 -> 0.508 Inexact Rounded sqtx3466 squareroot 0.0258 -> 0.161 Inexact Rounded sqtx3467 squareroot 0.259 -> 0.509 Inexact Rounded sqtx3468 squareroot 0.0259 -> 0.161 Inexact Rounded sqtx3469 squareroot 0.261 -> 0.511 Inexact Rounded sqtx3470 squareroot 0.0261 -> 0.162 Inexact Rounded sqtx3471 squareroot 0.262 -> 0.512 Inexact Rounded sqtx3472 squareroot 0.0262 -> 0.162 Inexact Rounded sqtx3473 squareroot 0.263 -> 0.513 Inexact Rounded sqtx3474 squareroot 0.0263 -> 0.162 Inexact Rounded sqtx3475 squareroot 0.264 -> 0.514 Inexact Rounded sqtx3476 squareroot 0.0264 -> 0.162 Inexact Rounded sqtx3477 squareroot 0.265 -> 0.515 Inexact Rounded sqtx3478 squareroot 0.0265 -> 0.163 Inexact Rounded sqtx3479 squareroot 0.266 -> 0.516 Inexact Rounded sqtx3480 squareroot 0.0266 -> 0.163 Inexact Rounded sqtx3481 squareroot 0.267 -> 0.517 Inexact Rounded sqtx3482 squareroot 0.0267 -> 0.163 Inexact Rounded sqtx3483 squareroot 0.268 -> 0.518 Inexact Rounded sqtx3484 squareroot 0.0268 -> 0.164 Inexact Rounded sqtx3485 squareroot 0.269 -> 0.519 Inexact Rounded sqtx3486 squareroot 0.0269 -> 0.164 Inexact Rounded sqtx3487 squareroot 0.271 -> 0.521 Inexact Rounded sqtx3488 squareroot 0.0271 -> 0.165 Inexact Rounded sqtx3489 squareroot 0.272 -> 0.522 Inexact Rounded sqtx3490 squareroot 0.0272 -> 0.165 Inexact Rounded sqtx3491 squareroot 0.273 -> 0.522 Inexact Rounded sqtx3492 squareroot 0.0273 -> 0.165 Inexact Rounded sqtx3493 squareroot 0.274 -> 0.523 Inexact Rounded sqtx3494 squareroot 0.0274 -> 0.166 Inexact Rounded sqtx3495 squareroot 0.275 -> 0.524 Inexact Rounded sqtx3496 squareroot 0.0275 -> 0.166 Inexact Rounded sqtx3497 squareroot 0.276 -> 0.525 Inexact Rounded sqtx3498 squareroot 0.0276 -> 0.166 Inexact Rounded sqtx3499 squareroot 0.277 -> 0.526 Inexact Rounded sqtx3500 squareroot 0.0277 -> 0.166 Inexact Rounded sqtx3501 squareroot 0.278 -> 0.527 Inexact Rounded sqtx3502 squareroot 0.0278 -> 0.167 Inexact Rounded sqtx3503 squareroot 0.279 -> 0.528 Inexact Rounded sqtx3504 squareroot 0.0279 -> 0.167 Inexact Rounded sqtx3505 squareroot 0.281 -> 0.530 Inexact Rounded sqtx3506 squareroot 0.0281 -> 0.168 Inexact Rounded sqtx3507 squareroot 0.282 -> 0.531 Inexact Rounded sqtx3508 squareroot 0.0282 -> 0.168 Inexact Rounded sqtx3509 squareroot 0.283 -> 0.532 Inexact Rounded sqtx3510 squareroot 0.0283 -> 0.168 Inexact Rounded sqtx3511 squareroot 0.284 -> 0.533 Inexact Rounded sqtx3512 squareroot 0.0284 -> 0.169 Inexact Rounded sqtx3513 squareroot 0.285 -> 0.534 Inexact Rounded sqtx3514 squareroot 0.0285 -> 0.169 Inexact Rounded sqtx3515 squareroot 0.286 -> 0.535 Inexact Rounded sqtx3516 squareroot 0.0286 -> 0.169 Inexact Rounded sqtx3517 squareroot 0.287 -> 0.536 Inexact Rounded sqtx3518 squareroot 0.0287 -> 0.169 Inexact Rounded sqtx3519 squareroot 0.288 -> 0.537 Inexact Rounded sqtx3520 squareroot 0.0288 -> 0.170 Inexact Rounded sqtx3521 squareroot 0.289 -> 0.538 Inexact Rounded sqtx3522 squareroot 0.0289 -> 0.17 sqtx3523 squareroot 0.291 -> 0.539 Inexact Rounded sqtx3524 squareroot 0.0291 -> 0.171 Inexact Rounded sqtx3525 squareroot 0.292 -> 0.540 Inexact Rounded sqtx3526 squareroot 0.0292 -> 0.171 Inexact Rounded sqtx3527 squareroot 0.293 -> 0.541 Inexact Rounded sqtx3528 squareroot 0.0293 -> 0.171 Inexact Rounded sqtx3529 squareroot 0.294 -> 0.542 Inexact Rounded sqtx3530 squareroot 0.0294 -> 0.171 Inexact Rounded sqtx3531 squareroot 0.295 -> 0.543 Inexact Rounded sqtx3532 squareroot 0.0295 -> 0.172 Inexact Rounded sqtx3533 squareroot 0.296 -> 0.544 Inexact Rounded sqtx3534 squareroot 0.0296 -> 0.172 Inexact Rounded sqtx3535 squareroot 0.297 -> 0.545 Inexact Rounded sqtx3536 squareroot 0.0297 -> 0.172 Inexact Rounded sqtx3537 squareroot 0.298 -> 0.546 Inexact Rounded sqtx3538 squareroot 0.0298 -> 0.173 Inexact Rounded sqtx3539 squareroot 0.299 -> 0.547 Inexact Rounded sqtx3540 squareroot 0.0299 -> 0.173 Inexact Rounded sqtx3541 squareroot 0.301 -> 0.549 Inexact Rounded sqtx3542 squareroot 0.0301 -> 0.173 Inexact Rounded sqtx3543 squareroot 0.302 -> 0.550 Inexact Rounded sqtx3544 squareroot 0.0302 -> 0.174 Inexact Rounded sqtx3545 squareroot 0.303 -> 0.550 Inexact Rounded sqtx3546 squareroot 0.0303 -> 0.174 Inexact Rounded sqtx3547 squareroot 0.304 -> 0.551 Inexact Rounded sqtx3548 squareroot 0.0304 -> 0.174 Inexact Rounded sqtx3549 squareroot 0.305 -> 0.552 Inexact Rounded sqtx3550 squareroot 0.0305 -> 0.175 Inexact Rounded sqtx3551 squareroot 0.306 -> 0.553 Inexact Rounded sqtx3552 squareroot 0.0306 -> 0.175 Inexact Rounded sqtx3553 squareroot 0.307 -> 0.554 Inexact Rounded sqtx3554 squareroot 0.0307 -> 0.175 Inexact Rounded sqtx3555 squareroot 0.308 -> 0.555 Inexact Rounded sqtx3556 squareroot 0.0308 -> 0.175 Inexact Rounded sqtx3557 squareroot 0.309 -> 0.556 Inexact Rounded sqtx3558 squareroot 0.0309 -> 0.176 Inexact Rounded sqtx3559 squareroot 0.311 -> 0.558 Inexact Rounded sqtx3560 squareroot 0.0311 -> 0.176 Inexact Rounded sqtx3561 squareroot 0.312 -> 0.559 Inexact Rounded sqtx3562 squareroot 0.0312 -> 0.177 Inexact Rounded sqtx3563 squareroot 0.313 -> 0.559 Inexact Rounded sqtx3564 squareroot 0.0313 -> 0.177 Inexact Rounded sqtx3565 squareroot 0.314 -> 0.560 Inexact Rounded sqtx3566 squareroot 0.0314 -> 0.177 Inexact Rounded sqtx3567 squareroot 0.315 -> 0.561 Inexact Rounded sqtx3568 squareroot 0.0315 -> 0.177 Inexact Rounded sqtx3569 squareroot 0.316 -> 0.562 Inexact Rounded sqtx3570 squareroot 0.0316 -> 0.178 Inexact Rounded sqtx3571 squareroot 0.317 -> 0.563 Inexact Rounded sqtx3572 squareroot 0.0317 -> 0.178 Inexact Rounded sqtx3573 squareroot 0.318 -> 0.564 Inexact Rounded sqtx3574 squareroot 0.0318 -> 0.178 Inexact Rounded sqtx3575 squareroot 0.319 -> 0.565 Inexact Rounded sqtx3576 squareroot 0.0319 -> 0.179 Inexact Rounded sqtx3577 squareroot 0.321 -> 0.567 Inexact Rounded sqtx3578 squareroot 0.0321 -> 0.179 Inexact Rounded sqtx3579 squareroot 0.322 -> 0.567 Inexact Rounded sqtx3580 squareroot 0.0322 -> 0.179 Inexact Rounded sqtx3581 squareroot 0.323 -> 0.568 Inexact Rounded sqtx3582 squareroot 0.0323 -> 0.180 Inexact Rounded sqtx3583 squareroot 0.324 -> 0.569 Inexact Rounded sqtx3584 squareroot 0.0324 -> 0.18 sqtx3585 squareroot 0.325 -> 0.570 Inexact Rounded sqtx3586 squareroot 0.0325 -> 0.180 Inexact Rounded sqtx3587 squareroot 0.326 -> 0.571 Inexact Rounded sqtx3588 squareroot 0.0326 -> 0.181 Inexact Rounded sqtx3589 squareroot 0.327 -> 0.572 Inexact Rounded sqtx3590 squareroot 0.0327 -> 0.181 Inexact Rounded sqtx3591 squareroot 0.328 -> 0.573 Inexact Rounded sqtx3592 squareroot 0.0328 -> 0.181 Inexact Rounded sqtx3593 squareroot 0.329 -> 0.574 Inexact Rounded sqtx3594 squareroot 0.0329 -> 0.181 Inexact Rounded sqtx3595 squareroot 0.331 -> 0.575 Inexact Rounded sqtx3596 squareroot 0.0331 -> 0.182 Inexact Rounded sqtx3597 squareroot 0.332 -> 0.576 Inexact Rounded sqtx3598 squareroot 0.0332 -> 0.182 Inexact Rounded sqtx3599 squareroot 0.333 -> 0.577 Inexact Rounded sqtx3600 squareroot 0.0333 -> 0.182 Inexact Rounded sqtx3601 squareroot 0.334 -> 0.578 Inexact Rounded sqtx3602 squareroot 0.0334 -> 0.183 Inexact Rounded sqtx3603 squareroot 0.335 -> 0.579 Inexact Rounded sqtx3604 squareroot 0.0335 -> 0.183 Inexact Rounded sqtx3605 squareroot 0.336 -> 0.580 Inexact Rounded sqtx3606 squareroot 0.0336 -> 0.183 Inexact Rounded sqtx3607 squareroot 0.337 -> 0.581 Inexact Rounded sqtx3608 squareroot 0.0337 -> 0.184 Inexact Rounded sqtx3609 squareroot 0.338 -> 0.581 Inexact Rounded sqtx3610 squareroot 0.0338 -> 0.184 Inexact Rounded sqtx3611 squareroot 0.339 -> 0.582 Inexact Rounded sqtx3612 squareroot 0.0339 -> 0.184 Inexact Rounded sqtx3613 squareroot 0.341 -> 0.584 Inexact Rounded sqtx3614 squareroot 0.0341 -> 0.185 Inexact Rounded sqtx3615 squareroot 0.342 -> 0.585 Inexact Rounded sqtx3616 squareroot 0.0342 -> 0.185 Inexact Rounded sqtx3617 squareroot 0.343 -> 0.586 Inexact Rounded sqtx3618 squareroot 0.0343 -> 0.185 Inexact Rounded sqtx3619 squareroot 0.344 -> 0.587 Inexact Rounded sqtx3620 squareroot 0.0344 -> 0.185 Inexact Rounded sqtx3621 squareroot 0.345 -> 0.587 Inexact Rounded sqtx3622 squareroot 0.0345 -> 0.186 Inexact Rounded sqtx3623 squareroot 0.346 -> 0.588 Inexact Rounded sqtx3624 squareroot 0.0346 -> 0.186 Inexact Rounded sqtx3625 squareroot 0.347 -> 0.589 Inexact Rounded sqtx3626 squareroot 0.0347 -> 0.186 Inexact Rounded sqtx3627 squareroot 0.348 -> 0.590 Inexact Rounded sqtx3628 squareroot 0.0348 -> 0.187 Inexact Rounded sqtx3629 squareroot 0.349 -> 0.591 Inexact Rounded sqtx3630 squareroot 0.0349 -> 0.187 Inexact Rounded sqtx3631 squareroot 0.351 -> 0.592 Inexact Rounded sqtx3632 squareroot 0.0351 -> 0.187 Inexact Rounded sqtx3633 squareroot 0.352 -> 0.593 Inexact Rounded sqtx3634 squareroot 0.0352 -> 0.188 Inexact Rounded sqtx3635 squareroot 0.353 -> 0.594 Inexact Rounded sqtx3636 squareroot 0.0353 -> 0.188 Inexact Rounded sqtx3637 squareroot 0.354 -> 0.595 Inexact Rounded sqtx3638 squareroot 0.0354 -> 0.188 Inexact Rounded sqtx3639 squareroot 0.355 -> 0.596 Inexact Rounded sqtx3640 squareroot 0.0355 -> 0.188 Inexact Rounded sqtx3641 squareroot 0.356 -> 0.597 Inexact Rounded sqtx3642 squareroot 0.0356 -> 0.189 Inexact Rounded sqtx3643 squareroot 0.357 -> 0.597 Inexact Rounded sqtx3644 squareroot 0.0357 -> 0.189 Inexact Rounded sqtx3645 squareroot 0.358 -> 0.598 Inexact Rounded sqtx3646 squareroot 0.0358 -> 0.189 Inexact Rounded sqtx3647 squareroot 0.359 -> 0.599 Inexact Rounded sqtx3648 squareroot 0.0359 -> 0.189 Inexact Rounded sqtx3649 squareroot 0.361 -> 0.601 Inexact Rounded sqtx3650 squareroot 0.0361 -> 0.19 sqtx3651 squareroot 0.362 -> 0.602 Inexact Rounded sqtx3652 squareroot 0.0362 -> 0.190 Inexact Rounded sqtx3653 squareroot 0.363 -> 0.602 Inexact Rounded sqtx3654 squareroot 0.0363 -> 0.191 Inexact Rounded sqtx3655 squareroot 0.364 -> 0.603 Inexact Rounded sqtx3656 squareroot 0.0364 -> 0.191 Inexact Rounded sqtx3657 squareroot 0.365 -> 0.604 Inexact Rounded sqtx3658 squareroot 0.0365 -> 0.191 Inexact Rounded sqtx3659 squareroot 0.366 -> 0.605 Inexact Rounded sqtx3660 squareroot 0.0366 -> 0.191 Inexact Rounded sqtx3661 squareroot 0.367 -> 0.606 Inexact Rounded sqtx3662 squareroot 0.0367 -> 0.192 Inexact Rounded sqtx3663 squareroot 0.368 -> 0.607 Inexact Rounded sqtx3664 squareroot 0.0368 -> 0.192 Inexact Rounded sqtx3665 squareroot 0.369 -> 0.607 Inexact Rounded sqtx3666 squareroot 0.0369 -> 0.192 Inexact Rounded sqtx3667 squareroot 0.371 -> 0.609 Inexact Rounded sqtx3668 squareroot 0.0371 -> 0.193 Inexact Rounded sqtx3669 squareroot 0.372 -> 0.610 Inexact Rounded sqtx3670 squareroot 0.0372 -> 0.193 Inexact Rounded sqtx3671 squareroot 0.373 -> 0.611 Inexact Rounded sqtx3672 squareroot 0.0373 -> 0.193 Inexact Rounded sqtx3673 squareroot 0.374 -> 0.612 Inexact Rounded sqtx3674 squareroot 0.0374 -> 0.193 Inexact Rounded sqtx3675 squareroot 0.375 -> 0.612 Inexact Rounded sqtx3676 squareroot 0.0375 -> 0.194 Inexact Rounded sqtx3677 squareroot 0.376 -> 0.613 Inexact Rounded sqtx3678 squareroot 0.0376 -> 0.194 Inexact Rounded sqtx3679 squareroot 0.377 -> 0.614 Inexact Rounded sqtx3680 squareroot 0.0377 -> 0.194 Inexact Rounded sqtx3681 squareroot 0.378 -> 0.615 Inexact Rounded sqtx3682 squareroot 0.0378 -> 0.194 Inexact Rounded sqtx3683 squareroot 0.379 -> 0.616 Inexact Rounded sqtx3684 squareroot 0.0379 -> 0.195 Inexact Rounded sqtx3685 squareroot 0.381 -> 0.617 Inexact Rounded sqtx3686 squareroot 0.0381 -> 0.195 Inexact Rounded sqtx3687 squareroot 0.382 -> 0.618 Inexact Rounded sqtx3688 squareroot 0.0382 -> 0.195 Inexact Rounded sqtx3689 squareroot 0.383 -> 0.619 Inexact Rounded sqtx3690 squareroot 0.0383 -> 0.196 Inexact Rounded sqtx3691 squareroot 0.384 -> 0.620 Inexact Rounded sqtx3692 squareroot 0.0384 -> 0.196 Inexact Rounded sqtx3693 squareroot 0.385 -> 0.620 Inexact Rounded sqtx3694 squareroot 0.0385 -> 0.196 Inexact Rounded sqtx3695 squareroot 0.386 -> 0.621 Inexact Rounded sqtx3696 squareroot 0.0386 -> 0.196 Inexact Rounded sqtx3697 squareroot 0.387 -> 0.622 Inexact Rounded sqtx3698 squareroot 0.0387 -> 0.197 Inexact Rounded sqtx3699 squareroot 0.388 -> 0.623 Inexact Rounded sqtx3700 squareroot 0.0388 -> 0.197 Inexact Rounded sqtx3701 squareroot 0.389 -> 0.624 Inexact Rounded sqtx3702 squareroot 0.0389 -> 0.197 Inexact Rounded sqtx3703 squareroot 0.391 -> 0.625 Inexact Rounded sqtx3704 squareroot 0.0391 -> 0.198 Inexact Rounded sqtx3705 squareroot 0.392 -> 0.626 Inexact Rounded sqtx3706 squareroot 0.0392 -> 0.198 Inexact Rounded sqtx3707 squareroot 0.393 -> 0.627 Inexact Rounded sqtx3708 squareroot 0.0393 -> 0.198 Inexact Rounded sqtx3709 squareroot 0.394 -> 0.628 Inexact Rounded sqtx3710 squareroot 0.0394 -> 0.198 Inexact Rounded sqtx3711 squareroot 0.395 -> 0.628 Inexact Rounded sqtx3712 squareroot 0.0395 -> 0.199 Inexact Rounded sqtx3713 squareroot 0.396 -> 0.629 Inexact Rounded sqtx3714 squareroot 0.0396 -> 0.199 Inexact Rounded sqtx3715 squareroot 0.397 -> 0.630 Inexact Rounded sqtx3716 squareroot 0.0397 -> 0.199 Inexact Rounded sqtx3717 squareroot 0.398 -> 0.631 Inexact Rounded sqtx3718 squareroot 0.0398 -> 0.199 Inexact Rounded sqtx3719 squareroot 0.399 -> 0.632 Inexact Rounded sqtx3720 squareroot 0.0399 -> 0.200 Inexact Rounded sqtx3721 squareroot 0.401 -> 0.633 Inexact Rounded sqtx3722 squareroot 0.0401 -> 0.200 Inexact Rounded sqtx3723 squareroot 0.402 -> 0.634 Inexact Rounded sqtx3724 squareroot 0.0402 -> 0.200 Inexact Rounded sqtx3725 squareroot 0.403 -> 0.635 Inexact Rounded sqtx3726 squareroot 0.0403 -> 0.201 Inexact Rounded sqtx3727 squareroot 0.404 -> 0.636 Inexact Rounded sqtx3728 squareroot 0.0404 -> 0.201 Inexact Rounded sqtx3729 squareroot 0.405 -> 0.636 Inexact Rounded sqtx3730 squareroot 0.0405 -> 0.201 Inexact Rounded sqtx3731 squareroot 0.406 -> 0.637 Inexact Rounded sqtx3732 squareroot 0.0406 -> 0.201 Inexact Rounded sqtx3733 squareroot 0.407 -> 0.638 Inexact Rounded sqtx3734 squareroot 0.0407 -> 0.202 Inexact Rounded sqtx3735 squareroot 0.408 -> 0.639 Inexact Rounded sqtx3736 squareroot 0.0408 -> 0.202 Inexact Rounded sqtx3737 squareroot 0.409 -> 0.640 Inexact Rounded sqtx3738 squareroot 0.0409 -> 0.202 Inexact Rounded sqtx3739 squareroot 0.411 -> 0.641 Inexact Rounded sqtx3740 squareroot 0.0411 -> 0.203 Inexact Rounded sqtx3741 squareroot 0.412 -> 0.642 Inexact Rounded sqtx3742 squareroot 0.0412 -> 0.203 Inexact Rounded sqtx3743 squareroot 0.413 -> 0.643 Inexact Rounded sqtx3744 squareroot 0.0413 -> 0.203 Inexact Rounded sqtx3745 squareroot 0.414 -> 0.643 Inexact Rounded sqtx3746 squareroot 0.0414 -> 0.203 Inexact Rounded sqtx3747 squareroot 0.415 -> 0.644 Inexact Rounded sqtx3748 squareroot 0.0415 -> 0.204 Inexact Rounded sqtx3749 squareroot 0.416 -> 0.645 Inexact Rounded sqtx3750 squareroot 0.0416 -> 0.204 Inexact Rounded sqtx3751 squareroot 0.417 -> 0.646 Inexact Rounded sqtx3752 squareroot 0.0417 -> 0.204 Inexact Rounded sqtx3753 squareroot 0.418 -> 0.647 Inexact Rounded sqtx3754 squareroot 0.0418 -> 0.204 Inexact Rounded sqtx3755 squareroot 0.419 -> 0.647 Inexact Rounded sqtx3756 squareroot 0.0419 -> 0.205 Inexact Rounded sqtx3757 squareroot 0.421 -> 0.649 Inexact Rounded sqtx3758 squareroot 0.0421 -> 0.205 Inexact Rounded sqtx3759 squareroot 0.422 -> 0.650 Inexact Rounded sqtx3760 squareroot 0.0422 -> 0.205 Inexact Rounded sqtx3761 squareroot 0.423 -> 0.650 Inexact Rounded sqtx3762 squareroot 0.0423 -> 0.206 Inexact Rounded sqtx3763 squareroot 0.424 -> 0.651 Inexact Rounded sqtx3764 squareroot 0.0424 -> 0.206 Inexact Rounded sqtx3765 squareroot 0.425 -> 0.652 Inexact Rounded sqtx3766 squareroot 0.0425 -> 0.206 Inexact Rounded sqtx3767 squareroot 0.426 -> 0.653 Inexact Rounded sqtx3768 squareroot 0.0426 -> 0.206 Inexact Rounded sqtx3769 squareroot 0.427 -> 0.653 Inexact Rounded sqtx3770 squareroot 0.0427 -> 0.207 Inexact Rounded sqtx3771 squareroot 0.428 -> 0.654 Inexact Rounded sqtx3772 squareroot 0.0428 -> 0.207 Inexact Rounded sqtx3773 squareroot 0.429 -> 0.655 Inexact Rounded sqtx3774 squareroot 0.0429 -> 0.207 Inexact Rounded sqtx3775 squareroot 0.431 -> 0.657 Inexact Rounded sqtx3776 squareroot 0.0431 -> 0.208 Inexact Rounded sqtx3777 squareroot 0.432 -> 0.657 Inexact Rounded sqtx3778 squareroot 0.0432 -> 0.208 Inexact Rounded sqtx3779 squareroot 0.433 -> 0.658 Inexact Rounded sqtx3780 squareroot 0.0433 -> 0.208 Inexact Rounded sqtx3781 squareroot 0.434 -> 0.659 Inexact Rounded sqtx3782 squareroot 0.0434 -> 0.208 Inexact Rounded sqtx3783 squareroot 0.435 -> 0.660 Inexact Rounded sqtx3784 squareroot 0.0435 -> 0.209 Inexact Rounded sqtx3785 squareroot 0.436 -> 0.660 Inexact Rounded sqtx3786 squareroot 0.0436 -> 0.209 Inexact Rounded sqtx3787 squareroot 0.437 -> 0.661 Inexact Rounded sqtx3788 squareroot 0.0437 -> 0.209 Inexact Rounded sqtx3789 squareroot 0.438 -> 0.662 Inexact Rounded sqtx3790 squareroot 0.0438 -> 0.209 Inexact Rounded sqtx3791 squareroot 0.439 -> 0.663 Inexact Rounded sqtx3792 squareroot 0.0439 -> 0.210 Inexact Rounded sqtx3793 squareroot 0.441 -> 0.664 Inexact Rounded sqtx3794 squareroot 0.0441 -> 0.21 sqtx3795 squareroot 0.442 -> 0.665 Inexact Rounded sqtx3796 squareroot 0.0442 -> 0.210 Inexact Rounded sqtx3797 squareroot 0.443 -> 0.666 Inexact Rounded sqtx3798 squareroot 0.0443 -> 0.210 Inexact Rounded sqtx3799 squareroot 0.444 -> 0.666 Inexact Rounded sqtx3800 squareroot 0.0444 -> 0.211 Inexact Rounded sqtx3801 squareroot 0.445 -> 0.667 Inexact Rounded sqtx3802 squareroot 0.0445 -> 0.211 Inexact Rounded sqtx3803 squareroot 0.446 -> 0.668 Inexact Rounded sqtx3804 squareroot 0.0446 -> 0.211 Inexact Rounded sqtx3805 squareroot 0.447 -> 0.669 Inexact Rounded sqtx3806 squareroot 0.0447 -> 0.211 Inexact Rounded sqtx3807 squareroot 0.448 -> 0.669 Inexact Rounded sqtx3808 squareroot 0.0448 -> 0.212 Inexact Rounded sqtx3809 squareroot 0.449 -> 0.670 Inexact Rounded sqtx3810 squareroot 0.0449 -> 0.212 Inexact Rounded sqtx3811 squareroot 0.451 -> 0.672 Inexact Rounded sqtx3812 squareroot 0.0451 -> 0.212 Inexact Rounded sqtx3813 squareroot 0.452 -> 0.672 Inexact Rounded sqtx3814 squareroot 0.0452 -> 0.213 Inexact Rounded sqtx3815 squareroot 0.453 -> 0.673 Inexact Rounded sqtx3816 squareroot 0.0453 -> 0.213 Inexact Rounded sqtx3817 squareroot 0.454 -> 0.674 Inexact Rounded sqtx3818 squareroot 0.0454 -> 0.213 Inexact Rounded sqtx3819 squareroot 0.455 -> 0.675 Inexact Rounded sqtx3820 squareroot 0.0455 -> 0.213 Inexact Rounded sqtx3821 squareroot 0.456 -> 0.675 Inexact Rounded sqtx3822 squareroot 0.0456 -> 0.214 Inexact Rounded sqtx3823 squareroot 0.457 -> 0.676 Inexact Rounded sqtx3824 squareroot 0.0457 -> 0.214 Inexact Rounded sqtx3825 squareroot 0.458 -> 0.677 Inexact Rounded sqtx3826 squareroot 0.0458 -> 0.214 Inexact Rounded sqtx3827 squareroot 0.459 -> 0.677 Inexact Rounded sqtx3828 squareroot 0.0459 -> 0.214 Inexact Rounded sqtx3829 squareroot 0.461 -> 0.679 Inexact Rounded sqtx3830 squareroot 0.0461 -> 0.215 Inexact Rounded sqtx3831 squareroot 0.462 -> 0.680 Inexact Rounded sqtx3832 squareroot 0.0462 -> 0.215 Inexact Rounded sqtx3833 squareroot 0.463 -> 0.680 Inexact Rounded sqtx3834 squareroot 0.0463 -> 0.215 Inexact Rounded sqtx3835 squareroot 0.464 -> 0.681 Inexact Rounded sqtx3836 squareroot 0.0464 -> 0.215 Inexact Rounded sqtx3837 squareroot 0.465 -> 0.682 Inexact Rounded sqtx3838 squareroot 0.0465 -> 0.216 Inexact Rounded sqtx3839 squareroot 0.466 -> 0.683 Inexact Rounded sqtx3840 squareroot 0.0466 -> 0.216 Inexact Rounded sqtx3841 squareroot 0.467 -> 0.683 Inexact Rounded sqtx3842 squareroot 0.0467 -> 0.216 Inexact Rounded sqtx3843 squareroot 0.468 -> 0.684 Inexact Rounded sqtx3844 squareroot 0.0468 -> 0.216 Inexact Rounded sqtx3845 squareroot 0.469 -> 0.685 Inexact Rounded sqtx3846 squareroot 0.0469 -> 0.217 Inexact Rounded sqtx3847 squareroot 0.471 -> 0.686 Inexact Rounded sqtx3848 squareroot 0.0471 -> 0.217 Inexact Rounded sqtx3849 squareroot 0.472 -> 0.687 Inexact Rounded sqtx3850 squareroot 0.0472 -> 0.217 Inexact Rounded sqtx3851 squareroot 0.473 -> 0.688 Inexact Rounded sqtx3852 squareroot 0.0473 -> 0.217 Inexact Rounded sqtx3853 squareroot 0.474 -> 0.688 Inexact Rounded sqtx3854 squareroot 0.0474 -> 0.218 Inexact Rounded sqtx3855 squareroot 0.475 -> 0.689 Inexact Rounded sqtx3856 squareroot 0.0475 -> 0.218 Inexact Rounded sqtx3857 squareroot 0.476 -> 0.690 Inexact Rounded sqtx3858 squareroot 0.0476 -> 0.218 Inexact Rounded sqtx3859 squareroot 0.477 -> 0.691 Inexact Rounded sqtx3860 squareroot 0.0477 -> 0.218 Inexact Rounded sqtx3861 squareroot 0.478 -> 0.691 Inexact Rounded sqtx3862 squareroot 0.0478 -> 0.219 Inexact Rounded sqtx3863 squareroot 0.479 -> 0.692 Inexact Rounded sqtx3864 squareroot 0.0479 -> 0.219 Inexact Rounded sqtx3865 squareroot 0.481 -> 0.694 Inexact Rounded sqtx3866 squareroot 0.0481 -> 0.219 Inexact Rounded sqtx3867 squareroot 0.482 -> 0.694 Inexact Rounded sqtx3868 squareroot 0.0482 -> 0.220 Inexact Rounded sqtx3869 squareroot 0.483 -> 0.695 Inexact Rounded sqtx3870 squareroot 0.0483 -> 0.220 Inexact Rounded sqtx3871 squareroot 0.484 -> 0.696 Inexact Rounded sqtx3872 squareroot 0.0484 -> 0.22 sqtx3873 squareroot 0.485 -> 0.696 Inexact Rounded sqtx3874 squareroot 0.0485 -> 0.220 Inexact Rounded sqtx3875 squareroot 0.486 -> 0.697 Inexact Rounded sqtx3876 squareroot 0.0486 -> 0.220 Inexact Rounded sqtx3877 squareroot 0.487 -> 0.698 Inexact Rounded sqtx3878 squareroot 0.0487 -> 0.221 Inexact Rounded sqtx3879 squareroot 0.488 -> 0.699 Inexact Rounded sqtx3880 squareroot 0.0488 -> 0.221 Inexact Rounded sqtx3881 squareroot 0.489 -> 0.699 Inexact Rounded sqtx3882 squareroot 0.0489 -> 0.221 Inexact Rounded sqtx3883 squareroot 0.491 -> 0.701 Inexact Rounded sqtx3884 squareroot 0.0491 -> 0.222 Inexact Rounded sqtx3885 squareroot 0.492 -> 0.701 Inexact Rounded sqtx3886 squareroot 0.0492 -> 0.222 Inexact Rounded sqtx3887 squareroot 0.493 -> 0.702 Inexact Rounded sqtx3888 squareroot 0.0493 -> 0.222 Inexact Rounded sqtx3889 squareroot 0.494 -> 0.703 Inexact Rounded sqtx3890 squareroot 0.0494 -> 0.222 Inexact Rounded sqtx3891 squareroot 0.495 -> 0.704 Inexact Rounded sqtx3892 squareroot 0.0495 -> 0.222 Inexact Rounded sqtx3893 squareroot 0.496 -> 0.704 Inexact Rounded sqtx3894 squareroot 0.0496 -> 0.223 Inexact Rounded sqtx3895 squareroot 0.497 -> 0.705 Inexact Rounded sqtx3896 squareroot 0.0497 -> 0.223 Inexact Rounded sqtx3897 squareroot 0.498 -> 0.706 Inexact Rounded sqtx3898 squareroot 0.0498 -> 0.223 Inexact Rounded sqtx3899 squareroot 0.499 -> 0.706 Inexact Rounded sqtx3900 squareroot 0.0499 -> 0.223 Inexact Rounded sqtx3901 squareroot 0.501 -> 0.708 Inexact Rounded sqtx3902 squareroot 0.0501 -> 0.224 Inexact Rounded sqtx3903 squareroot 0.502 -> 0.709 Inexact Rounded sqtx3904 squareroot 0.0502 -> 0.224 Inexact Rounded sqtx3905 squareroot 0.503 -> 0.709 Inexact Rounded sqtx3906 squareroot 0.0503 -> 0.224 Inexact Rounded sqtx3907 squareroot 0.504 -> 0.710 Inexact Rounded sqtx3908 squareroot 0.0504 -> 0.224 Inexact Rounded sqtx3909 squareroot 0.505 -> 0.711 Inexact Rounded sqtx3910 squareroot 0.0505 -> 0.225 Inexact Rounded sqtx3911 squareroot 0.506 -> 0.711 Inexact Rounded sqtx3912 squareroot 0.0506 -> 0.225 Inexact Rounded sqtx3913 squareroot 0.507 -> 0.712 Inexact Rounded sqtx3914 squareroot 0.0507 -> 0.225 Inexact Rounded sqtx3915 squareroot 0.508 -> 0.713 Inexact Rounded sqtx3916 squareroot 0.0508 -> 0.225 Inexact Rounded sqtx3917 squareroot 0.509 -> 0.713 Inexact Rounded sqtx3918 squareroot 0.0509 -> 0.226 Inexact Rounded sqtx3919 squareroot 0.511 -> 0.715 Inexact Rounded sqtx3920 squareroot 0.0511 -> 0.226 Inexact Rounded sqtx3921 squareroot 0.512 -> 0.716 Inexact Rounded sqtx3922 squareroot 0.0512 -> 0.226 Inexact Rounded sqtx3923 squareroot 0.513 -> 0.716 Inexact Rounded sqtx3924 squareroot 0.0513 -> 0.226 Inexact Rounded sqtx3925 squareroot 0.514 -> 0.717 Inexact Rounded sqtx3926 squareroot 0.0514 -> 0.227 Inexact Rounded sqtx3927 squareroot 0.515 -> 0.718 Inexact Rounded sqtx3928 squareroot 0.0515 -> 0.227 Inexact Rounded sqtx3929 squareroot 0.516 -> 0.718 Inexact Rounded sqtx3930 squareroot 0.0516 -> 0.227 Inexact Rounded sqtx3931 squareroot 0.517 -> 0.719 Inexact Rounded sqtx3932 squareroot 0.0517 -> 0.227 Inexact Rounded sqtx3933 squareroot 0.518 -> 0.720 Inexact Rounded sqtx3934 squareroot 0.0518 -> 0.228 Inexact Rounded sqtx3935 squareroot 0.519 -> 0.720 Inexact Rounded sqtx3936 squareroot 0.0519 -> 0.228 Inexact Rounded sqtx3937 squareroot 0.521 -> 0.722 Inexact Rounded sqtx3938 squareroot 0.0521 -> 0.228 Inexact Rounded sqtx3939 squareroot 0.522 -> 0.722 Inexact Rounded sqtx3940 squareroot 0.0522 -> 0.228 Inexact Rounded sqtx3941 squareroot 0.523 -> 0.723 Inexact Rounded sqtx3942 squareroot 0.0523 -> 0.229 Inexact Rounded sqtx3943 squareroot 0.524 -> 0.724 Inexact Rounded sqtx3944 squareroot 0.0524 -> 0.229 Inexact Rounded sqtx3945 squareroot 0.525 -> 0.725 Inexact Rounded sqtx3946 squareroot 0.0525 -> 0.229 Inexact Rounded sqtx3947 squareroot 0.526 -> 0.725 Inexact Rounded sqtx3948 squareroot 0.0526 -> 0.229 Inexact Rounded sqtx3949 squareroot 0.527 -> 0.726 Inexact Rounded sqtx3950 squareroot 0.0527 -> 0.230 Inexact Rounded sqtx3951 squareroot 0.528 -> 0.727 Inexact Rounded sqtx3952 squareroot 0.0528 -> 0.230 Inexact Rounded sqtx3953 squareroot 0.529 -> 0.727 Inexact Rounded sqtx3954 squareroot 0.0529 -> 0.23 sqtx3955 squareroot 0.531 -> 0.729 Inexact Rounded sqtx3956 squareroot 0.0531 -> 0.230 Inexact Rounded sqtx3957 squareroot 0.532 -> 0.729 Inexact Rounded sqtx3958 squareroot 0.0532 -> 0.231 Inexact Rounded sqtx3959 squareroot 0.533 -> 0.730 Inexact Rounded sqtx3960 squareroot 0.0533 -> 0.231 Inexact Rounded sqtx3961 squareroot 0.534 -> 0.731 Inexact Rounded sqtx3962 squareroot 0.0534 -> 0.231 Inexact Rounded sqtx3963 squareroot 0.535 -> 0.731 Inexact Rounded sqtx3964 squareroot 0.0535 -> 0.231 Inexact Rounded sqtx3965 squareroot 0.536 -> 0.732 Inexact Rounded sqtx3966 squareroot 0.0536 -> 0.232 Inexact Rounded sqtx3967 squareroot 0.537 -> 0.733 Inexact Rounded sqtx3968 squareroot 0.0537 -> 0.232 Inexact Rounded sqtx3969 squareroot 0.538 -> 0.733 Inexact Rounded sqtx3970 squareroot 0.0538 -> 0.232 Inexact Rounded sqtx3971 squareroot 0.539 -> 0.734 Inexact Rounded sqtx3972 squareroot 0.0539 -> 0.232 Inexact Rounded sqtx3973 squareroot 0.541 -> 0.736 Inexact Rounded sqtx3974 squareroot 0.0541 -> 0.233 Inexact Rounded sqtx3975 squareroot 0.542 -> 0.736 Inexact Rounded sqtx3976 squareroot 0.0542 -> 0.233 Inexact Rounded sqtx3977 squareroot 0.543 -> 0.737 Inexact Rounded sqtx3978 squareroot 0.0543 -> 0.233 Inexact Rounded sqtx3979 squareroot 0.544 -> 0.738 Inexact Rounded sqtx3980 squareroot 0.0544 -> 0.233 Inexact Rounded sqtx3981 squareroot 0.545 -> 0.738 Inexact Rounded sqtx3982 squareroot 0.0545 -> 0.233 Inexact Rounded sqtx3983 squareroot 0.546 -> 0.739 Inexact Rounded sqtx3984 squareroot 0.0546 -> 0.234 Inexact Rounded sqtx3985 squareroot 0.547 -> 0.740 Inexact Rounded sqtx3986 squareroot 0.0547 -> 0.234 Inexact Rounded sqtx3987 squareroot 0.548 -> 0.740 Inexact Rounded sqtx3988 squareroot 0.0548 -> 0.234 Inexact Rounded sqtx3989 squareroot 0.549 -> 0.741 Inexact Rounded sqtx3990 squareroot 0.0549 -> 0.234 Inexact Rounded sqtx3991 squareroot 0.551 -> 0.742 Inexact Rounded sqtx3992 squareroot 0.0551 -> 0.235 Inexact Rounded sqtx3993 squareroot 0.552 -> 0.743 Inexact Rounded sqtx3994 squareroot 0.0552 -> 0.235 Inexact Rounded sqtx3995 squareroot 0.553 -> 0.744 Inexact Rounded sqtx3996 squareroot 0.0553 -> 0.235 Inexact Rounded sqtx3997 squareroot 0.554 -> 0.744 Inexact Rounded sqtx3998 squareroot 0.0554 -> 0.235 Inexact Rounded sqtx3999 squareroot 0.555 -> 0.745 Inexact Rounded sqtx4000 squareroot 0.0555 -> 0.236 Inexact Rounded sqtx4001 squareroot 0.556 -> 0.746 Inexact Rounded sqtx4002 squareroot 0.0556 -> 0.236 Inexact Rounded sqtx4003 squareroot 0.557 -> 0.746 Inexact Rounded sqtx4004 squareroot 0.0557 -> 0.236 Inexact Rounded sqtx4005 squareroot 0.558 -> 0.747 Inexact Rounded sqtx4006 squareroot 0.0558 -> 0.236 Inexact Rounded sqtx4007 squareroot 0.559 -> 0.748 Inexact Rounded sqtx4008 squareroot 0.0559 -> 0.236 Inexact Rounded sqtx4009 squareroot 0.561 -> 0.749 Inexact Rounded sqtx4010 squareroot 0.0561 -> 0.237 Inexact Rounded sqtx4011 squareroot 0.562 -> 0.750 Inexact Rounded sqtx4012 squareroot 0.0562 -> 0.237 Inexact Rounded sqtx4013 squareroot 0.563 -> 0.750 Inexact Rounded sqtx4014 squareroot 0.0563 -> 0.237 Inexact Rounded sqtx4015 squareroot 0.564 -> 0.751 Inexact Rounded sqtx4016 squareroot 0.0564 -> 0.237 Inexact Rounded sqtx4017 squareroot 0.565 -> 0.752 Inexact Rounded sqtx4018 squareroot 0.0565 -> 0.238 Inexact Rounded sqtx4019 squareroot 0.566 -> 0.752 Inexact Rounded sqtx4020 squareroot 0.0566 -> 0.238 Inexact Rounded sqtx4021 squareroot 0.567 -> 0.753 Inexact Rounded sqtx4022 squareroot 0.0567 -> 0.238 Inexact Rounded sqtx4023 squareroot 0.568 -> 0.754 Inexact Rounded sqtx4024 squareroot 0.0568 -> 0.238 Inexact Rounded sqtx4025 squareroot 0.569 -> 0.754 Inexact Rounded sqtx4026 squareroot 0.0569 -> 0.239 Inexact Rounded sqtx4027 squareroot 0.571 -> 0.756 Inexact Rounded sqtx4028 squareroot 0.0571 -> 0.239 Inexact Rounded sqtx4029 squareroot 0.572 -> 0.756 Inexact Rounded sqtx4030 squareroot 0.0572 -> 0.239 Inexact Rounded sqtx4031 squareroot 0.573 -> 0.757 Inexact Rounded sqtx4032 squareroot 0.0573 -> 0.239 Inexact Rounded sqtx4033 squareroot 0.574 -> 0.758 Inexact Rounded sqtx4034 squareroot 0.0574 -> 0.240 Inexact Rounded sqtx4035 squareroot 0.575 -> 0.758 Inexact Rounded sqtx4036 squareroot 0.0575 -> 0.240 Inexact Rounded sqtx4037 squareroot 0.576 -> 0.759 Inexact Rounded sqtx4038 squareroot 0.0576 -> 0.24 sqtx4039 squareroot 0.577 -> 0.760 Inexact Rounded sqtx4040 squareroot 0.0577 -> 0.240 Inexact Rounded sqtx4041 squareroot 0.578 -> 0.760 Inexact Rounded sqtx4042 squareroot 0.0578 -> 0.240 Inexact Rounded sqtx4043 squareroot 0.579 -> 0.761 Inexact Rounded sqtx4044 squareroot 0.0579 -> 0.241 Inexact Rounded sqtx4045 squareroot 0.581 -> 0.762 Inexact Rounded sqtx4046 squareroot 0.0581 -> 0.241 Inexact Rounded sqtx4047 squareroot 0.582 -> 0.763 Inexact Rounded sqtx4048 squareroot 0.0582 -> 0.241 Inexact Rounded sqtx4049 squareroot 0.583 -> 0.764 Inexact Rounded sqtx4050 squareroot 0.0583 -> 0.241 Inexact Rounded sqtx4051 squareroot 0.584 -> 0.764 Inexact Rounded sqtx4052 squareroot 0.0584 -> 0.242 Inexact Rounded sqtx4053 squareroot 0.585 -> 0.765 Inexact Rounded sqtx4054 squareroot 0.0585 -> 0.242 Inexact Rounded sqtx4055 squareroot 0.586 -> 0.766 Inexact Rounded sqtx4056 squareroot 0.0586 -> 0.242 Inexact Rounded sqtx4057 squareroot 0.587 -> 0.766 Inexact Rounded sqtx4058 squareroot 0.0587 -> 0.242 Inexact Rounded sqtx4059 squareroot 0.588 -> 0.767 Inexact Rounded sqtx4060 squareroot 0.0588 -> 0.242 Inexact Rounded sqtx4061 squareroot 0.589 -> 0.767 Inexact Rounded sqtx4062 squareroot 0.0589 -> 0.243 Inexact Rounded sqtx4063 squareroot 0.591 -> 0.769 Inexact Rounded sqtx4064 squareroot 0.0591 -> 0.243 Inexact Rounded sqtx4065 squareroot 0.592 -> 0.769 Inexact Rounded sqtx4066 squareroot 0.0592 -> 0.243 Inexact Rounded sqtx4067 squareroot 0.593 -> 0.770 Inexact Rounded sqtx4068 squareroot 0.0593 -> 0.244 Inexact Rounded sqtx4069 squareroot 0.594 -> 0.771 Inexact Rounded sqtx4070 squareroot 0.0594 -> 0.244 Inexact Rounded sqtx4071 squareroot 0.595 -> 0.771 Inexact Rounded sqtx4072 squareroot 0.0595 -> 0.244 Inexact Rounded sqtx4073 squareroot 0.596 -> 0.772 Inexact Rounded sqtx4074 squareroot 0.0596 -> 0.244 Inexact Rounded sqtx4075 squareroot 0.597 -> 0.773 Inexact Rounded sqtx4076 squareroot 0.0597 -> 0.244 Inexact Rounded sqtx4077 squareroot 0.598 -> 0.773 Inexact Rounded sqtx4078 squareroot 0.0598 -> 0.245 Inexact Rounded sqtx4079 squareroot 0.599 -> 0.774 Inexact Rounded sqtx4080 squareroot 0.0599 -> 0.245 Inexact Rounded sqtx4081 squareroot 0.601 -> 0.775 Inexact Rounded sqtx4082 squareroot 0.0601 -> 0.245 Inexact Rounded sqtx4083 squareroot 0.602 -> 0.776 Inexact Rounded sqtx4084 squareroot 0.0602 -> 0.245 Inexact Rounded sqtx4085 squareroot 0.603 -> 0.777 Inexact Rounded sqtx4086 squareroot 0.0603 -> 0.246 Inexact Rounded sqtx4087 squareroot 0.604 -> 0.777 Inexact Rounded sqtx4088 squareroot 0.0604 -> 0.246 Inexact Rounded sqtx4089 squareroot 0.605 -> 0.778 Inexact Rounded sqtx4090 squareroot 0.0605 -> 0.246 Inexact Rounded sqtx4091 squareroot 0.606 -> 0.778 Inexact Rounded sqtx4092 squareroot 0.0606 -> 0.246 Inexact Rounded sqtx4093 squareroot 0.607 -> 0.779 Inexact Rounded sqtx4094 squareroot 0.0607 -> 0.246 Inexact Rounded sqtx4095 squareroot 0.608 -> 0.780 Inexact Rounded sqtx4096 squareroot 0.0608 -> 0.247 Inexact Rounded sqtx4097 squareroot 0.609 -> 0.780 Inexact Rounded sqtx4098 squareroot 0.0609 -> 0.247 Inexact Rounded sqtx4099 squareroot 0.611 -> 0.782 Inexact Rounded sqtx4100 squareroot 0.0611 -> 0.247 Inexact Rounded sqtx4101 squareroot 0.612 -> 0.782 Inexact Rounded sqtx4102 squareroot 0.0612 -> 0.247 Inexact Rounded sqtx4103 squareroot 0.613 -> 0.783 Inexact Rounded sqtx4104 squareroot 0.0613 -> 0.248 Inexact Rounded sqtx4105 squareroot 0.614 -> 0.784 Inexact Rounded sqtx4106 squareroot 0.0614 -> 0.248 Inexact Rounded sqtx4107 squareroot 0.615 -> 0.784 Inexact Rounded sqtx4108 squareroot 0.0615 -> 0.248 Inexact Rounded sqtx4109 squareroot 0.616 -> 0.785 Inexact Rounded sqtx4110 squareroot 0.0616 -> 0.248 Inexact Rounded sqtx4111 squareroot 0.617 -> 0.785 Inexact Rounded sqtx4112 squareroot 0.0617 -> 0.248 Inexact Rounded sqtx4113 squareroot 0.618 -> 0.786 Inexact Rounded sqtx4114 squareroot 0.0618 -> 0.249 Inexact Rounded sqtx4115 squareroot 0.619 -> 0.787 Inexact Rounded sqtx4116 squareroot 0.0619 -> 0.249 Inexact Rounded sqtx4117 squareroot 0.621 -> 0.788 Inexact Rounded sqtx4118 squareroot 0.0621 -> 0.249 Inexact Rounded sqtx4119 squareroot 0.622 -> 0.789 Inexact Rounded sqtx4120 squareroot 0.0622 -> 0.249 Inexact Rounded sqtx4121 squareroot 0.623 -> 0.789 Inexact Rounded sqtx4122 squareroot 0.0623 -> 0.250 Inexact Rounded sqtx4123 squareroot 0.624 -> 0.790 Inexact Rounded sqtx4124 squareroot 0.0624 -> 0.250 Inexact Rounded sqtx4125 squareroot 0.625 -> 0.791 Inexact Rounded sqtx4126 squareroot 0.0625 -> 0.25 sqtx4127 squareroot 0.626 -> 0.791 Inexact Rounded sqtx4128 squareroot 0.0626 -> 0.250 Inexact Rounded sqtx4129 squareroot 0.627 -> 0.792 Inexact Rounded sqtx4130 squareroot 0.0627 -> 0.250 Inexact Rounded sqtx4131 squareroot 0.628 -> 0.792 Inexact Rounded sqtx4132 squareroot 0.0628 -> 0.251 Inexact Rounded sqtx4133 squareroot 0.629 -> 0.793 Inexact Rounded sqtx4134 squareroot 0.0629 -> 0.251 Inexact Rounded sqtx4135 squareroot 0.631 -> 0.794 Inexact Rounded sqtx4136 squareroot 0.0631 -> 0.251 Inexact Rounded sqtx4137 squareroot 0.632 -> 0.795 Inexact Rounded sqtx4138 squareroot 0.0632 -> 0.251 Inexact Rounded sqtx4139 squareroot 0.633 -> 0.796 Inexact Rounded sqtx4140 squareroot 0.0633 -> 0.252 Inexact Rounded sqtx4141 squareroot 0.634 -> 0.796 Inexact Rounded sqtx4142 squareroot 0.0634 -> 0.252 Inexact Rounded sqtx4143 squareroot 0.635 -> 0.797 Inexact Rounded sqtx4144 squareroot 0.0635 -> 0.252 Inexact Rounded sqtx4145 squareroot 0.636 -> 0.797 Inexact Rounded sqtx4146 squareroot 0.0636 -> 0.252 Inexact Rounded sqtx4147 squareroot 0.637 -> 0.798 Inexact Rounded sqtx4148 squareroot 0.0637 -> 0.252 Inexact Rounded sqtx4149 squareroot 0.638 -> 0.799 Inexact Rounded sqtx4150 squareroot 0.0638 -> 0.253 Inexact Rounded sqtx4151 squareroot 0.639 -> 0.799 Inexact Rounded sqtx4152 squareroot 0.0639 -> 0.253 Inexact Rounded sqtx4153 squareroot 0.641 -> 0.801 Inexact Rounded sqtx4154 squareroot 0.0641 -> 0.253 Inexact Rounded sqtx4155 squareroot 0.642 -> 0.801 Inexact Rounded sqtx4156 squareroot 0.0642 -> 0.253 Inexact Rounded sqtx4157 squareroot 0.643 -> 0.802 Inexact Rounded sqtx4158 squareroot 0.0643 -> 0.254 Inexact Rounded sqtx4159 squareroot 0.644 -> 0.802 Inexact Rounded sqtx4160 squareroot 0.0644 -> 0.254 Inexact Rounded sqtx4161 squareroot 0.645 -> 0.803 Inexact Rounded sqtx4162 squareroot 0.0645 -> 0.254 Inexact Rounded sqtx4163 squareroot 0.646 -> 0.804 Inexact Rounded sqtx4164 squareroot 0.0646 -> 0.254 Inexact Rounded sqtx4165 squareroot 0.647 -> 0.804 Inexact Rounded sqtx4166 squareroot 0.0647 -> 0.254 Inexact Rounded sqtx4167 squareroot 0.648 -> 0.805 Inexact Rounded sqtx4168 squareroot 0.0648 -> 0.255 Inexact Rounded sqtx4169 squareroot 0.649 -> 0.806 Inexact Rounded sqtx4170 squareroot 0.0649 -> 0.255 Inexact Rounded sqtx4171 squareroot 0.651 -> 0.807 Inexact Rounded sqtx4172 squareroot 0.0651 -> 0.255 Inexact Rounded sqtx4173 squareroot 0.652 -> 0.807 Inexact Rounded sqtx4174 squareroot 0.0652 -> 0.255 Inexact Rounded sqtx4175 squareroot 0.653 -> 0.808 Inexact Rounded sqtx4176 squareroot 0.0653 -> 0.256 Inexact Rounded sqtx4177 squareroot 0.654 -> 0.809 Inexact Rounded sqtx4178 squareroot 0.0654 -> 0.256 Inexact Rounded sqtx4179 squareroot 0.655 -> 0.809 Inexact Rounded sqtx4180 squareroot 0.0655 -> 0.256 Inexact Rounded sqtx4181 squareroot 0.656 -> 0.810 Inexact Rounded sqtx4182 squareroot 0.0656 -> 0.256 Inexact Rounded sqtx4183 squareroot 0.657 -> 0.811 Inexact Rounded sqtx4184 squareroot 0.0657 -> 0.256 Inexact Rounded sqtx4185 squareroot 0.658 -> 0.811 Inexact Rounded sqtx4186 squareroot 0.0658 -> 0.257 Inexact Rounded sqtx4187 squareroot 0.659 -> 0.812 Inexact Rounded sqtx4188 squareroot 0.0659 -> 0.257 Inexact Rounded sqtx4189 squareroot 0.661 -> 0.813 Inexact Rounded sqtx4190 squareroot 0.0661 -> 0.257 Inexact Rounded sqtx4191 squareroot 0.662 -> 0.814 Inexact Rounded sqtx4192 squareroot 0.0662 -> 0.257 Inexact Rounded sqtx4193 squareroot 0.663 -> 0.814 Inexact Rounded sqtx4194 squareroot 0.0663 -> 0.257 Inexact Rounded sqtx4195 squareroot 0.664 -> 0.815 Inexact Rounded sqtx4196 squareroot 0.0664 -> 0.258 Inexact Rounded sqtx4197 squareroot 0.665 -> 0.815 Inexact Rounded sqtx4198 squareroot 0.0665 -> 0.258 Inexact Rounded sqtx4199 squareroot 0.666 -> 0.816 Inexact Rounded sqtx4200 squareroot 0.0666 -> 0.258 Inexact Rounded sqtx4201 squareroot 0.667 -> 0.817 Inexact Rounded sqtx4202 squareroot 0.0667 -> 0.258 Inexact Rounded sqtx4203 squareroot 0.668 -> 0.817 Inexact Rounded sqtx4204 squareroot 0.0668 -> 0.258 Inexact Rounded sqtx4205 squareroot 0.669 -> 0.818 Inexact Rounded sqtx4206 squareroot 0.0669 -> 0.259 Inexact Rounded sqtx4207 squareroot 0.671 -> 0.819 Inexact Rounded sqtx4208 squareroot 0.0671 -> 0.259 Inexact Rounded sqtx4209 squareroot 0.672 -> 0.820 Inexact Rounded sqtx4210 squareroot 0.0672 -> 0.259 Inexact Rounded sqtx4211 squareroot 0.673 -> 0.820 Inexact Rounded sqtx4212 squareroot 0.0673 -> 0.259 Inexact Rounded sqtx4213 squareroot 0.674 -> 0.821 Inexact Rounded sqtx4214 squareroot 0.0674 -> 0.260 Inexact Rounded sqtx4215 squareroot 0.675 -> 0.822 Inexact Rounded sqtx4216 squareroot 0.0675 -> 0.260 Inexact Rounded sqtx4217 squareroot 0.676 -> 0.822 Inexact Rounded sqtx4218 squareroot 0.0676 -> 0.26 sqtx4219 squareroot 0.677 -> 0.823 Inexact Rounded sqtx4220 squareroot 0.0677 -> 0.260 Inexact Rounded sqtx4221 squareroot 0.678 -> 0.823 Inexact Rounded sqtx4222 squareroot 0.0678 -> 0.260 Inexact Rounded sqtx4223 squareroot 0.679 -> 0.824 Inexact Rounded sqtx4224 squareroot 0.0679 -> 0.261 Inexact Rounded sqtx4225 squareroot 0.681 -> 0.825 Inexact Rounded sqtx4226 squareroot 0.0681 -> 0.261 Inexact Rounded sqtx4227 squareroot 0.682 -> 0.826 Inexact Rounded sqtx4228 squareroot 0.0682 -> 0.261 Inexact Rounded sqtx4229 squareroot 0.683 -> 0.826 Inexact Rounded sqtx4230 squareroot 0.0683 -> 0.261 Inexact Rounded sqtx4231 squareroot 0.684 -> 0.827 Inexact Rounded sqtx4232 squareroot 0.0684 -> 0.262 Inexact Rounded sqtx4233 squareroot 0.685 -> 0.828 Inexact Rounded sqtx4234 squareroot 0.0685 -> 0.262 Inexact Rounded sqtx4235 squareroot 0.686 -> 0.828 Inexact Rounded sqtx4236 squareroot 0.0686 -> 0.262 Inexact Rounded sqtx4237 squareroot 0.687 -> 0.829 Inexact Rounded sqtx4238 squareroot 0.0687 -> 0.262 Inexact Rounded sqtx4239 squareroot 0.688 -> 0.829 Inexact Rounded sqtx4240 squareroot 0.0688 -> 0.262 Inexact Rounded sqtx4241 squareroot 0.689 -> 0.830 Inexact Rounded sqtx4242 squareroot 0.0689 -> 0.262 Inexact Rounded sqtx4243 squareroot 0.691 -> 0.831 Inexact Rounded sqtx4244 squareroot 0.0691 -> 0.263 Inexact Rounded sqtx4245 squareroot 0.692 -> 0.832 Inexact Rounded sqtx4246 squareroot 0.0692 -> 0.263 Inexact Rounded sqtx4247 squareroot 0.693 -> 0.832 Inexact Rounded sqtx4248 squareroot 0.0693 -> 0.263 Inexact Rounded sqtx4249 squareroot 0.694 -> 0.833 Inexact Rounded sqtx4250 squareroot 0.0694 -> 0.263 Inexact Rounded sqtx4251 squareroot 0.695 -> 0.834 Inexact Rounded sqtx4252 squareroot 0.0695 -> 0.264 Inexact Rounded sqtx4253 squareroot 0.696 -> 0.834 Inexact Rounded sqtx4254 squareroot 0.0696 -> 0.264 Inexact Rounded sqtx4255 squareroot 0.697 -> 0.835 Inexact Rounded sqtx4256 squareroot 0.0697 -> 0.264 Inexact Rounded sqtx4257 squareroot 0.698 -> 0.835 Inexact Rounded sqtx4258 squareroot 0.0698 -> 0.264 Inexact Rounded sqtx4259 squareroot 0.699 -> 0.836 Inexact Rounded sqtx4260 squareroot 0.0699 -> 0.264 Inexact Rounded sqtx4261 squareroot 0.701 -> 0.837 Inexact Rounded sqtx4262 squareroot 0.0701 -> 0.265 Inexact Rounded sqtx4263 squareroot 0.702 -> 0.838 Inexact Rounded sqtx4264 squareroot 0.0702 -> 0.265 Inexact Rounded sqtx4265 squareroot 0.703 -> 0.838 Inexact Rounded sqtx4266 squareroot 0.0703 -> 0.265 Inexact Rounded sqtx4267 squareroot 0.704 -> 0.839 Inexact Rounded sqtx4268 squareroot 0.0704 -> 0.265 Inexact Rounded sqtx4269 squareroot 0.705 -> 0.840 Inexact Rounded sqtx4270 squareroot 0.0705 -> 0.266 Inexact Rounded sqtx4271 squareroot 0.706 -> 0.840 Inexact Rounded sqtx4272 squareroot 0.0706 -> 0.266 Inexact Rounded sqtx4273 squareroot 0.707 -> 0.841 Inexact Rounded sqtx4274 squareroot 0.0707 -> 0.266 Inexact Rounded sqtx4275 squareroot 0.708 -> 0.841 Inexact Rounded sqtx4276 squareroot 0.0708 -> 0.266 Inexact Rounded sqtx4277 squareroot 0.709 -> 0.842 Inexact Rounded sqtx4278 squareroot 0.0709 -> 0.266 Inexact Rounded sqtx4279 squareroot 0.711 -> 0.843 Inexact Rounded sqtx4280 squareroot 0.0711 -> 0.267 Inexact Rounded sqtx4281 squareroot 0.712 -> 0.844 Inexact Rounded sqtx4282 squareroot 0.0712 -> 0.267 Inexact Rounded sqtx4283 squareroot 0.713 -> 0.844 Inexact Rounded sqtx4284 squareroot 0.0713 -> 0.267 Inexact Rounded sqtx4285 squareroot 0.714 -> 0.845 Inexact Rounded sqtx4286 squareroot 0.0714 -> 0.267 Inexact Rounded sqtx4287 squareroot 0.715 -> 0.846 Inexact Rounded sqtx4288 squareroot 0.0715 -> 0.267 Inexact Rounded sqtx4289 squareroot 0.716 -> 0.846 Inexact Rounded sqtx4290 squareroot 0.0716 -> 0.268 Inexact Rounded sqtx4291 squareroot 0.717 -> 0.847 Inexact Rounded sqtx4292 squareroot 0.0717 -> 0.268 Inexact Rounded sqtx4293 squareroot 0.718 -> 0.847 Inexact Rounded sqtx4294 squareroot 0.0718 -> 0.268 Inexact Rounded sqtx4295 squareroot 0.719 -> 0.848 Inexact Rounded sqtx4296 squareroot 0.0719 -> 0.268 Inexact Rounded sqtx4297 squareroot 0.721 -> 0.849 Inexact Rounded sqtx4298 squareroot 0.0721 -> 0.269 Inexact Rounded sqtx4299 squareroot 0.722 -> 0.850 Inexact Rounded sqtx4300 squareroot 0.0722 -> 0.269 Inexact Rounded sqtx4301 squareroot 0.723 -> 0.850 Inexact Rounded sqtx4302 squareroot 0.0723 -> 0.269 Inexact Rounded sqtx4303 squareroot 0.724 -> 0.851 Inexact Rounded sqtx4304 squareroot 0.0724 -> 0.269 Inexact Rounded sqtx4305 squareroot 0.725 -> 0.851 Inexact Rounded sqtx4306 squareroot 0.0725 -> 0.269 Inexact Rounded sqtx4307 squareroot 0.726 -> 0.852 Inexact Rounded sqtx4308 squareroot 0.0726 -> 0.269 Inexact Rounded sqtx4309 squareroot 0.727 -> 0.853 Inexact Rounded sqtx4310 squareroot 0.0727 -> 0.270 Inexact Rounded sqtx4311 squareroot 0.728 -> 0.853 Inexact Rounded sqtx4312 squareroot 0.0728 -> 0.270 Inexact Rounded sqtx4313 squareroot 0.729 -> 0.854 Inexact Rounded sqtx4314 squareroot 0.0729 -> 0.27 sqtx4315 squareroot 0.731 -> 0.855 Inexact Rounded sqtx4316 squareroot 0.0731 -> 0.270 Inexact Rounded sqtx4317 squareroot 0.732 -> 0.856 Inexact Rounded sqtx4318 squareroot 0.0732 -> 0.271 Inexact Rounded sqtx4319 squareroot 0.733 -> 0.856 Inexact Rounded sqtx4320 squareroot 0.0733 -> 0.271 Inexact Rounded sqtx4321 squareroot 0.734 -> 0.857 Inexact Rounded sqtx4322 squareroot 0.0734 -> 0.271 Inexact Rounded sqtx4323 squareroot 0.735 -> 0.857 Inexact Rounded sqtx4324 squareroot 0.0735 -> 0.271 Inexact Rounded sqtx4325 squareroot 0.736 -> 0.858 Inexact Rounded sqtx4326 squareroot 0.0736 -> 0.271 Inexact Rounded sqtx4327 squareroot 0.737 -> 0.858 Inexact Rounded sqtx4328 squareroot 0.0737 -> 0.271 Inexact Rounded sqtx4329 squareroot 0.738 -> 0.859 Inexact Rounded sqtx4330 squareroot 0.0738 -> 0.272 Inexact Rounded sqtx4331 squareroot 0.739 -> 0.860 Inexact Rounded sqtx4332 squareroot 0.0739 -> 0.272 Inexact Rounded sqtx4333 squareroot 0.741 -> 0.861 Inexact Rounded sqtx4334 squareroot 0.0741 -> 0.272 Inexact Rounded sqtx4335 squareroot 0.742 -> 0.861 Inexact Rounded sqtx4336 squareroot 0.0742 -> 0.272 Inexact Rounded sqtx4337 squareroot 0.743 -> 0.862 Inexact Rounded sqtx4338 squareroot 0.0743 -> 0.273 Inexact Rounded sqtx4339 squareroot 0.744 -> 0.863 Inexact Rounded sqtx4340 squareroot 0.0744 -> 0.273 Inexact Rounded sqtx4341 squareroot 0.745 -> 0.863 Inexact Rounded sqtx4342 squareroot 0.0745 -> 0.273 Inexact Rounded sqtx4343 squareroot 0.746 -> 0.864 Inexact Rounded sqtx4344 squareroot 0.0746 -> 0.273 Inexact Rounded sqtx4345 squareroot 0.747 -> 0.864 Inexact Rounded sqtx4346 squareroot 0.0747 -> 0.273 Inexact Rounded sqtx4347 squareroot 0.748 -> 0.865 Inexact Rounded sqtx4348 squareroot 0.0748 -> 0.273 Inexact Rounded sqtx4349 squareroot 0.749 -> 0.865 Inexact Rounded sqtx4350 squareroot 0.0749 -> 0.274 Inexact Rounded sqtx4351 squareroot 0.751 -> 0.867 Inexact Rounded sqtx4352 squareroot 0.0751 -> 0.274 Inexact Rounded sqtx4353 squareroot 0.752 -> 0.867 Inexact Rounded sqtx4354 squareroot 0.0752 -> 0.274 Inexact Rounded sqtx4355 squareroot 0.753 -> 0.868 Inexact Rounded sqtx4356 squareroot 0.0753 -> 0.274 Inexact Rounded sqtx4357 squareroot 0.754 -> 0.868 Inexact Rounded sqtx4358 squareroot 0.0754 -> 0.275 Inexact Rounded sqtx4359 squareroot 0.755 -> 0.869 Inexact Rounded sqtx4360 squareroot 0.0755 -> 0.275 Inexact Rounded sqtx4361 squareroot 0.756 -> 0.869 Inexact Rounded sqtx4362 squareroot 0.0756 -> 0.275 Inexact Rounded sqtx4363 squareroot 0.757 -> 0.870 Inexact Rounded sqtx4364 squareroot 0.0757 -> 0.275 Inexact Rounded sqtx4365 squareroot 0.758 -> 0.871 Inexact Rounded sqtx4366 squareroot 0.0758 -> 0.275 Inexact Rounded sqtx4367 squareroot 0.759 -> 0.871 Inexact Rounded sqtx4368 squareroot 0.0759 -> 0.275 Inexact Rounded sqtx4369 squareroot 0.761 -> 0.872 Inexact Rounded sqtx4370 squareroot 0.0761 -> 0.276 Inexact Rounded sqtx4371 squareroot 0.762 -> 0.873 Inexact Rounded sqtx4372 squareroot 0.0762 -> 0.276 Inexact Rounded sqtx4373 squareroot 0.763 -> 0.873 Inexact Rounded sqtx4374 squareroot 0.0763 -> 0.276 Inexact Rounded sqtx4375 squareroot 0.764 -> 0.874 Inexact Rounded sqtx4376 squareroot 0.0764 -> 0.276 Inexact Rounded sqtx4377 squareroot 0.765 -> 0.875 Inexact Rounded sqtx4378 squareroot 0.0765 -> 0.277 Inexact Rounded sqtx4379 squareroot 0.766 -> 0.875 Inexact Rounded sqtx4380 squareroot 0.0766 -> 0.277 Inexact Rounded sqtx4381 squareroot 0.767 -> 0.876 Inexact Rounded sqtx4382 squareroot 0.0767 -> 0.277 Inexact Rounded sqtx4383 squareroot 0.768 -> 0.876 Inexact Rounded sqtx4384 squareroot 0.0768 -> 0.277 Inexact Rounded sqtx4385 squareroot 0.769 -> 0.877 Inexact Rounded sqtx4386 squareroot 0.0769 -> 0.277 Inexact Rounded sqtx4387 squareroot 0.771 -> 0.878 Inexact Rounded sqtx4388 squareroot 0.0771 -> 0.278 Inexact Rounded sqtx4389 squareroot 0.772 -> 0.879 Inexact Rounded sqtx4390 squareroot 0.0772 -> 0.278 Inexact Rounded sqtx4391 squareroot 0.773 -> 0.879 Inexact Rounded sqtx4392 squareroot 0.0773 -> 0.278 Inexact Rounded sqtx4393 squareroot 0.774 -> 0.880 Inexact Rounded sqtx4394 squareroot 0.0774 -> 0.278 Inexact Rounded sqtx4395 squareroot 0.775 -> 0.880 Inexact Rounded sqtx4396 squareroot 0.0775 -> 0.278 Inexact Rounded sqtx4397 squareroot 0.776 -> 0.881 Inexact Rounded sqtx4398 squareroot 0.0776 -> 0.279 Inexact Rounded sqtx4399 squareroot 0.777 -> 0.881 Inexact Rounded sqtx4400 squareroot 0.0777 -> 0.279 Inexact Rounded sqtx4401 squareroot 0.778 -> 0.882 Inexact Rounded sqtx4402 squareroot 0.0778 -> 0.279 Inexact Rounded sqtx4403 squareroot 0.779 -> 0.883 Inexact Rounded sqtx4404 squareroot 0.0779 -> 0.279 Inexact Rounded sqtx4405 squareroot 0.781 -> 0.884 Inexact Rounded sqtx4406 squareroot 0.0781 -> 0.279 Inexact Rounded sqtx4407 squareroot 0.782 -> 0.884 Inexact Rounded sqtx4408 squareroot 0.0782 -> 0.280 Inexact Rounded sqtx4409 squareroot 0.783 -> 0.885 Inexact Rounded sqtx4410 squareroot 0.0783 -> 0.280 Inexact Rounded sqtx4411 squareroot 0.784 -> 0.885 Inexact Rounded sqtx4412 squareroot 0.0784 -> 0.28 sqtx4413 squareroot 0.785 -> 0.886 Inexact Rounded sqtx4414 squareroot 0.0785 -> 0.280 Inexact Rounded sqtx4415 squareroot 0.786 -> 0.887 Inexact Rounded sqtx4416 squareroot 0.0786 -> 0.280 Inexact Rounded sqtx4417 squareroot 0.787 -> 0.887 Inexact Rounded sqtx4418 squareroot 0.0787 -> 0.281 Inexact Rounded sqtx4419 squareroot 0.788 -> 0.888 Inexact Rounded sqtx4420 squareroot 0.0788 -> 0.281 Inexact Rounded sqtx4421 squareroot 0.789 -> 0.888 Inexact Rounded sqtx4422 squareroot 0.0789 -> 0.281 Inexact Rounded sqtx4423 squareroot 0.791 -> 0.889 Inexact Rounded sqtx4424 squareroot 0.0791 -> 0.281 Inexact Rounded sqtx4425 squareroot 0.792 -> 0.890 Inexact Rounded sqtx4426 squareroot 0.0792 -> 0.281 Inexact Rounded sqtx4427 squareroot 0.793 -> 0.891 Inexact Rounded sqtx4428 squareroot 0.0793 -> 0.282 Inexact Rounded sqtx4429 squareroot 0.794 -> 0.891 Inexact Rounded sqtx4430 squareroot 0.0794 -> 0.282 Inexact Rounded sqtx4431 squareroot 0.795 -> 0.892 Inexact Rounded sqtx4432 squareroot 0.0795 -> 0.282 Inexact Rounded sqtx4433 squareroot 0.796 -> 0.892 Inexact Rounded sqtx4434 squareroot 0.0796 -> 0.282 Inexact Rounded sqtx4435 squareroot 0.797 -> 0.893 Inexact Rounded sqtx4436 squareroot 0.0797 -> 0.282 Inexact Rounded sqtx4437 squareroot 0.798 -> 0.893 Inexact Rounded sqtx4438 squareroot 0.0798 -> 0.282 Inexact Rounded sqtx4439 squareroot 0.799 -> 0.894 Inexact Rounded sqtx4440 squareroot 0.0799 -> 0.283 Inexact Rounded sqtx4441 squareroot 0.801 -> 0.895 Inexact Rounded sqtx4442 squareroot 0.0801 -> 0.283 Inexact Rounded sqtx4443 squareroot 0.802 -> 0.896 Inexact Rounded sqtx4444 squareroot 0.0802 -> 0.283 Inexact Rounded sqtx4445 squareroot 0.803 -> 0.896 Inexact Rounded sqtx4446 squareroot 0.0803 -> 0.283 Inexact Rounded sqtx4447 squareroot 0.804 -> 0.897 Inexact Rounded sqtx4448 squareroot 0.0804 -> 0.284 Inexact Rounded sqtx4449 squareroot 0.805 -> 0.897 Inexact Rounded sqtx4450 squareroot 0.0805 -> 0.284 Inexact Rounded sqtx4451 squareroot 0.806 -> 0.898 Inexact Rounded sqtx4452 squareroot 0.0806 -> 0.284 Inexact Rounded sqtx4453 squareroot 0.807 -> 0.898 Inexact Rounded sqtx4454 squareroot 0.0807 -> 0.284 Inexact Rounded sqtx4455 squareroot 0.808 -> 0.899 Inexact Rounded sqtx4456 squareroot 0.0808 -> 0.284 Inexact Rounded sqtx4457 squareroot 0.809 -> 0.899 Inexact Rounded sqtx4458 squareroot 0.0809 -> 0.284 Inexact Rounded sqtx4459 squareroot 0.811 -> 0.901 Inexact Rounded sqtx4460 squareroot 0.0811 -> 0.285 Inexact Rounded sqtx4461 squareroot 0.812 -> 0.901 Inexact Rounded sqtx4462 squareroot 0.0812 -> 0.285 Inexact Rounded sqtx4463 squareroot 0.813 -> 0.902 Inexact Rounded sqtx4464 squareroot 0.0813 -> 0.285 Inexact Rounded sqtx4465 squareroot 0.814 -> 0.902 Inexact Rounded sqtx4466 squareroot 0.0814 -> 0.285 Inexact Rounded sqtx4467 squareroot 0.815 -> 0.903 Inexact Rounded sqtx4468 squareroot 0.0815 -> 0.285 Inexact Rounded sqtx4469 squareroot 0.816 -> 0.903 Inexact Rounded sqtx4470 squareroot 0.0816 -> 0.286 Inexact Rounded sqtx4471 squareroot 0.817 -> 0.904 Inexact Rounded sqtx4472 squareroot 0.0817 -> 0.286 Inexact Rounded sqtx4473 squareroot 0.818 -> 0.904 Inexact Rounded sqtx4474 squareroot 0.0818 -> 0.286 Inexact Rounded sqtx4475 squareroot 0.819 -> 0.905 Inexact Rounded sqtx4476 squareroot 0.0819 -> 0.286 Inexact Rounded sqtx4477 squareroot 0.821 -> 0.906 Inexact Rounded sqtx4478 squareroot 0.0821 -> 0.287 Inexact Rounded sqtx4479 squareroot 0.822 -> 0.907 Inexact Rounded sqtx4480 squareroot 0.0822 -> 0.287 Inexact Rounded sqtx4481 squareroot 0.823 -> 0.907 Inexact Rounded sqtx4482 squareroot 0.0823 -> 0.287 Inexact Rounded sqtx4483 squareroot 0.824 -> 0.908 Inexact Rounded sqtx4484 squareroot 0.0824 -> 0.287 Inexact Rounded sqtx4485 squareroot 0.825 -> 0.908 Inexact Rounded sqtx4486 squareroot 0.0825 -> 0.287 Inexact Rounded sqtx4487 squareroot 0.826 -> 0.909 Inexact Rounded sqtx4488 squareroot 0.0826 -> 0.287 Inexact Rounded sqtx4489 squareroot 0.827 -> 0.909 Inexact Rounded sqtx4490 squareroot 0.0827 -> 0.288 Inexact Rounded sqtx4491 squareroot 0.828 -> 0.910 Inexact Rounded sqtx4492 squareroot 0.0828 -> 0.288 Inexact Rounded sqtx4493 squareroot 0.829 -> 0.910 Inexact Rounded sqtx4494 squareroot 0.0829 -> 0.288 Inexact Rounded sqtx4495 squareroot 0.831 -> 0.912 Inexact Rounded sqtx4496 squareroot 0.0831 -> 0.288 Inexact Rounded sqtx4497 squareroot 0.832 -> 0.912 Inexact Rounded sqtx4498 squareroot 0.0832 -> 0.288 Inexact Rounded sqtx4499 squareroot 0.833 -> 0.913 Inexact Rounded sqtx4500 squareroot 0.0833 -> 0.289 Inexact Rounded sqtx4501 squareroot 0.834 -> 0.913 Inexact Rounded sqtx4502 squareroot 0.0834 -> 0.289 Inexact Rounded sqtx4503 squareroot 0.835 -> 0.914 Inexact Rounded sqtx4504 squareroot 0.0835 -> 0.289 Inexact Rounded sqtx4505 squareroot 0.836 -> 0.914 Inexact Rounded sqtx4506 squareroot 0.0836 -> 0.289 Inexact Rounded sqtx4507 squareroot 0.837 -> 0.915 Inexact Rounded sqtx4508 squareroot 0.0837 -> 0.289 Inexact Rounded sqtx4509 squareroot 0.838 -> 0.915 Inexact Rounded sqtx4510 squareroot 0.0838 -> 0.289 Inexact Rounded sqtx4511 squareroot 0.839 -> 0.916 Inexact Rounded sqtx4512 squareroot 0.0839 -> 0.290 Inexact Rounded sqtx4513 squareroot 0.841 -> 0.917 Inexact Rounded sqtx4514 squareroot 0.0841 -> 0.29 sqtx4515 squareroot 0.842 -> 0.918 Inexact Rounded sqtx4516 squareroot 0.0842 -> 0.290 Inexact Rounded sqtx4517 squareroot 0.843 -> 0.918 Inexact Rounded sqtx4518 squareroot 0.0843 -> 0.290 Inexact Rounded sqtx4519 squareroot 0.844 -> 0.919 Inexact Rounded sqtx4520 squareroot 0.0844 -> 0.291 Inexact Rounded sqtx4521 squareroot 0.845 -> 0.919 Inexact Rounded sqtx4522 squareroot 0.0845 -> 0.291 Inexact Rounded sqtx4523 squareroot 0.846 -> 0.920 Inexact Rounded sqtx4524 squareroot 0.0846 -> 0.291 Inexact Rounded sqtx4525 squareroot 0.847 -> 0.920 Inexact Rounded sqtx4526 squareroot 0.0847 -> 0.291 Inexact Rounded sqtx4527 squareroot 0.848 -> 0.921 Inexact Rounded sqtx4528 squareroot 0.0848 -> 0.291 Inexact Rounded sqtx4529 squareroot 0.849 -> 0.921 Inexact Rounded sqtx4530 squareroot 0.0849 -> 0.291 Inexact Rounded sqtx4531 squareroot 0.851 -> 0.922 Inexact Rounded sqtx4532 squareroot 0.0851 -> 0.292 Inexact Rounded sqtx4533 squareroot 0.852 -> 0.923 Inexact Rounded sqtx4534 squareroot 0.0852 -> 0.292 Inexact Rounded sqtx4535 squareroot 0.853 -> 0.924 Inexact Rounded sqtx4536 squareroot 0.0853 -> 0.292 Inexact Rounded sqtx4537 squareroot 0.854 -> 0.924 Inexact Rounded sqtx4538 squareroot 0.0854 -> 0.292 Inexact Rounded sqtx4539 squareroot 0.855 -> 0.925 Inexact Rounded sqtx4540 squareroot 0.0855 -> 0.292 Inexact Rounded sqtx4541 squareroot 0.856 -> 0.925 Inexact Rounded sqtx4542 squareroot 0.0856 -> 0.293 Inexact Rounded sqtx4543 squareroot 0.857 -> 0.926 Inexact Rounded sqtx4544 squareroot 0.0857 -> 0.293 Inexact Rounded sqtx4545 squareroot 0.858 -> 0.926 Inexact Rounded sqtx4546 squareroot 0.0858 -> 0.293 Inexact Rounded sqtx4547 squareroot 0.859 -> 0.927 Inexact Rounded sqtx4548 squareroot 0.0859 -> 0.293 Inexact Rounded sqtx4549 squareroot 0.861 -> 0.928 Inexact Rounded sqtx4550 squareroot 0.0861 -> 0.293 Inexact Rounded sqtx4551 squareroot 0.862 -> 0.928 Inexact Rounded sqtx4552 squareroot 0.0862 -> 0.294 Inexact Rounded sqtx4553 squareroot 0.863 -> 0.929 Inexact Rounded sqtx4554 squareroot 0.0863 -> 0.294 Inexact Rounded sqtx4555 squareroot 0.864 -> 0.930 Inexact Rounded sqtx4556 squareroot 0.0864 -> 0.294 Inexact Rounded sqtx4557 squareroot 0.865 -> 0.930 Inexact Rounded sqtx4558 squareroot 0.0865 -> 0.294 Inexact Rounded sqtx4559 squareroot 0.866 -> 0.931 Inexact Rounded sqtx4560 squareroot 0.0866 -> 0.294 Inexact Rounded sqtx4561 squareroot 0.867 -> 0.931 Inexact Rounded sqtx4562 squareroot 0.0867 -> 0.294 Inexact Rounded sqtx4563 squareroot 0.868 -> 0.932 Inexact Rounded sqtx4564 squareroot 0.0868 -> 0.295 Inexact Rounded sqtx4565 squareroot 0.869 -> 0.932 Inexact Rounded sqtx4566 squareroot 0.0869 -> 0.295 Inexact Rounded sqtx4567 squareroot 0.871 -> 0.933 Inexact Rounded sqtx4568 squareroot 0.0871 -> 0.295 Inexact Rounded sqtx4569 squareroot 0.872 -> 0.934 Inexact Rounded sqtx4570 squareroot 0.0872 -> 0.295 Inexact Rounded sqtx4571 squareroot 0.873 -> 0.934 Inexact Rounded sqtx4572 squareroot 0.0873 -> 0.295 Inexact Rounded sqtx4573 squareroot 0.874 -> 0.935 Inexact Rounded sqtx4574 squareroot 0.0874 -> 0.296 Inexact Rounded sqtx4575 squareroot 0.875 -> 0.935 Inexact Rounded sqtx4576 squareroot 0.0875 -> 0.296 Inexact Rounded sqtx4577 squareroot 0.876 -> 0.936 Inexact Rounded sqtx4578 squareroot 0.0876 -> 0.296 Inexact Rounded sqtx4579 squareroot 0.877 -> 0.936 Inexact Rounded sqtx4580 squareroot 0.0877 -> 0.296 Inexact Rounded sqtx4581 squareroot 0.878 -> 0.937 Inexact Rounded sqtx4582 squareroot 0.0878 -> 0.296 Inexact Rounded sqtx4583 squareroot 0.879 -> 0.938 Inexact Rounded sqtx4584 squareroot 0.0879 -> 0.296 Inexact Rounded sqtx4585 squareroot 0.881 -> 0.939 Inexact Rounded sqtx4586 squareroot 0.0881 -> 0.297 Inexact Rounded sqtx4587 squareroot 0.882 -> 0.939 Inexact Rounded sqtx4588 squareroot 0.0882 -> 0.297 Inexact Rounded sqtx4589 squareroot 0.883 -> 0.940 Inexact Rounded sqtx4590 squareroot 0.0883 -> 0.297 Inexact Rounded sqtx4591 squareroot 0.884 -> 0.940 Inexact Rounded sqtx4592 squareroot 0.0884 -> 0.297 Inexact Rounded sqtx4593 squareroot 0.885 -> 0.941 Inexact Rounded sqtx4594 squareroot 0.0885 -> 0.297 Inexact Rounded sqtx4595 squareroot 0.886 -> 0.941 Inexact Rounded sqtx4596 squareroot 0.0886 -> 0.298 Inexact Rounded sqtx4597 squareroot 0.887 -> 0.942 Inexact Rounded sqtx4598 squareroot 0.0887 -> 0.298 Inexact Rounded sqtx4599 squareroot 0.888 -> 0.942 Inexact Rounded sqtx4600 squareroot 0.0888 -> 0.298 Inexact Rounded sqtx4601 squareroot 0.889 -> 0.943 Inexact Rounded sqtx4602 squareroot 0.0889 -> 0.298 Inexact Rounded sqtx4603 squareroot 0.891 -> 0.944 Inexact Rounded sqtx4604 squareroot 0.0891 -> 0.298 Inexact Rounded sqtx4605 squareroot 0.892 -> 0.944 Inexact Rounded sqtx4606 squareroot 0.0892 -> 0.299 Inexact Rounded sqtx4607 squareroot 0.893 -> 0.945 Inexact Rounded sqtx4608 squareroot 0.0893 -> 0.299 Inexact Rounded sqtx4609 squareroot 0.894 -> 0.946 Inexact Rounded sqtx4610 squareroot 0.0894 -> 0.299 Inexact Rounded sqtx4611 squareroot 0.895 -> 0.946 Inexact Rounded sqtx4612 squareroot 0.0895 -> 0.299 Inexact Rounded sqtx4613 squareroot 0.896 -> 0.947 Inexact Rounded sqtx4614 squareroot 0.0896 -> 0.299 Inexact Rounded sqtx4615 squareroot 0.897 -> 0.947 Inexact Rounded sqtx4616 squareroot 0.0897 -> 0.299 Inexact Rounded sqtx4617 squareroot 0.898 -> 0.948 Inexact Rounded sqtx4618 squareroot 0.0898 -> 0.300 Inexact Rounded sqtx4619 squareroot 0.899 -> 0.948 Inexact Rounded sqtx4620 squareroot 0.0899 -> 0.300 Inexact Rounded sqtx4621 squareroot 0.901 -> 0.949 Inexact Rounded sqtx4622 squareroot 0.0901 -> 0.300 Inexact Rounded sqtx4623 squareroot 0.902 -> 0.950 Inexact Rounded sqtx4624 squareroot 0.0902 -> 0.300 Inexact Rounded sqtx4625 squareroot 0.903 -> 0.950 Inexact Rounded sqtx4626 squareroot 0.0903 -> 0.300 Inexact Rounded sqtx4627 squareroot 0.904 -> 0.951 Inexact Rounded sqtx4628 squareroot 0.0904 -> 0.301 Inexact Rounded sqtx4629 squareroot 0.905 -> 0.951 Inexact Rounded sqtx4630 squareroot 0.0905 -> 0.301 Inexact Rounded sqtx4631 squareroot 0.906 -> 0.952 Inexact Rounded sqtx4632 squareroot 0.0906 -> 0.301 Inexact Rounded sqtx4633 squareroot 0.907 -> 0.952 Inexact Rounded sqtx4634 squareroot 0.0907 -> 0.301 Inexact Rounded sqtx4635 squareroot 0.908 -> 0.953 Inexact Rounded sqtx4636 squareroot 0.0908 -> 0.301 Inexact Rounded sqtx4637 squareroot 0.909 -> 0.953 Inexact Rounded sqtx4638 squareroot 0.0909 -> 0.301 Inexact Rounded sqtx4639 squareroot 0.911 -> 0.954 Inexact Rounded sqtx4640 squareroot 0.0911 -> 0.302 Inexact Rounded sqtx4641 squareroot 0.912 -> 0.955 Inexact Rounded sqtx4642 squareroot 0.0912 -> 0.302 Inexact Rounded sqtx4643 squareroot 0.913 -> 0.956 Inexact Rounded sqtx4644 squareroot 0.0913 -> 0.302 Inexact Rounded sqtx4645 squareroot 0.914 -> 0.956 Inexact Rounded sqtx4646 squareroot 0.0914 -> 0.302 Inexact Rounded sqtx4647 squareroot 0.915 -> 0.957 Inexact Rounded sqtx4648 squareroot 0.0915 -> 0.302 Inexact Rounded sqtx4649 squareroot 0.916 -> 0.957 Inexact Rounded sqtx4650 squareroot 0.0916 -> 0.303 Inexact Rounded sqtx4651 squareroot 0.917 -> 0.958 Inexact Rounded sqtx4652 squareroot 0.0917 -> 0.303 Inexact Rounded sqtx4653 squareroot 0.918 -> 0.958 Inexact Rounded sqtx4654 squareroot 0.0918 -> 0.303 Inexact Rounded sqtx4655 squareroot 0.919 -> 0.959 Inexact Rounded sqtx4656 squareroot 0.0919 -> 0.303 Inexact Rounded sqtx4657 squareroot 0.921 -> 0.960 Inexact Rounded sqtx4658 squareroot 0.0921 -> 0.303 Inexact Rounded sqtx4659 squareroot 0.922 -> 0.960 Inexact Rounded sqtx4660 squareroot 0.0922 -> 0.304 Inexact Rounded sqtx4661 squareroot 0.923 -> 0.961 Inexact Rounded sqtx4662 squareroot 0.0923 -> 0.304 Inexact Rounded sqtx4663 squareroot 0.924 -> 0.961 Inexact Rounded sqtx4664 squareroot 0.0924 -> 0.304 Inexact Rounded sqtx4665 squareroot 0.925 -> 0.962 Inexact Rounded sqtx4666 squareroot 0.0925 -> 0.304 Inexact Rounded sqtx4667 squareroot 0.926 -> 0.962 Inexact Rounded sqtx4668 squareroot 0.0926 -> 0.304 Inexact Rounded sqtx4669 squareroot 0.927 -> 0.963 Inexact Rounded sqtx4670 squareroot 0.0927 -> 0.304 Inexact Rounded sqtx4671 squareroot 0.928 -> 0.963 Inexact Rounded sqtx4672 squareroot 0.0928 -> 0.305 Inexact Rounded sqtx4673 squareroot 0.929 -> 0.964 Inexact Rounded sqtx4674 squareroot 0.0929 -> 0.305 Inexact Rounded sqtx4675 squareroot 0.931 -> 0.965 Inexact Rounded sqtx4676 squareroot 0.0931 -> 0.305 Inexact Rounded sqtx4677 squareroot 0.932 -> 0.965 Inexact Rounded sqtx4678 squareroot 0.0932 -> 0.305 Inexact Rounded sqtx4679 squareroot 0.933 -> 0.966 Inexact Rounded sqtx4680 squareroot 0.0933 -> 0.305 Inexact Rounded sqtx4681 squareroot 0.934 -> 0.966 Inexact Rounded sqtx4682 squareroot 0.0934 -> 0.306 Inexact Rounded sqtx4683 squareroot 0.935 -> 0.967 Inexact Rounded sqtx4684 squareroot 0.0935 -> 0.306 Inexact Rounded sqtx4685 squareroot 0.936 -> 0.967 Inexact Rounded sqtx4686 squareroot 0.0936 -> 0.306 Inexact Rounded sqtx4687 squareroot 0.937 -> 0.968 Inexact Rounded sqtx4688 squareroot 0.0937 -> 0.306 Inexact Rounded sqtx4689 squareroot 0.938 -> 0.969 Inexact Rounded sqtx4690 squareroot 0.0938 -> 0.306 Inexact Rounded sqtx4691 squareroot 0.939 -> 0.969 Inexact Rounded sqtx4692 squareroot 0.0939 -> 0.306 Inexact Rounded sqtx4693 squareroot 0.941 -> 0.970 Inexact Rounded sqtx4694 squareroot 0.0941 -> 0.307 Inexact Rounded sqtx4695 squareroot 0.942 -> 0.971 Inexact Rounded sqtx4696 squareroot 0.0942 -> 0.307 Inexact Rounded sqtx4697 squareroot 0.943 -> 0.971 Inexact Rounded sqtx4698 squareroot 0.0943 -> 0.307 Inexact Rounded sqtx4699 squareroot 0.944 -> 0.972 Inexact Rounded sqtx4700 squareroot 0.0944 -> 0.307 Inexact Rounded sqtx4701 squareroot 0.945 -> 0.972 Inexact Rounded sqtx4702 squareroot 0.0945 -> 0.307 Inexact Rounded sqtx4703 squareroot 0.946 -> 0.973 Inexact Rounded sqtx4704 squareroot 0.0946 -> 0.308 Inexact Rounded sqtx4705 squareroot 0.947 -> 0.973 Inexact Rounded sqtx4706 squareroot 0.0947 -> 0.308 Inexact Rounded sqtx4707 squareroot 0.948 -> 0.974 Inexact Rounded sqtx4708 squareroot 0.0948 -> 0.308 Inexact Rounded sqtx4709 squareroot 0.949 -> 0.974 Inexact Rounded sqtx4710 squareroot 0.0949 -> 0.308 Inexact Rounded sqtx4711 squareroot 0.951 -> 0.975 Inexact Rounded sqtx4712 squareroot 0.0951 -> 0.308 Inexact Rounded sqtx4713 squareroot 0.952 -> 0.976 Inexact Rounded sqtx4714 squareroot 0.0952 -> 0.309 Inexact Rounded sqtx4715 squareroot 0.953 -> 0.976 Inexact Rounded sqtx4716 squareroot 0.0953 -> 0.309 Inexact Rounded sqtx4717 squareroot 0.954 -> 0.977 Inexact Rounded sqtx4718 squareroot 0.0954 -> 0.309 Inexact Rounded sqtx4719 squareroot 0.955 -> 0.977 Inexact Rounded sqtx4720 squareroot 0.0955 -> 0.309 Inexact Rounded sqtx4721 squareroot 0.956 -> 0.978 Inexact Rounded sqtx4722 squareroot 0.0956 -> 0.309 Inexact Rounded sqtx4723 squareroot 0.957 -> 0.978 Inexact Rounded sqtx4724 squareroot 0.0957 -> 0.309 Inexact Rounded sqtx4725 squareroot 0.958 -> 0.979 Inexact Rounded sqtx4726 squareroot 0.0958 -> 0.310 Inexact Rounded sqtx4727 squareroot 0.959 -> 0.979 Inexact Rounded sqtx4728 squareroot 0.0959 -> 0.310 Inexact Rounded sqtx4729 squareroot 0.961 -> 0.980 Inexact Rounded sqtx4730 squareroot 0.0961 -> 0.31 sqtx4731 squareroot 0.962 -> 0.981 Inexact Rounded sqtx4732 squareroot 0.0962 -> 0.310 Inexact Rounded sqtx4733 squareroot 0.963 -> 0.981 Inexact Rounded sqtx4734 squareroot 0.0963 -> 0.310 Inexact Rounded sqtx4735 squareroot 0.964 -> 0.982 Inexact Rounded sqtx4736 squareroot 0.0964 -> 0.310 Inexact Rounded sqtx4737 squareroot 0.965 -> 0.982 Inexact Rounded sqtx4738 squareroot 0.0965 -> 0.311 Inexact Rounded sqtx4739 squareroot 0.966 -> 0.983 Inexact Rounded sqtx4740 squareroot 0.0966 -> 0.311 Inexact Rounded sqtx4741 squareroot 0.967 -> 0.983 Inexact Rounded sqtx4742 squareroot 0.0967 -> 0.311 Inexact Rounded sqtx4743 squareroot 0.968 -> 0.984 Inexact Rounded sqtx4744 squareroot 0.0968 -> 0.311 Inexact Rounded sqtx4745 squareroot 0.969 -> 0.984 Inexact Rounded sqtx4746 squareroot 0.0969 -> 0.311 Inexact Rounded sqtx4747 squareroot 0.971 -> 0.985 Inexact Rounded sqtx4748 squareroot 0.0971 -> 0.312 Inexact Rounded sqtx4749 squareroot 0.972 -> 0.986 Inexact Rounded sqtx4750 squareroot 0.0972 -> 0.312 Inexact Rounded sqtx4751 squareroot 0.973 -> 0.986 Inexact Rounded sqtx4752 squareroot 0.0973 -> 0.312 Inexact Rounded sqtx4753 squareroot 0.974 -> 0.987 Inexact Rounded sqtx4754 squareroot 0.0974 -> 0.312 Inexact Rounded sqtx4755 squareroot 0.975 -> 0.987 Inexact Rounded sqtx4756 squareroot 0.0975 -> 0.312 Inexact Rounded sqtx4757 squareroot 0.976 -> 0.988 Inexact Rounded sqtx4758 squareroot 0.0976 -> 0.312 Inexact Rounded sqtx4759 squareroot 0.977 -> 0.988 Inexact Rounded sqtx4760 squareroot 0.0977 -> 0.313 Inexact Rounded sqtx4761 squareroot 0.978 -> 0.989 Inexact Rounded sqtx4762 squareroot 0.0978 -> 0.313 Inexact Rounded sqtx4763 squareroot 0.979 -> 0.989 Inexact Rounded sqtx4764 squareroot 0.0979 -> 0.313 Inexact Rounded sqtx4765 squareroot 0.981 -> 0.990 Inexact Rounded sqtx4766 squareroot 0.0981 -> 0.313 Inexact Rounded sqtx4767 squareroot 0.982 -> 0.991 Inexact Rounded sqtx4768 squareroot 0.0982 -> 0.313 Inexact Rounded sqtx4769 squareroot 0.983 -> 0.991 Inexact Rounded sqtx4770 squareroot 0.0983 -> 0.314 Inexact Rounded sqtx4771 squareroot 0.984 -> 0.992 Inexact Rounded sqtx4772 squareroot 0.0984 -> 0.314 Inexact Rounded sqtx4773 squareroot 0.985 -> 0.992 Inexact Rounded sqtx4774 squareroot 0.0985 -> 0.314 Inexact Rounded sqtx4775 squareroot 0.986 -> 0.993 Inexact Rounded sqtx4776 squareroot 0.0986 -> 0.314 Inexact Rounded sqtx4777 squareroot 0.987 -> 0.993 Inexact Rounded sqtx4778 squareroot 0.0987 -> 0.314 Inexact Rounded sqtx4779 squareroot 0.988 -> 0.994 Inexact Rounded sqtx4780 squareroot 0.0988 -> 0.314 Inexact Rounded sqtx4781 squareroot 0.989 -> 0.994 Inexact Rounded sqtx4782 squareroot 0.0989 -> 0.314 Inexact Rounded sqtx4783 squareroot 0.991 -> 0.995 Inexact Rounded sqtx4784 squareroot 0.0991 -> 0.315 Inexact Rounded sqtx4785 squareroot 0.992 -> 0.996 Inexact Rounded sqtx4786 squareroot 0.0992 -> 0.315 Inexact Rounded sqtx4787 squareroot 0.993 -> 0.996 Inexact Rounded sqtx4788 squareroot 0.0993 -> 0.315 Inexact Rounded sqtx4789 squareroot 0.994 -> 0.997 Inexact Rounded sqtx4790 squareroot 0.0994 -> 0.315 Inexact Rounded sqtx4791 squareroot 0.995 -> 0.997 Inexact Rounded sqtx4792 squareroot 0.0995 -> 0.315 Inexact Rounded sqtx4793 squareroot 0.996 -> 0.998 Inexact Rounded sqtx4794 squareroot 0.0996 -> 0.316 Inexact Rounded sqtx4795 squareroot 0.997 -> 0.998 Inexact Rounded sqtx4796 squareroot 0.0997 -> 0.316 Inexact Rounded sqtx4797 squareroot 0.998 -> 0.999 Inexact Rounded sqtx4798 squareroot 0.0998 -> 0.316 Inexact Rounded sqtx4799 squareroot 0.999 -> 0.999 Inexact Rounded sqtx4800 squareroot 0.0999 -> 0.316 Inexact Rounded -- A group of precision 4 tests where Hull & Abrham adjustments are -- needed in some cases (both up and down) [see Hull1985b] rounding: half_even maxExponent: 999 minexponent: -999 precision: 4 sqtx5001 squareroot 0.0118 -> 0.1086 Inexact Rounded sqtx5002 squareroot 0.119 -> 0.3450 Inexact Rounded sqtx5003 squareroot 0.0119 -> 0.1091 Inexact Rounded sqtx5004 squareroot 0.121 -> 0.3479 Inexact Rounded sqtx5005 squareroot 0.0121 -> 0.11 sqtx5006 squareroot 0.122 -> 0.3493 Inexact Rounded sqtx5007 squareroot 0.0122 -> 0.1105 Inexact Rounded sqtx5008 squareroot 0.123 -> 0.3507 Inexact Rounded sqtx5009 squareroot 0.494 -> 0.7029 Inexact Rounded sqtx5010 squareroot 0.0669 -> 0.2587 Inexact Rounded sqtx5011 squareroot 0.9558 -> 0.9777 Inexact Rounded sqtx5012 squareroot 0.9348 -> 0.9669 Inexact Rounded sqtx5013 squareroot 0.9345 -> 0.9667 Inexact Rounded sqtx5014 squareroot 0.09345 -> 0.3057 Inexact Rounded sqtx5015 squareroot 0.9346 -> 0.9667 Inexact Rounded sqtx5016 squareroot 0.09346 -> 0.3057 Inexact Rounded sqtx5017 squareroot 0.9347 -> 0.9668 Inexact Rounded -- examples from decArith precision: 9 sqtx700 squareroot 0 -> '0' sqtx701 squareroot -0 -> '-0' sqtx702 squareroot 0.39 -> 0.624499800 Inexact Rounded sqtx703 squareroot 100 -> '10' sqtx704 squareroot 1.00 -> '1.0' sqtx705 squareroot 7 -> '2.64575131' Inexact Rounded sqtx706 squareroot 10 -> 3.16227766 Inexact Rounded -- some one-offs precision: 9 sqtx711 squareroot 0.1 -> 0.316227766 Inexact Rounded sqtx712 squareroot 0.2 -> 0.447213595 Inexact Rounded sqtx713 squareroot 0.3 -> 0.547722558 Inexact Rounded sqtx714 squareroot 0.4 -> 0.632455532 Inexact Rounded sqtx715 squareroot 0.5 -> 0.707106781 Inexact Rounded sqtx716 squareroot 0.6 -> 0.774596669 Inexact Rounded sqtx717 squareroot 0.7 -> 0.836660027 Inexact Rounded sqtx718 squareroot 0.8 -> 0.894427191 Inexact Rounded sqtx719 squareroot 0.9 -> 0.948683298 Inexact Rounded precision: 10 -- note no normalizatoin here sqtx720 squareroot +0.1 -> 0.3162277660 Inexact Rounded precision: 11 sqtx721 squareroot +0.1 -> 0.31622776602 Inexact Rounded precision: 12 sqtx722 squareroot +0.1 -> 0.316227766017 Inexact Rounded precision: 9 sqtx723 squareroot 0.39 -> 0.624499800 Inexact Rounded precision: 15 sqtx724 squareroot 0.39 -> 0.624499799839840 Inexact Rounded -- discussion cases precision: 7 sqtx731 squareroot 9 -> 3 sqtx732 squareroot 100 -> 10 sqtx733 squareroot 123 -> 11.09054 Inexact Rounded sqtx734 squareroot 144 -> 12 sqtx735 squareroot 156 -> 12.49000 Inexact Rounded sqtx736 squareroot 10000 -> 100 -- values close to overflow (if there were input rounding) maxexponent: 99 minexponent: -99 precision: 5 sqtx760 squareroot 9.9997E+99 -> 9.9998E+49 Inexact Rounded sqtx761 squareroot 9.9998E+99 -> 9.9999E+49 Inexact Rounded sqtx762 squareroot 9.9999E+99 -> 9.9999E+49 Inexact Rounded sqtx763 squareroot 9.99991E+99 -> 1.0000E+50 Inexact Rounded sqtx764 squareroot 9.99994E+99 -> 1.0000E+50 Inexact Rounded sqtx765 squareroot 9.99995E+99 -> 1.0000E+50 Inexact Rounded sqtx766 squareroot 9.99999E+99 -> 1.0000E+50 Inexact Rounded precision: 9 sqtx770 squareroot 9.9997E+99 -> 9.99985000E+49 Inexact Rounded sqtx771 squareroot 9.9998E+99 -> 9.99990000E+49 Inexact Rounded sqtx772 squareroot 9.9999E+99 -> 9.99995000E+49 Inexact Rounded sqtx773 squareroot 9.99991E+99 -> 9.99995500E+49 Inexact Rounded sqtx774 squareroot 9.99994E+99 -> 9.99997000E+49 Inexact Rounded sqtx775 squareroot 9.99995E+99 -> 9.99997500E+49 Inexact Rounded sqtx776 squareroot 9.99999E+99 -> 9.99999500E+49 Inexact Rounded precision: 20 sqtx780 squareroot 9.9997E+99 -> '9.9998499988749831247E+49' Inexact Rounded sqtx781 squareroot 9.9998E+99 -> '9.9998999994999949999E+49' Inexact Rounded sqtx782 squareroot 9.9999E+99 -> '9.9999499998749993750E+49' Inexact Rounded sqtx783 squareroot 9.99991E+99 -> '9.9999549998987495444E+49' Inexact Rounded sqtx784 squareroot 9.99994E+99 -> '9.9999699999549998650E+49' Inexact Rounded sqtx785 squareroot 9.99995E+99 -> '9.9999749999687499219E+49' Inexact Rounded sqtx786 squareroot 9.99999E+99 -> '9.9999949999987499994E+49' Inexact Rounded -- subnormals and underflows [these can only result when eMax is < digits+1] -- Etiny = -(Emax + (precision-1)) -- start with subnormal operands and normal results maxexponent: 9 minexponent: -9 precision: 9 -- Etiny=-17 sqtx800 squareroot 1E-17 -> 3.16227766E-9 Inexact Rounded sqtx801 squareroot 10E-17 -> 1.0E-8 precision: 10 -- Etiny=-18 sqtx802 squareroot 10E-18 -> 3.162277660E-9 Inexact Rounded sqtx803 squareroot 1E-18 -> 1E-9 precision: 11 -- Etiny=-19 sqtx804 squareroot 1E-19 -> 3.162277660E-10 Underflow Subnormal Inexact Rounded sqtx805 squareroot 10E-19 -> 1.0E-9 -- exact precision: 12 -- Etiny=-20 sqtx806 squareroot 10E-20 -> 3.1622776602E-10 Underflow Subnormal Inexact Rounded sqtx807 squareroot 1E-20 -> 1E-10 Subnormal -- exact Subnormal case precision: 13 -- Etiny=-21 sqtx808 squareroot 1E-21 -> 3.1622776602E-11 Underflow Subnormal Inexact Rounded sqtx809 squareroot 10E-21 -> 1.0E-10 Subnormal -- exact Subnormal case precision: 14 -- Etiny=-22 sqtx810 squareroot 1E-21 -> 3.16227766017E-11 Underflow Subnormal Inexact Rounded sqtx811 squareroot 10E-22 -> 3.16227766017E-11 Underflow Subnormal Inexact Rounded sqtx812 squareroot 1E-22 -> 1E-11 Subnormal -- exact Subnormal case -- Not enough digits? precision: 16 maxExponent: 384 minExponent: -383 rounding: half_even sqtx815 squareroot 1.0000000001000000E-78 -> 1.000000000050000E-39 Inexact Rounded -- 1 234567890123456 -- special values maxexponent: 999 minexponent: -999 sqtx820 squareroot Inf -> Infinity sqtx821 squareroot -Inf -> NaN Invalid_operation sqtx822 squareroot NaN -> NaN sqtx823 squareroot sNaN -> NaN Invalid_operation -- propagating NaNs sqtx824 squareroot sNaN123 -> NaN123 Invalid_operation sqtx825 squareroot -sNaN321 -> -NaN321 Invalid_operation sqtx826 squareroot NaN456 -> NaN456 sqtx827 squareroot -NaN654 -> -NaN654 sqtx828 squareroot NaN1 -> NaN1 -- payload decapitate precision: 5 sqtx840 squareroot -sNaN1234567890 -> -NaN67890 Invalid_operation ------------------------------------------------------------------------ -- -- Special thanks to Mark Dickinson for tests in the range 8000-8999. -- -- Extra tests for the square root function, dealing with a variety of -- corner cases. In particular, these tests concentrate on -- (1) cases where the input precision exceeds the context precision, and -- (2) cases where the input exponent is outside the current context, -- and in particular when the result is subnormal -- -- maxexponent and minexponent are set to 9 and -9 for most of these -- cases; only the precision changes. The rounding also does not -- change, because it is ignored for this operation. maxexponent: 9 minexponent: -9 -- exact results, input precision > context precision precision: 1 sqtx8000 squareroot 0 -> 0 sqtx8001 squareroot 1 -> 1 sqtx8002 squareroot 4 -> 2 sqtx8003 squareroot 9 -> 3 sqtx8004 squareroot 16 -> 4 sqtx8005 squareroot 25 -> 5 sqtx8006 squareroot 36 -> 6 sqtx8007 squareroot 49 -> 7 sqtx8008 squareroot 64 -> 8 sqtx8009 squareroot 81 -> 9 sqtx8010 squareroot 100 -> 1E+1 Rounded sqtx8011 squareroot 121 -> 1E+1 Inexact Rounded precision: 2 sqtx8012 squareroot 0 -> 0 sqtx8013 squareroot 1 -> 1 sqtx8014 squareroot 4 -> 2 sqtx8015 squareroot 9 -> 3 sqtx8016 squareroot 16 -> 4 sqtx8017 squareroot 25 -> 5 sqtx8018 squareroot 36 -> 6 sqtx8019 squareroot 49 -> 7 sqtx8020 squareroot 64 -> 8 sqtx8021 squareroot 81 -> 9 sqtx8022 squareroot 100 -> 10 sqtx8023 squareroot 121 -> 11 sqtx8024 squareroot 144 -> 12 sqtx8025 squareroot 169 -> 13 sqtx8026 squareroot 196 -> 14 sqtx8027 squareroot 225 -> 15 sqtx8028 squareroot 256 -> 16 sqtx8029 squareroot 289 -> 17 sqtx8030 squareroot 324 -> 18 sqtx8031 squareroot 361 -> 19 sqtx8032 squareroot 400 -> 20 sqtx8033 squareroot 441 -> 21 sqtx8034 squareroot 484 -> 22 sqtx8035 squareroot 529 -> 23 sqtx8036 squareroot 576 -> 24 sqtx8037 squareroot 625 -> 25 sqtx8038 squareroot 676 -> 26 sqtx8039 squareroot 729 -> 27 sqtx8040 squareroot 784 -> 28 sqtx8041 squareroot 841 -> 29 sqtx8042 squareroot 900 -> 30 sqtx8043 squareroot 961 -> 31 sqtx8044 squareroot 1024 -> 32 sqtx8045 squareroot 1089 -> 33 sqtx8046 squareroot 1156 -> 34 sqtx8047 squareroot 1225 -> 35 sqtx8048 squareroot 1296 -> 36 sqtx8049 squareroot 1369 -> 37 sqtx8050 squareroot 1444 -> 38 sqtx8051 squareroot 1521 -> 39 sqtx8052 squareroot 1600 -> 40 sqtx8053 squareroot 1681 -> 41 sqtx8054 squareroot 1764 -> 42 sqtx8055 squareroot 1849 -> 43 sqtx8056 squareroot 1936 -> 44 sqtx8057 squareroot 2025 -> 45 sqtx8058 squareroot 2116 -> 46 sqtx8059 squareroot 2209 -> 47 sqtx8060 squareroot 2304 -> 48 sqtx8061 squareroot 2401 -> 49 sqtx8062 squareroot 2500 -> 50 sqtx8063 squareroot 2601 -> 51 sqtx8064 squareroot 2704 -> 52 sqtx8065 squareroot 2809 -> 53 sqtx8066 squareroot 2916 -> 54 sqtx8067 squareroot 3025 -> 55 sqtx8068 squareroot 3136 -> 56 sqtx8069 squareroot 3249 -> 57 sqtx8070 squareroot 3364 -> 58 sqtx8071 squareroot 3481 -> 59 sqtx8072 squareroot 3600 -> 60 sqtx8073 squareroot 3721 -> 61 sqtx8074 squareroot 3844 -> 62 sqtx8075 squareroot 3969 -> 63 sqtx8076 squareroot 4096 -> 64 sqtx8077 squareroot 4225 -> 65 sqtx8078 squareroot 4356 -> 66 sqtx8079 squareroot 4489 -> 67 sqtx8080 squareroot 4624 -> 68 sqtx8081 squareroot 4761 -> 69 sqtx8082 squareroot 4900 -> 70 sqtx8083 squareroot 5041 -> 71 sqtx8084 squareroot 5184 -> 72 sqtx8085 squareroot 5329 -> 73 sqtx8086 squareroot 5476 -> 74 sqtx8087 squareroot 5625 -> 75 sqtx8088 squareroot 5776 -> 76 sqtx8089 squareroot 5929 -> 77 sqtx8090 squareroot 6084 -> 78 sqtx8091 squareroot 6241 -> 79 sqtx8092 squareroot 6400 -> 80 sqtx8093 squareroot 6561 -> 81 sqtx8094 squareroot 6724 -> 82 sqtx8095 squareroot 6889 -> 83 sqtx8096 squareroot 7056 -> 84 sqtx8097 squareroot 7225 -> 85 sqtx8098 squareroot 7396 -> 86 sqtx8099 squareroot 7569 -> 87 sqtx8100 squareroot 7744 -> 88 sqtx8101 squareroot 7921 -> 89 sqtx8102 squareroot 8100 -> 90 sqtx8103 squareroot 8281 -> 91 sqtx8104 squareroot 8464 -> 92 sqtx8105 squareroot 8649 -> 93 sqtx8106 squareroot 8836 -> 94 sqtx8107 squareroot 9025 -> 95 sqtx8108 squareroot 9216 -> 96 sqtx8109 squareroot 9409 -> 97 sqtx8110 squareroot 9604 -> 98 sqtx8111 squareroot 9801 -> 99 sqtx8112 squareroot 10000 -> 1.0E+2 Rounded sqtx8113 squareroot 10201 -> 1.0E+2 Inexact Rounded precision: 3 sqtx8114 squareroot 841 -> 29 sqtx8115 squareroot 1600 -> 40 sqtx8116 squareroot 2209 -> 47 sqtx8117 squareroot 9604 -> 98 sqtx8118 squareroot 21316 -> 146 sqtx8119 squareroot 52441 -> 229 sqtx8120 squareroot 68644 -> 262 sqtx8121 squareroot 69696 -> 264 sqtx8122 squareroot 70225 -> 265 sqtx8123 squareroot 76729 -> 277 sqtx8124 squareroot 130321 -> 361 sqtx8125 squareroot 171396 -> 414 sqtx8126 squareroot 270400 -> 520 sqtx8127 squareroot 279841 -> 529 sqtx8128 squareroot 407044 -> 638 sqtx8129 squareroot 408321 -> 639 sqtx8130 squareroot 480249 -> 693 sqtx8131 squareroot 516961 -> 719 sqtx8132 squareroot 692224 -> 832 sqtx8133 squareroot 829921 -> 911 -- selection of random exact results precision: 6 sqtx8134 squareroot 2.25E-12 -> 0.0000015 sqtx8135 squareroot 8.41E-14 -> 2.9E-7 sqtx8136 squareroot 6.241E-15 -> 7.9E-8 sqtx8137 squareroot 5.041E+13 -> 7.1E+6 sqtx8138 squareroot 4761 -> 69 sqtx8139 squareroot 1.369E+17 -> 3.7E+8 sqtx8140 squareroot 0.00002116 -> 0.0046 sqtx8141 squareroot 7.29E+4 -> 2.7E+2 sqtx8142 squareroot 4.624E-13 -> 6.8E-7 sqtx8143 squareroot 3.969E+5 -> 6.3E+2 sqtx8144 squareroot 3.73321E-11 -> 0.00000611 sqtx8145 squareroot 5.61001E+17 -> 7.49E+8 sqtx8146 squareroot 2.30400E-11 -> 0.00000480 sqtx8147 squareroot 4.30336E+17 -> 6.56E+8 sqtx8148 squareroot 0.057121 -> 0.239 sqtx8149 squareroot 7.225E+17 -> 8.5E+8 sqtx8150 squareroot 3.14721E+13 -> 5.61E+6 sqtx8151 squareroot 4.61041E+17 -> 6.79E+8 sqtx8152 squareroot 1.39876E-15 -> 3.74E-8 sqtx8153 squareroot 6.19369E-9 -> 0.0000787 sqtx8154 squareroot 1.620529E-10 -> 0.00001273 sqtx8155 squareroot 1177.1761 -> 34.31 sqtx8156 squareroot 67043344 -> 8188 sqtx8157 squareroot 4.84E+6 -> 2.2E+3 sqtx8158 squareroot 1.23904E+11 -> 3.52E+5 sqtx8159 squareroot 32604100 -> 5710 sqtx8160 squareroot 2.9757025E-11 -> 0.000005455 sqtx8161 squareroot 6.3760225E-9 -> 0.00007985 sqtx8162 squareroot 4.5198729E-11 -> 0.000006723 sqtx8163 squareroot 1.4745600E-11 -> 0.000003840 sqtx8164 squareroot 18964283.04 -> 4354.8 sqtx8165 squareroot 3.308895529E+13 -> 5.7523E+6 sqtx8166 squareroot 0.0028590409 -> 0.05347 sqtx8167 squareroot 3572.213824 -> 59.768 sqtx8168 squareroot 4.274021376E+15 -> 6.5376E+7 sqtx8169 squareroot 4455476.64 -> 2110.8 sqtx8170 squareroot 38.44 -> 6.2 sqtx8171 squareroot 68.558400 -> 8.280 sqtx8172 squareroot 715402009 -> 26747 sqtx8173 squareroot 93.373569 -> 9.663 sqtx8174 squareroot 2.62144000000E+15 -> 5.12000E+7 sqtx8175 squareroot 7.48225000000E+15 -> 8.65000E+7 sqtx8176 squareroot 3.38724000000E-9 -> 0.0000582000 sqtx8177 squareroot 5.64001000000E-13 -> 7.51000E-7 sqtx8178 squareroot 5.06944000000E-15 -> 7.12000E-8 sqtx8179 squareroot 4.95616000000E+17 -> 7.04000E+8 sqtx8180 squareroot 0.0000242064000000 -> 0.00492000 sqtx8181 squareroot 1.48996000000E-15 -> 3.86000E-8 sqtx8182 squareroot 9.37024000000E+17 -> 9.68000E+8 sqtx8183 squareroot 7128900.0000 -> 2670.00 sqtx8184 squareroot 8.2311610000E-10 -> 0.0000286900 sqtx8185 squareroot 482747040000 -> 694800 sqtx8186 squareroot 4.14478440000E+17 -> 6.43800E+8 sqtx8187 squareroot 5.10510250000E-7 -> 0.000714500 sqtx8188 squareroot 355096.810000 -> 595.900 sqtx8189 squareroot 14288400.0000 -> 3780.00 sqtx8190 squareroot 3.36168040000E-15 -> 5.79800E-8 sqtx8191 squareroot 1.70899560000E-13 -> 4.13400E-7 sqtx8192 squareroot 0.0000378348010000 -> 0.00615100 sqtx8193 squareroot 2.00972890000E-13 -> 4.48300E-7 sqtx8194 squareroot 4.07222659600E-13 -> 6.38140E-7 sqtx8195 squareroot 131486012100 -> 362610 sqtx8196 squareroot 818192611600 -> 904540 sqtx8197 squareroot 9.8558323600E+16 -> 3.13940E+8 sqtx8198 squareroot 5641.06144900 -> 75.1070 sqtx8199 squareroot 4.58789475600E+17 -> 6.77340E+8 sqtx8200 squareroot 3.21386948100E-9 -> 0.0000566910 sqtx8201 squareroot 3.9441960000E-8 -> 0.000198600 sqtx8202 squareroot 242723.728900 -> 492.670 sqtx8203 squareroot 1874.89000000 -> 43.3000 sqtx8204 squareroot 2.56722595684E+15 -> 5.06678E+7 sqtx8205 squareroot 3.96437714689E-17 -> 6.29633E-9 sqtx8206 squareroot 3.80106774784E-17 -> 6.16528E-9 sqtx8207 squareroot 1.42403588496E-13 -> 3.77364E-7 sqtx8208 squareroot 4604.84388100 -> 67.8590 sqtx8209 squareroot 2157100869.16 -> 46444.6 sqtx8210 squareroot 355288570.81 -> 18849.1 sqtx8211 squareroot 4.69775901604E-11 -> 0.00000685402 sqtx8212 squareroot 8.22115770436E+17 -> 9.06706E+8 sqtx8213 squareroot 7.16443744900E+15 -> 8.46430E+7 sqtx8214 squareroot 9.48995498896E+15 -> 9.74164E+7 sqtx8215 squareroot 0.0000419091801129 -> 0.00647373 sqtx8216 squareroot 5862627996.84 -> 76567.8 sqtx8217 squareroot 9369537.3409 -> 3060.97 sqtx8218 squareroot 7.74792529729E+17 -> 8.80223E+8 sqtx8219 squareroot 1.08626931396E+17 -> 3.29586E+8 sqtx8220 squareroot 8.89584739684E-7 -> 0.000943178 sqtx8221 squareroot 4.0266040896E-18 -> 2.00664E-9 sqtx8222 squareroot 9.27669480336E-7 -> 0.000963156 sqtx8223 squareroot 0.00225497717956 -> 0.0474866 -- test use of round-half-even for ties precision: 1 sqtx8224 squareroot 225 -> 2E+1 Inexact Rounded sqtx8225 squareroot 625 -> 2E+1 Inexact Rounded sqtx8226 squareroot 1225 -> 4E+1 Inexact Rounded sqtx8227 squareroot 2025 -> 4E+1 Inexact Rounded sqtx8228 squareroot 3025 -> 6E+1 Inexact Rounded sqtx8229 squareroot 4225 -> 6E+1 Inexact Rounded sqtx8230 squareroot 5625 -> 8E+1 Inexact Rounded sqtx8231 squareroot 7225 -> 8E+1 Inexact Rounded sqtx8232 squareroot 9025 -> 1E+2 Inexact Rounded precision: 2 sqtx8233 squareroot 11025 -> 1.0E+2 Inexact Rounded sqtx8234 squareroot 13225 -> 1.2E+2 Inexact Rounded sqtx8235 squareroot 15625 -> 1.2E+2 Inexact Rounded sqtx8236 squareroot 18225 -> 1.4E+2 Inexact Rounded sqtx8237 squareroot 21025 -> 1.4E+2 Inexact Rounded sqtx8238 squareroot 24025 -> 1.6E+2 Inexact Rounded sqtx8239 squareroot 27225 -> 1.6E+2 Inexact Rounded sqtx8240 squareroot 30625 -> 1.8E+2 Inexact Rounded sqtx8241 squareroot 34225 -> 1.8E+2 Inexact Rounded sqtx8242 squareroot 38025 -> 2.0E+2 Inexact Rounded sqtx8243 squareroot 42025 -> 2.0E+2 Inexact Rounded sqtx8244 squareroot 46225 -> 2.2E+2 Inexact Rounded sqtx8245 squareroot 50625 -> 2.2E+2 Inexact Rounded sqtx8246 squareroot 55225 -> 2.4E+2 Inexact Rounded sqtx8247 squareroot 60025 -> 2.4E+2 Inexact Rounded sqtx8248 squareroot 65025 -> 2.6E+2 Inexact Rounded sqtx8249 squareroot 70225 -> 2.6E+2 Inexact Rounded sqtx8250 squareroot 75625 -> 2.8E+2 Inexact Rounded sqtx8251 squareroot 81225 -> 2.8E+2 Inexact Rounded sqtx8252 squareroot 87025 -> 3.0E+2 Inexact Rounded sqtx8253 squareroot 93025 -> 3.0E+2 Inexact Rounded sqtx8254 squareroot 99225 -> 3.2E+2 Inexact Rounded sqtx8255 squareroot 105625 -> 3.2E+2 Inexact Rounded sqtx8256 squareroot 112225 -> 3.4E+2 Inexact Rounded sqtx8257 squareroot 119025 -> 3.4E+2 Inexact Rounded sqtx8258 squareroot 126025 -> 3.6E+2 Inexact Rounded sqtx8259 squareroot 133225 -> 3.6E+2 Inexact Rounded sqtx8260 squareroot 140625 -> 3.8E+2 Inexact Rounded sqtx8261 squareroot 148225 -> 3.8E+2 Inexact Rounded sqtx8262 squareroot 156025 -> 4.0E+2 Inexact Rounded sqtx8263 squareroot 164025 -> 4.0E+2 Inexact Rounded sqtx8264 squareroot 172225 -> 4.2E+2 Inexact Rounded sqtx8265 squareroot 180625 -> 4.2E+2 Inexact Rounded sqtx8266 squareroot 189225 -> 4.4E+2 Inexact Rounded sqtx8267 squareroot 198025 -> 4.4E+2 Inexact Rounded sqtx8268 squareroot 207025 -> 4.6E+2 Inexact Rounded sqtx8269 squareroot 216225 -> 4.6E+2 Inexact Rounded sqtx8270 squareroot 225625 -> 4.8E+2 Inexact Rounded sqtx8271 squareroot 235225 -> 4.8E+2 Inexact Rounded sqtx8272 squareroot 245025 -> 5.0E+2 Inexact Rounded sqtx8273 squareroot 255025 -> 5.0E+2 Inexact Rounded sqtx8274 squareroot 265225 -> 5.2E+2 Inexact Rounded sqtx8275 squareroot 275625 -> 5.2E+2 Inexact Rounded sqtx8276 squareroot 286225 -> 5.4E+2 Inexact Rounded sqtx8277 squareroot 297025 -> 5.4E+2 Inexact Rounded sqtx8278 squareroot 308025 -> 5.6E+2 Inexact Rounded sqtx8279 squareroot 319225 -> 5.6E+2 Inexact Rounded sqtx8280 squareroot 330625 -> 5.8E+2 Inexact Rounded sqtx8281 squareroot 342225 -> 5.8E+2 Inexact Rounded sqtx8282 squareroot 354025 -> 6.0E+2 Inexact Rounded sqtx8283 squareroot 366025 -> 6.0E+2 Inexact Rounded sqtx8284 squareroot 378225 -> 6.2E+2 Inexact Rounded sqtx8285 squareroot 390625 -> 6.2E+2 Inexact Rounded sqtx8286 squareroot 403225 -> 6.4E+2 Inexact Rounded sqtx8287 squareroot 416025 -> 6.4E+2 Inexact Rounded sqtx8288 squareroot 429025 -> 6.6E+2 Inexact Rounded sqtx8289 squareroot 442225 -> 6.6E+2 Inexact Rounded sqtx8290 squareroot 455625 -> 6.8E+2 Inexact Rounded sqtx8291 squareroot 469225 -> 6.8E+2 Inexact Rounded sqtx8292 squareroot 483025 -> 7.0E+2 Inexact Rounded sqtx8293 squareroot 497025 -> 7.0E+2 Inexact Rounded sqtx8294 squareroot 511225 -> 7.2E+2 Inexact Rounded sqtx8295 squareroot 525625 -> 7.2E+2 Inexact Rounded sqtx8296 squareroot 540225 -> 7.4E+2 Inexact Rounded sqtx8297 squareroot 555025 -> 7.4E+2 Inexact Rounded sqtx8298 squareroot 570025 -> 7.6E+2 Inexact Rounded sqtx8299 squareroot 585225 -> 7.6E+2 Inexact Rounded sqtx8300 squareroot 600625 -> 7.8E+2 Inexact Rounded sqtx8301 squareroot 616225 -> 7.8E+2 Inexact Rounded sqtx8302 squareroot 632025 -> 8.0E+2 Inexact Rounded sqtx8303 squareroot 648025 -> 8.0E+2 Inexact Rounded sqtx8304 squareroot 664225 -> 8.2E+2 Inexact Rounded sqtx8305 squareroot 680625 -> 8.2E+2 Inexact Rounded sqtx8306 squareroot 697225 -> 8.4E+2 Inexact Rounded sqtx8307 squareroot 714025 -> 8.4E+2 Inexact Rounded sqtx8308 squareroot 731025 -> 8.6E+2 Inexact Rounded sqtx8309 squareroot 748225 -> 8.6E+2 Inexact Rounded sqtx8310 squareroot 765625 -> 8.8E+2 Inexact Rounded sqtx8311 squareroot 783225 -> 8.8E+2 Inexact Rounded sqtx8312 squareroot 801025 -> 9.0E+2 Inexact Rounded sqtx8313 squareroot 819025 -> 9.0E+2 Inexact Rounded sqtx8314 squareroot 837225 -> 9.2E+2 Inexact Rounded sqtx8315 squareroot 855625 -> 9.2E+2 Inexact Rounded sqtx8316 squareroot 874225 -> 9.4E+2 Inexact Rounded sqtx8317 squareroot 893025 -> 9.4E+2 Inexact Rounded sqtx8318 squareroot 912025 -> 9.6E+2 Inexact Rounded sqtx8319 squareroot 931225 -> 9.6E+2 Inexact Rounded sqtx8320 squareroot 950625 -> 9.8E+2 Inexact Rounded sqtx8321 squareroot 970225 -> 9.8E+2 Inexact Rounded sqtx8322 squareroot 990025 -> 1.0E+3 Inexact Rounded precision: 6 sqtx8323 squareroot 88975734963025 -> 9.43270E+6 Inexact Rounded sqtx8324 squareroot 71085555000625 -> 8.43122E+6 Inexact Rounded sqtx8325 squareroot 39994304.051025 -> 6324.10 Inexact Rounded sqtx8326 squareroot 0.000007327172265625 -> 0.00270688 Inexact Rounded sqtx8327 squareroot 1.0258600439025E-13 -> 3.20290E-7 Inexact Rounded sqtx8328 squareroot 0.0034580574275625 -> 0.0588052 Inexact Rounded sqtx8329 squareroot 7.6842317700625E-7 -> 0.000876598 Inexact Rounded sqtx8330 squareroot 1263834495.2025 -> 35550.4 Inexact Rounded sqtx8331 squareroot 433970666460.25 -> 658764 Inexact Rounded sqtx8332 squareroot 4.5879286230625E-7 -> 0.000677342 Inexact Rounded sqtx8333 squareroot 0.0029305603306225 -> 0.0541346 Inexact Rounded sqtx8334 squareroot 70218282.733225 -> 8379.64 Inexact Rounded sqtx8335 squareroot 11942519.082025 -> 3455.80 Inexact Rounded sqtx8336 squareroot 0.0021230668905625 -> 0.0460768 Inexact Rounded sqtx8337 squareroot 0.90081833411025 -> 0.949114 Inexact Rounded sqtx8338 squareroot 5.5104120936225E-17 -> 7.42322E-9 Inexact Rounded sqtx8339 squareroot 0.10530446854225 -> 0.324506 Inexact Rounded sqtx8340 squareroot 8.706069866025E-14 -> 2.95060E-7 Inexact Rounded sqtx8341 squareroot 23838.58800625 -> 154.398 Inexact Rounded sqtx8342 squareroot 0.0013426911275625 -> 0.0366428 Inexact Rounded -- test use of round-half-even in underflow situations -- precisions 2; all cases where result is both subnormal and a tie precision: 2 sqtx8343 squareroot 2.5E-21 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped sqtx8344 squareroot 2.25E-20 -> 2E-10 Underflow Subnormal Inexact Rounded sqtx8345 squareroot 6.25E-20 -> 2E-10 Underflow Subnormal Inexact Rounded sqtx8346 squareroot 1.225E-19 -> 4E-10 Underflow Subnormal Inexact Rounded sqtx8347 squareroot 2.025E-19 -> 4E-10 Underflow Subnormal Inexact Rounded sqtx8348 squareroot 3.025E-19 -> 6E-10 Underflow Subnormal Inexact Rounded sqtx8349 squareroot 4.225E-19 -> 6E-10 Underflow Subnormal Inexact Rounded sqtx8350 squareroot 5.625E-19 -> 8E-10 Underflow Subnormal Inexact Rounded sqtx8351 squareroot 7.225E-19 -> 8E-10 Underflow Subnormal Inexact Rounded sqtx8352 squareroot 9.025E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded -- precision 3, input precision <= 5 precision: 3 sqtx8353 squareroot 2.5E-23 -> 0E-11 Underflow Subnormal Inexact Rounded Clamped sqtx8354 squareroot 2.25E-22 -> 2E-11 Underflow Subnormal Inexact Rounded sqtx8355 squareroot 6.25E-22 -> 2E-11 Underflow Subnormal Inexact Rounded sqtx8356 squareroot 1.225E-21 -> 4E-11 Underflow Subnormal Inexact Rounded sqtx8357 squareroot 2.025E-21 -> 4E-11 Underflow Subnormal Inexact Rounded sqtx8358 squareroot 3.025E-21 -> 6E-11 Underflow Subnormal Inexact Rounded sqtx8359 squareroot 4.225E-21 -> 6E-11 Underflow Subnormal Inexact Rounded sqtx8360 squareroot 5.625E-21 -> 8E-11 Underflow Subnormal Inexact Rounded sqtx8361 squareroot 7.225E-21 -> 8E-11 Underflow Subnormal Inexact Rounded sqtx8362 squareroot 9.025E-21 -> 1.0E-10 Underflow Subnormal Inexact Rounded sqtx8363 squareroot 1.1025E-20 -> 1.0E-10 Underflow Subnormal Inexact Rounded sqtx8364 squareroot 1.3225E-20 -> 1.2E-10 Underflow Subnormal Inexact Rounded sqtx8365 squareroot 1.5625E-20 -> 1.2E-10 Underflow Subnormal Inexact Rounded sqtx8366 squareroot 1.8225E-20 -> 1.4E-10 Underflow Subnormal Inexact Rounded sqtx8367 squareroot 2.1025E-20 -> 1.4E-10 Underflow Subnormal Inexact Rounded sqtx8368 squareroot 2.4025E-20 -> 1.6E-10 Underflow Subnormal Inexact Rounded sqtx8369 squareroot 2.7225E-20 -> 1.6E-10 Underflow Subnormal Inexact Rounded sqtx8370 squareroot 3.0625E-20 -> 1.8E-10 Underflow Subnormal Inexact Rounded sqtx8371 squareroot 3.4225E-20 -> 1.8E-10 Underflow Subnormal Inexact Rounded sqtx8372 squareroot 3.8025E-20 -> 2.0E-10 Underflow Subnormal Inexact Rounded sqtx8373 squareroot 4.2025E-20 -> 2.0E-10 Underflow Subnormal Inexact Rounded sqtx8374 squareroot 4.6225E-20 -> 2.2E-10 Underflow Subnormal Inexact Rounded sqtx8375 squareroot 5.0625E-20 -> 2.2E-10 Underflow Subnormal Inexact Rounded sqtx8376 squareroot 5.5225E-20 -> 2.4E-10 Underflow Subnormal Inexact Rounded sqtx8377 squareroot 6.0025E-20 -> 2.4E-10 Underflow Subnormal Inexact Rounded sqtx8378 squareroot 6.5025E-20 -> 2.6E-10 Underflow Subnormal Inexact Rounded sqtx8379 squareroot 7.0225E-20 -> 2.6E-10 Underflow Subnormal Inexact Rounded sqtx8380 squareroot 7.5625E-20 -> 2.8E-10 Underflow Subnormal Inexact Rounded sqtx8381 squareroot 8.1225E-20 -> 2.8E-10 Underflow Subnormal Inexact Rounded sqtx8382 squareroot 8.7025E-20 -> 3.0E-10 Underflow Subnormal Inexact Rounded sqtx8383 squareroot 9.3025E-20 -> 3.0E-10 Underflow Subnormal Inexact Rounded sqtx8384 squareroot 9.9225E-20 -> 3.2E-10 Underflow Subnormal Inexact Rounded --precision 4, input precision <= 4 precision: 4 sqtx8385 squareroot 2.5E-25 -> 0E-12 Underflow Subnormal Inexact Rounded Clamped sqtx8386 squareroot 2.25E-24 -> 2E-12 Underflow Subnormal Inexact Rounded sqtx8387 squareroot 6.25E-24 -> 2E-12 Underflow Subnormal Inexact Rounded sqtx8388 squareroot 1.225E-23 -> 4E-12 Underflow Subnormal Inexact Rounded sqtx8389 squareroot 2.025E-23 -> 4E-12 Underflow Subnormal Inexact Rounded sqtx8390 squareroot 3.025E-23 -> 6E-12 Underflow Subnormal Inexact Rounded sqtx8391 squareroot 4.225E-23 -> 6E-12 Underflow Subnormal Inexact Rounded sqtx8392 squareroot 5.625E-23 -> 8E-12 Underflow Subnormal Inexact Rounded sqtx8393 squareroot 7.225E-23 -> 8E-12 Underflow Subnormal Inexact Rounded sqtx8394 squareroot 9.025E-23 -> 1.0E-11 Underflow Subnormal Inexact Rounded --precision 5, input precision <= 5 precision: 5 sqtx8395 squareroot 2.5E-27 -> 0E-13 Underflow Subnormal Inexact Rounded Clamped sqtx8396 squareroot 2.25E-26 -> 2E-13 Underflow Subnormal Inexact Rounded sqtx8397 squareroot 6.25E-26 -> 2E-13 Underflow Subnormal Inexact Rounded sqtx8398 squareroot 1.225E-25 -> 4E-13 Underflow Subnormal Inexact Rounded sqtx8399 squareroot 2.025E-25 -> 4E-13 Underflow Subnormal Inexact Rounded sqtx8400 squareroot 3.025E-25 -> 6E-13 Underflow Subnormal Inexact Rounded sqtx8401 squareroot 4.225E-25 -> 6E-13 Underflow Subnormal Inexact Rounded sqtx8402 squareroot 5.625E-25 -> 8E-13 Underflow Subnormal Inexact Rounded sqtx8403 squareroot 7.225E-25 -> 8E-13 Underflow Subnormal Inexact Rounded sqtx8404 squareroot 9.025E-25 -> 1.0E-12 Underflow Subnormal Inexact Rounded sqtx8405 squareroot 1.1025E-24 -> 1.0E-12 Underflow Subnormal Inexact Rounded sqtx8406 squareroot 1.3225E-24 -> 1.2E-12 Underflow Subnormal Inexact Rounded sqtx8407 squareroot 1.5625E-24 -> 1.2E-12 Underflow Subnormal Inexact Rounded sqtx8408 squareroot 1.8225E-24 -> 1.4E-12 Underflow Subnormal Inexact Rounded sqtx8409 squareroot 2.1025E-24 -> 1.4E-12 Underflow Subnormal Inexact Rounded sqtx8410 squareroot 2.4025E-24 -> 1.6E-12 Underflow Subnormal Inexact Rounded sqtx8411 squareroot 2.7225E-24 -> 1.6E-12 Underflow Subnormal Inexact Rounded sqtx8412 squareroot 3.0625E-24 -> 1.8E-12 Underflow Subnormal Inexact Rounded sqtx8413 squareroot 3.4225E-24 -> 1.8E-12 Underflow Subnormal Inexact Rounded sqtx8414 squareroot 3.8025E-24 -> 2.0E-12 Underflow Subnormal Inexact Rounded sqtx8415 squareroot 4.2025E-24 -> 2.0E-12 Underflow Subnormal Inexact Rounded sqtx8416 squareroot 4.6225E-24 -> 2.2E-12 Underflow Subnormal Inexact Rounded sqtx8417 squareroot 5.0625E-24 -> 2.2E-12 Underflow Subnormal Inexact Rounded sqtx8418 squareroot 5.5225E-24 -> 2.4E-12 Underflow Subnormal Inexact Rounded sqtx8419 squareroot 6.0025E-24 -> 2.4E-12 Underflow Subnormal Inexact Rounded sqtx8420 squareroot 6.5025E-24 -> 2.6E-12 Underflow Subnormal Inexact Rounded sqtx8421 squareroot 7.0225E-24 -> 2.6E-12 Underflow Subnormal Inexact Rounded sqtx8422 squareroot 7.5625E-24 -> 2.8E-12 Underflow Subnormal Inexact Rounded sqtx8423 squareroot 8.1225E-24 -> 2.8E-12 Underflow Subnormal Inexact Rounded sqtx8424 squareroot 8.7025E-24 -> 3.0E-12 Underflow Subnormal Inexact Rounded sqtx8425 squareroot 9.3025E-24 -> 3.0E-12 Underflow Subnormal Inexact Rounded sqtx8426 squareroot 9.9225E-24 -> 3.2E-12 Underflow Subnormal Inexact Rounded -- a random selection of values that Python2.5.1 rounds incorrectly precision: 1 sqtx8427 squareroot 227 -> 2E+1 Inexact Rounded sqtx8428 squareroot 625 -> 2E+1 Inexact Rounded sqtx8429 squareroot 1215 -> 3E+1 Inexact Rounded sqtx8430 squareroot 2008 -> 4E+1 Inexact Rounded sqtx8431 squareroot 2020 -> 4E+1 Inexact Rounded sqtx8432 squareroot 2026 -> 5E+1 Inexact Rounded sqtx8433 squareroot 2027 -> 5E+1 Inexact Rounded sqtx8434 squareroot 2065 -> 5E+1 Inexact Rounded sqtx8435 squareroot 2075 -> 5E+1 Inexact Rounded sqtx8436 squareroot 2088 -> 5E+1 Inexact Rounded sqtx8437 squareroot 3049 -> 6E+1 Inexact Rounded sqtx8438 squareroot 3057 -> 6E+1 Inexact Rounded sqtx8439 squareroot 3061 -> 6E+1 Inexact Rounded sqtx8440 squareroot 3092 -> 6E+1 Inexact Rounded sqtx8441 squareroot 4222 -> 6E+1 Inexact Rounded sqtx8442 squareroot 5676 -> 8E+1 Inexact Rounded sqtx8443 squareroot 5686 -> 8E+1 Inexact Rounded sqtx8444 squareroot 7215 -> 8E+1 Inexact Rounded sqtx8445 squareroot 9086 -> 1E+2 Inexact Rounded sqtx8446 squareroot 9095 -> 1E+2 Inexact Rounded precision: 2 sqtx8447 squareroot 1266 -> 36 Inexact Rounded sqtx8448 squareroot 2552 -> 51 Inexact Rounded sqtx8449 squareroot 5554 -> 75 Inexact Rounded sqtx8450 squareroot 7832 -> 88 Inexact Rounded sqtx8451 squareroot 13201 -> 1.1E+2 Inexact Rounded sqtx8452 squareroot 15695 -> 1.3E+2 Inexact Rounded sqtx8453 squareroot 18272 -> 1.4E+2 Inexact Rounded sqtx8454 squareroot 21026 -> 1.5E+2 Inexact Rounded sqtx8455 squareroot 24069 -> 1.6E+2 Inexact Rounded sqtx8456 squareroot 34277 -> 1.9E+2 Inexact Rounded sqtx8457 squareroot 46233 -> 2.2E+2 Inexact Rounded sqtx8458 squareroot 46251 -> 2.2E+2 Inexact Rounded sqtx8459 squareroot 46276 -> 2.2E+2 Inexact Rounded sqtx8460 squareroot 70214 -> 2.6E+2 Inexact Rounded sqtx8461 squareroot 81249 -> 2.9E+2 Inexact Rounded sqtx8462 squareroot 81266 -> 2.9E+2 Inexact Rounded sqtx8463 squareroot 93065 -> 3.1E+2 Inexact Rounded sqtx8464 squareroot 93083 -> 3.1E+2 Inexact Rounded sqtx8465 squareroot 99230 -> 3.2E+2 Inexact Rounded sqtx8466 squareroot 99271 -> 3.2E+2 Inexact Rounded precision: 3 sqtx8467 squareroot 11349 -> 107 Inexact Rounded sqtx8468 squareroot 26738 -> 164 Inexact Rounded sqtx8469 squareroot 31508 -> 178 Inexact Rounded sqtx8470 squareroot 44734 -> 212 Inexact Rounded sqtx8471 squareroot 44738 -> 212 Inexact Rounded sqtx8472 squareroot 51307 -> 227 Inexact Rounded sqtx8473 squareroot 62259 -> 250 Inexact Rounded sqtx8474 squareroot 75901 -> 276 Inexact Rounded sqtx8475 squareroot 76457 -> 277 Inexact Rounded sqtx8476 squareroot 180287 -> 425 Inexact Rounded sqtx8477 squareroot 202053 -> 450 Inexact Rounded sqtx8478 squareroot 235747 -> 486 Inexact Rounded sqtx8479 squareroot 256537 -> 506 Inexact Rounded sqtx8480 squareroot 299772 -> 548 Inexact Rounded sqtx8481 squareroot 415337 -> 644 Inexact Rounded sqtx8482 squareroot 617067 -> 786 Inexact Rounded sqtx8483 squareroot 628022 -> 792 Inexact Rounded sqtx8484 squareroot 645629 -> 804 Inexact Rounded sqtx8485 squareroot 785836 -> 886 Inexact Rounded sqtx8486 squareroot 993066 -> 997 Inexact Rounded precision: 6 sqtx8487 squareroot 14917781 -> 3862.35 Inexact Rounded sqtx8488 squareroot 17237238 -> 4151.78 Inexact Rounded sqtx8489 squareroot 18054463 -> 4249.05 Inexact Rounded sqtx8490 squareroot 19990694 -> 4471.10 Inexact Rounded sqtx8491 squareroot 29061855 -> 5390.90 Inexact Rounded sqtx8492 squareroot 49166257 -> 7011.87 Inexact Rounded sqtx8493 squareroot 53082086 -> 7285.75 Inexact Rounded sqtx8494 squareroot 56787909 -> 7535.78 Inexact Rounded sqtx8495 squareroot 81140019 -> 9007.78 Inexact Rounded sqtx8496 squareroot 87977554 -> 9379.64 Inexact Rounded sqtx8497 squareroot 93624683 -> 9675.98 Inexact Rounded sqtx8498 squareroot 98732747 -> 9936.44 Inexact Rounded sqtx8499 squareroot 99222813 -> 9961.06 Inexact Rounded sqtx8500 squareroot 143883626 -> 11995.2 Inexact Rounded sqtx8501 squareroot 180433301 -> 13432.5 Inexact Rounded sqtx8502 squareroot 227034020 -> 15067.6 Inexact Rounded sqtx8503 squareroot 283253992 -> 16830.2 Inexact Rounded sqtx8504 squareroot 617047954 -> 24840.4 Inexact Rounded sqtx8505 squareroot 736870094 -> 27145.4 Inexact Rounded sqtx8506 squareroot 897322915 -> 29955.3 Inexact Rounded -- results close to minimum normal precision: 1 sqtx8507 squareroot 1E-20 -> 0E-9 Underflow Subnormal Inexact Rounded Clamped sqtx8508 squareroot 1E-19 -> 0E-9 Underflow Subnormal Inexact Rounded Clamped sqtx8509 squareroot 1E-18 -> 1E-9 precision: 2 sqtx8510 squareroot 8.1E-19 -> 9E-10 Subnormal sqtx8511 squareroot 8.10E-19 -> 9E-10 Subnormal Rounded sqtx8512 squareroot 9.0E-19 -> 9E-10 Underflow Subnormal Inexact Rounded sqtx8513 squareroot 9.02E-19 -> 9E-10 Underflow Subnormal Inexact Rounded sqtx8514 squareroot 9.03E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8515 squareroot 9.1E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8516 squareroot 9.9E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8517 squareroot 9.91E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8518 squareroot 9.92E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8519 squareroot 9.95E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8520 squareroot 9.98E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8521 squareroot 9.99E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded sqtx8522 squareroot 1E-18 -> 1E-9 sqtx8523 squareroot 1.0E-18 -> 1.0E-9 sqtx8524 squareroot 1.00E-18 -> 1.0E-9 sqtx8525 squareroot 1.000E-18 -> 1.0E-9 Rounded sqtx8526 squareroot 1.0000E-18 -> 1.0E-9 Rounded sqtx8527 squareroot 1.01E-18 -> 1.0E-9 Inexact Rounded sqtx8528 squareroot 1.02E-18 -> 1.0E-9 Inexact Rounded sqtx8529 squareroot 1.1E-18 -> 1.0E-9 Inexact Rounded precision: 3 sqtx8530 squareroot 8.1E-19 -> 9E-10 Subnormal sqtx8531 squareroot 8.10E-19 -> 9.0E-10 Subnormal sqtx8532 squareroot 8.100E-19 -> 9.0E-10 Subnormal sqtx8533 squareroot 8.1000E-19 -> 9.0E-10 Subnormal Rounded sqtx8534 squareroot 9.9E-19 -> 9.9E-10 Underflow Subnormal Inexact Rounded sqtx8535 squareroot 9.91E-19 -> 1.00E-9 Underflow Subnormal Inexact Rounded sqtx8536 squareroot 9.99E-19 -> 1.00E-9 Underflow Subnormal Inexact Rounded sqtx8537 squareroot 9.998E-19 -> 1.00E-9 Underflow Subnormal Inexact Rounded sqtx8538 squareroot 1E-18 -> 1E-9 sqtx8539 squareroot 1.0E-18 -> 1.0E-9 sqtx8540 squareroot 1.00E-18 -> 1.0E-9 sqtx8541 squareroot 1.000E-18 -> 1.00E-9 sqtx8542 squareroot 1.0000E-18 -> 1.00E-9 sqtx8543 squareroot 1.00000E-18 -> 1.00E-9 Rounded sqtx8544 squareroot 1.000000E-18 -> 1.00E-9 Rounded sqtx8545 squareroot 1.01E-18 -> 1.00E-9 Inexact Rounded sqtx8546 squareroot 1.02E-18 -> 1.01E-9 Inexact Rounded -- result exactly representable with precision p, but not necessarily -- exactly representable as a subnormal; check the correct flags are raised precision: 2 sqtx8547 squareroot 1.21E-20 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8548 squareroot 1.44E-20 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8549 squareroot 9.61E-20 -> 3E-10 Underflow Subnormal Inexact Rounded sqtx8550 squareroot 8.836E-19 -> 9E-10 Underflow Subnormal Inexact Rounded sqtx8551 squareroot 9.216E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded precision: 3 sqtx8552 squareroot 1.21E-22 -> 1E-11 Underflow Subnormal Inexact Rounded sqtx8553 squareroot 1.21E-20 -> 1.1E-10 Subnormal sqtx8554 squareroot 1.96E-22 -> 1E-11 Underflow Subnormal Inexact Rounded sqtx8555 squareroot 1.96E-20 -> 1.4E-10 Subnormal sqtx8556 squareroot 2.56E-22 -> 2E-11 Underflow Subnormal Inexact Rounded sqtx8557 squareroot 4.00E-22 -> 2E-11 Subnormal Rounded sqtx8558 squareroot 7.84E-22 -> 3E-11 Underflow Subnormal Inexact Rounded sqtx8559 squareroot 9.801E-21 -> 1.0E-10 Underflow Subnormal Inexact Rounded sqtx8560 squareroot 9.801E-19 -> 9.9E-10 Subnormal sqtx8561 squareroot 1.0201E-20 -> 1.0E-10 Underflow Subnormal Inexact Rounded sqtx8562 squareroot 1.1025E-20 -> 1.0E-10 Underflow Subnormal Inexact Rounded sqtx8563 squareroot 1.1236E-20 -> 1.1E-10 Underflow Subnormal Inexact Rounded sqtx8564 squareroot 1.2996E-20 -> 1.1E-10 Underflow Subnormal Inexact Rounded sqtx8565 squareroot 1.3225E-20 -> 1.2E-10 Underflow Subnormal Inexact Rounded -- A selection of subnormal results prone to double rounding errors precision: 2 sqtx8566 squareroot 2.3E-21 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped sqtx8567 squareroot 2.4E-21 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped sqtx8568 squareroot 2.5E-21 -> 0E-10 Underflow Subnormal Inexact Rounded Clamped sqtx8569 squareroot 2.6E-21 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8570 squareroot 2.7E-21 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8571 squareroot 2.8E-21 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8572 squareroot 2.2E-20 -> 1E-10 Underflow Subnormal Inexact Rounded sqtx8573 squareroot 2.3E-20 -> 2E-10 Underflow Subnormal Inexact Rounded sqtx8574 squareroot 2.4E-20 -> 2E-10 Underflow Subnormal Inexact Rounded sqtx8575 squareroot 6.2E-20 -> 2E-10 Underflow Subnormal Inexact Rounded sqtx8576 squareroot 6.3E-20 -> 3E-10 Underflow Subnormal Inexact Rounded sqtx8577 squareroot 6.4E-20 -> 3E-10 Underflow Subnormal Inexact Rounded sqtx8578 squareroot 6.5E-20 -> 3E-10 Underflow Subnormal Inexact Rounded sqtx8579 squareroot 1.2E-19 -> 3E-10 Underflow Subnormal Inexact Rounded sqtx8580 squareroot 2.0E-19 -> 4E-10 Underflow Subnormal Inexact Rounded sqtx8581 squareroot 4.2E-19 -> 6E-10 Underflow Subnormal Inexact Rounded sqtx8582 squareroot 5.6E-19 -> 7E-10 Underflow Subnormal Inexact Rounded sqtx8583 squareroot 5.7E-19 -> 8E-10 Underflow Subnormal Inexact Rounded sqtx8584 squareroot 9.0E-19 -> 9E-10 Underflow Subnormal Inexact Rounded sqtx8585 squareroot 9.1E-19 -> 1.0E-9 Underflow Subnormal Inexact Rounded precision: 3 sqtx8586 squareroot 2.6E-23 -> 1E-11 Underflow Subnormal Inexact Rounded sqtx8587 squareroot 2.22E-22 -> 1E-11 Underflow Subnormal Inexact Rounded sqtx8588 squareroot 6.07E-22 -> 2E-11 Underflow Subnormal Inexact Rounded sqtx8589 squareroot 6.25E-22 -> 2E-11 Underflow Subnormal Inexact Rounded sqtx8590 squareroot 6.45E-22 -> 3E-11 Underflow Subnormal Inexact Rounded sqtx8591 squareroot 6.50E-22 -> 3E-11 Underflow Subnormal Inexact Rounded sqtx8592 squareroot 1.22E-21 -> 3E-11 Underflow Subnormal Inexact Rounded sqtx8593 squareroot 1.24E-21 -> 4E-11 Underflow Subnormal Inexact Rounded sqtx8594 squareroot 4.18E-21 -> 6E-11 Underflow Subnormal Inexact Rounded sqtx8595 squareroot 7.19E-21 -> 8E-11 Underflow Subnormal Inexact Rounded sqtx8596 squareroot 8.94E-21 -> 9E-11 Underflow Subnormal Inexact Rounded sqtx8597 squareroot 1.81E-20 -> 1.3E-10 Underflow Subnormal Inexact Rounded sqtx8598 squareroot 4.64E-20 -> 2.2E-10 Underflow Subnormal Inexact Rounded sqtx8599 squareroot 5.06E-20 -> 2.2E-10 Underflow Subnormal Inexact Rounded sqtx8600 squareroot 5.08E-20 -> 2.3E-10 Underflow Subnormal Inexact Rounded sqtx8601 squareroot 7.00E-20 -> 2.6E-10 Underflow Subnormal Inexact Rounded sqtx8602 squareroot 1.81E-19 -> 4.3E-10 Underflow Subnormal Inexact Rounded sqtx8603 squareroot 6.64E-19 -> 8.1E-10 Underflow Subnormal Inexact Rounded sqtx8604 squareroot 7.48E-19 -> 8.6E-10 Underflow Subnormal Inexact Rounded sqtx8605 squareroot 9.91E-19 -> 1.00E-9 Underflow Subnormal Inexact Rounded precision: 4 sqtx8606 squareroot 6.24E-24 -> 2E-12 Underflow Subnormal Inexact Rounded sqtx8607 squareroot 7.162E-23 -> 8E-12 Underflow Subnormal Inexact Rounded sqtx8608 squareroot 7.243E-23 -> 9E-12 Underflow Subnormal Inexact Rounded sqtx8609 squareroot 8.961E-23 -> 9E-12 Underflow Subnormal Inexact Rounded sqtx8610 squareroot 9.029E-23 -> 1.0E-11 Underflow Subnormal Inexact Rounded sqtx8611 squareroot 4.624E-22 -> 2.2E-11 Underflow Subnormal Inexact Rounded sqtx8612 squareroot 5.980E-22 -> 2.4E-11 Underflow Subnormal Inexact Rounded sqtx8613 squareroot 6.507E-22 -> 2.6E-11 Underflow Subnormal Inexact Rounded sqtx8614 squareroot 1.483E-21 -> 3.9E-11 Underflow Subnormal Inexact Rounded sqtx8615 squareroot 3.903E-21 -> 6.2E-11 Underflow Subnormal Inexact Rounded sqtx8616 squareroot 8.733E-21 -> 9.3E-11 Underflow Subnormal Inexact Rounded sqtx8617 squareroot 1.781E-20 -> 1.33E-10 Underflow Subnormal Inexact Rounded sqtx8618 squareroot 6.426E-20 -> 2.53E-10 Underflow Subnormal Inexact Rounded sqtx8619 squareroot 7.102E-20 -> 2.66E-10 Underflow Subnormal Inexact Rounded sqtx8620 squareroot 7.535E-20 -> 2.74E-10 Underflow Subnormal Inexact Rounded sqtx8621 squareroot 9.892E-20 -> 3.15E-10 Underflow Subnormal Inexact Rounded sqtx8622 squareroot 1.612E-19 -> 4.01E-10 Underflow Subnormal Inexact Rounded sqtx8623 squareroot 1.726E-19 -> 4.15E-10 Underflow Subnormal Inexact Rounded sqtx8624 squareroot 1.853E-19 -> 4.30E-10 Underflow Subnormal Inexact Rounded sqtx8625 squareroot 4.245E-19 -> 6.52E-10 Underflow Subnormal Inexact Rounded -- clamping and overflow for large exponents precision: 1 sqtx8626 squareroot 1E+18 -> 1E+9 sqtx8627 squareroot 1E+19 -> 3E+9 Inexact Rounded -- in this next one, intermediate result is 9486832980.505137996... -- so rounds down to 9 (not up to 10 which would cause Infinity overflow) sqtx8628 squareroot 9E+19 -> 9E+9 Inexact Rounded sqtx8629 squareroot 9.1E+19 -> Infinity Overflow Inexact Rounded sqtx8630 squareroot 1E+20 -> Infinity Overflow Inexact Rounded precision: 2 sqtx8631 squareroot 1E+18 -> 1E+9 sqtx8632 squareroot 1.0E+18 -> 1.0E+9 sqtx8633 squareroot 1.00E+18 -> 1.0E+9 sqtx8634 squareroot 1.000E+18 -> 1.0E+9 Rounded sqtx8635 squareroot 1E+20 -> Infinity Overflow Inexact Rounded clamp: 1 sqtx8636 squareroot 1E+18 -> 1.0E+9 Clamped sqtx8637 squareroot 1.0E+18 -> 1.0E+9 sqtx8638 squareroot 1E+20 -> Infinity Overflow Inexact Rounded clamp: 0 precision: 6 sqtx8639 squareroot 1E+18 -> 1E+9 sqtx8640 squareroot 1.0000000000E+18 -> 1.00000E+9 sqtx8641 squareroot 1.00000000000E+18 -> 1.00000E+9 Rounded sqtx8642 squareroot 1E+20 -> Infinity Overflow Inexact Rounded clamp: 1 sqtx8643 squareroot 1E+8 -> 1E+4 sqtx8644 squareroot 1E+10 -> 1.0E+5 Clamped sqtx8645 squareroot 1.0E+10 -> 1.0E+5 sqtx8646 squareroot 1E+12 -> 1.00E+6 Clamped sqtx8647 squareroot 1.0E+12 -> 1.00E+6 Clamped sqtx8648 squareroot 1.00E+12 -> 1.00E+6 Clamped sqtx8649 squareroot 1.000E+12 -> 1.00E+6 sqtx8650 squareroot 1E+18 -> 1.00000E+9 Clamped sqtx8651 squareroot 1.00000000E+18 -> 1.00000E+9 Clamped sqtx8652 squareroot 1.000000000E+18 -> 1.00000E+9 sqtx8653 squareroot 1E+20 -> Infinity Overflow Inexact Rounded clamp: 0 -- The following example causes a TypeError in Python 2.5.1 precision: 3 maxexponent: 9 minexponent: -9 sqtx8654 squareroot 10000000000 -> 1.00E+5 Rounded -- Additional tricky cases of underflown subnormals rounding: half_even precision: 5 maxexponent: 999 minexponent: -999 sqtx8700 squareroot 2.8073E-2000 -> 1.675E-1000 Underflow Subnormal Inexact Rounded sqtx8701 squareroot 2.8883E-2000 -> 1.699E-1000 Underflow Subnormal Inexact Rounded sqtx8702 squareroot 3.1524E-2000 -> 1.775E-1000 Underflow Subnormal Inexact Rounded sqtx8703 squareroot 3.2382E-2000 -> 1.799E-1000 Underflow Subnormal Inexact Rounded sqtx8704 squareroot 3.5175E-2000 -> 1.875E-1000 Underflow Subnormal Inexact Rounded sqtx8705 squareroot 3.6081E-2000 -> 1.899E-1000 Underflow Subnormal Inexact Rounded sqtx8706 squareroot 3.9026E-2000 -> 1.975E-1000 Underflow Subnormal Inexact Rounded sqtx8707 squareroot 3.9980E-2000 -> 1.999E-1000 Underflow Subnormal Inexact Rounded sqtx8708 squareroot 4.3077E-2000 -> 2.075E-1000 Underflow Subnormal Inexact Rounded sqtx8709 squareroot 4.4079E-2000 -> 2.099E-1000 Underflow Subnormal Inexact Rounded sqtx8710 squareroot 4.7328E-2000 -> 2.175E-1000 Underflow Subnormal Inexact Rounded sqtx8711 squareroot 4.8378E-2000 -> 2.199E-1000 Underflow Subnormal Inexact Rounded sqtx8712 squareroot 5.1779E-2000 -> 2.275E-1000 Underflow Subnormal Inexact Rounded sqtx8713 squareroot 5.2877E-2000 -> 2.299E-1000 Underflow Subnormal Inexact Rounded sqtx8714 squareroot 5.6430E-2000 -> 2.375E-1000 Underflow Subnormal Inexact Rounded sqtx8715 squareroot 5.7576E-2000 -> 2.399E-1000 Underflow Subnormal Inexact Rounded sqtx8716 squareroot 6.1281E-2000 -> 2.475E-1000 Underflow Subnormal Inexact Rounded sqtx8717 squareroot 6.2475E-2000 -> 2.499E-1000 Underflow Subnormal Inexact Rounded sqtx8718 squareroot 6.6332E-2000 -> 2.575E-1000 Underflow Subnormal Inexact Rounded sqtx8719 squareroot 6.7574E-2000 -> 2.599E-1000 Underflow Subnormal Inexact Rounded sqtx8720 squareroot 7.1583E-2000 -> 2.675E-1000 Underflow Subnormal Inexact Rounded sqtx8721 squareroot 7.2873E-2000 -> 2.699E-1000 Underflow Subnormal Inexact Rounded sqtx8722 squareroot 7.7034E-2000 -> 2.775E-1000 Underflow Subnormal Inexact Rounded sqtx8723 squareroot 7.8372E-2000 -> 2.799E-1000 Underflow Subnormal Inexact Rounded sqtx8724 squareroot 8.2685E-2000 -> 2.875E-1000 Underflow Subnormal Inexact Rounded sqtx8725 squareroot 8.4071E-2000 -> 2.899E-1000 Underflow Subnormal Inexact Rounded sqtx8726 squareroot 8.8536E-2000 -> 2.975E-1000 Underflow Subnormal Inexact Rounded sqtx8727 squareroot 8.9970E-2000 -> 2.999E-1000 Underflow Subnormal Inexact Rounded sqtx8728 squareroot 9.4587E-2000 -> 3.075E-1000 Underflow Subnormal Inexact Rounded sqtx8729 squareroot 9.6069E-2000 -> 3.099E-1000 Underflow Subnormal Inexact Rounded -- (End of Mark Dickinson's testcases.) -- Some additional edge cases maxexponent: 9 minexponent: -9 precision: 2 sqtx9000 squareroot 9980.01 -> 1.0E+2 Inexact Rounded precision: 3 sqtx9001 squareroot 9980.01 -> 99.9 precision: 4 sqtx9002 squareroot 9980.01 -> 99.9 -- Exact from over-precise precision: 4 sqtx9003 squareroot 11025 -> 105 precision: 3 sqtx9004 squareroot 11025 -> 105 precision: 2 sqtx9005 squareroot 11025 -> 1.0E+2 Inexact Rounded precision: 1 sqtx9006 squareroot 11025 -> 1E+2 Inexact Rounded -- an interesting case precision: 7 sqtx9007 squareroot 1600000e1 -> 4000 -- Out-of-bounds zeros precision: 4 sqtx9010 squareroot 0E-9 -> 0.00000 sqtx9011 squareroot 0E-10 -> 0.00000 sqtx9012 squareroot 0E-11 -> 0.000000 sqtx9013 squareroot 0E-12 -> 0.000000 sqtx9014 squareroot 0E-13 -> 0E-7 sqtx9015 squareroot 0E-14 -> 0E-7 sqtx9020 squareroot 0E-17 -> 0E-9 sqtx9021 squareroot 0E-20 -> 0E-10 sqtx9022 squareroot 0E-22 -> 0E-11 sqtx9023 squareroot 0E-24 -> 0E-12 sqtx9024 squareroot 0E-25 -> 0E-12 Clamped sqtx9025 squareroot 0E-26 -> 0E-12 Clamped sqtx9026 squareroot 0E-27 -> 0E-12 Clamped sqtx9027 squareroot 0E-28 -> 0E-12 Clamped sqtx9030 squareroot 0E+8 -> 0E+4 sqtx9031 squareroot 0E+10 -> 0E+5 sqtx9032 squareroot 0E+12 -> 0E+6 sqtx9033 squareroot 0E+14 -> 0E+7 sqtx9034 squareroot 0E+15 -> 0E+7 sqtx9035 squareroot 0E+16 -> 0E+8 sqtx9036 squareroot 0E+18 -> 0E+9 sqtx9037 squareroot 0E+19 -> 0E+9 sqtx9038 squareroot 0E+20 -> 0E+9 Clamped sqtx9039 squareroot 0E+21 -> 0E+9 Clamped sqtx9040 squareroot 0E+22 -> 0E+9 Clamped -- if digits > emax maximum real exponent is negative maxexponent: 9 minexponent: -9 precision: 15 clamp: 1 sqtx9045 squareroot 1 -> 1.00000 Clamped -- other maxexponent: 999 minexponent: -999 precision: 16 sqtx9046 squareroot 10 -> 3.162277660168379 inexact rounded sqtx9047 squareroot 10E-1 -> 1.0 sqtx9048 squareroot 10E-2 -> 0.3162277660168379 inexact rounded sqtx9049 squareroot 10E-3 -> 0.10 -- High-precision exact and inexact maxexponent: 999 minexponent: -999 precision: 400 sqtx9050 squareroot 2 -> 1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572735013846230912297024924836055850737212644121497099935831413222665927505592755799950501152782060571470109559971605970274534596862014728517418640889198609552329230484308714321450839762603627995251407989687253396546331808829640620615258352395054745750287759961729835575220337531857011354374603408498847 Inexact Rounded sqtx9051 squareroot 1089 -> 33 sqtx9052 squareroot 10.89 -> 3.3 -- Null test sqtx9900 squareroot # -> NaN Invalid_operation apd-3.2.1/testdata/subtract.decTest000066400000000000000000001300601450022325000172270ustar00rootroot00000000000000------------------------------------------------------------------------ -- subtract.decTest -- decimal subtraction -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 extended: 1 precision: 9 rounding: half_up maxExponent: 384 minexponent: -383 -- [first group are 'quick confidence check'] subx001 subtract 0 0 -> '0' subx002 subtract 1 1 -> '0' subx003 subtract 1 2 -> '-1' subx004 subtract 2 1 -> '1' subx005 subtract 2 2 -> '0' subx006 subtract 3 2 -> '1' subx007 subtract 2 3 -> '-1' subx011 subtract -0 0 -> '-0' subx012 subtract -1 1 -> '-2' subx013 subtract -1 2 -> '-3' subx014 subtract -2 1 -> '-3' subx015 subtract -2 2 -> '-4' subx016 subtract -3 2 -> '-5' subx017 subtract -2 3 -> '-5' subx021 subtract 0 -0 -> '0' subx022 subtract 1 -1 -> '2' subx023 subtract 1 -2 -> '3' subx024 subtract 2 -1 -> '3' subx025 subtract 2 -2 -> '4' subx026 subtract 3 -2 -> '5' subx027 subtract 2 -3 -> '5' subx030 subtract 11 1 -> 10 subx031 subtract 10 1 -> 9 subx032 subtract 9 1 -> 8 subx033 subtract 1 1 -> 0 subx034 subtract 0 1 -> -1 subx035 subtract -1 1 -> -2 subx036 subtract -9 1 -> -10 subx037 subtract -10 1 -> -11 subx038 subtract -11 1 -> -12 subx040 subtract '5.75' '3.3' -> '2.45' subx041 subtract '5' '-3' -> '8' subx042 subtract '-5' '-3' -> '-2' subx043 subtract '-7' '2.5' -> '-9.5' subx044 subtract '0.7' '0.3' -> '0.4' subx045 subtract '1.3' '0.3' -> '1.0' subx046 subtract '1.25' '1.25' -> '0.00' subx050 subtract '1.23456789' '1.00000000' -> '0.23456789' subx051 subtract '1.23456789' '1.00000089' -> '0.23456700' subx052 subtract '0.5555555559' '0.0000000001' -> '0.555555556' Inexact Rounded subx053 subtract '0.5555555559' '0.0000000005' -> '0.555555555' Inexact Rounded subx054 subtract '0.4444444444' '0.1111111111' -> '0.333333333' Inexact Rounded subx055 subtract '1.0000000000' '0.00000001' -> '0.999999990' Rounded subx056 subtract '0.4444444444999' '0' -> '0.444444444' Inexact Rounded subx057 subtract '0.4444444445000' '0' -> '0.444444445' Inexact Rounded subx060 subtract '70' '10000e+9' -> '-1.00000000E+13' Inexact Rounded subx061 subtract '700' '10000e+9' -> '-1.00000000E+13' Inexact Rounded subx062 subtract '7000' '10000e+9' -> '-9.99999999E+12' Inexact Rounded subx063 subtract '70000' '10000e+9' -> '-9.99999993E+12' Rounded subx064 subtract '700000' '10000e+9' -> '-9.99999930E+12' Rounded -- symmetry: subx065 subtract '10000e+9' '70' -> '1.00000000E+13' Inexact Rounded subx066 subtract '10000e+9' '700' -> '1.00000000E+13' Inexact Rounded subx067 subtract '10000e+9' '7000' -> '9.99999999E+12' Inexact Rounded subx068 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded subx069 subtract '10000e+9' '700000' -> '9.99999930E+12' Rounded -- change precision subx080 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded precision: 6 subx081 subtract '10000e+9' '70000' -> '1.00000E+13' Inexact Rounded precision: 9 -- some of the next group are really constructor tests subx090 subtract '00.0' '0.0' -> '0.0' subx091 subtract '00.0' '0.00' -> '0.00' subx092 subtract '0.00' '00.0' -> '0.00' subx093 subtract '00.0' '0.00' -> '0.00' subx094 subtract '0.00' '00.0' -> '0.00' subx095 subtract '3' '.3' -> '2.7' subx096 subtract '3.' '.3' -> '2.7' subx097 subtract '3.0' '.3' -> '2.7' subx098 subtract '3.00' '.3' -> '2.70' subx099 subtract '3' '3' -> '0' subx100 subtract '3' '+3' -> '0' subx101 subtract '3' '-3' -> '6' subx102 subtract '3' '0.3' -> '2.7' subx103 subtract '3.' '0.3' -> '2.7' subx104 subtract '3.0' '0.3' -> '2.7' subx105 subtract '3.00' '0.3' -> '2.70' subx106 subtract '3' '3.0' -> '0.0' subx107 subtract '3' '+3.0' -> '0.0' subx108 subtract '3' '-3.0' -> '6.0' -- the above all from add; massaged and extended. Now some new ones... -- [particularly important for comparisons] -- NB: -xE-8 below were non-exponents pre-ANSI X3-274, and -1E-7 or 0E-7 -- with input rounding. subx120 subtract '10.23456784' '10.23456789' -> '-5E-8' subx121 subtract '10.23456785' '10.23456789' -> '-4E-8' subx122 subtract '10.23456786' '10.23456789' -> '-3E-8' subx123 subtract '10.23456787' '10.23456789' -> '-2E-8' subx124 subtract '10.23456788' '10.23456789' -> '-1E-8' subx125 subtract '10.23456789' '10.23456789' -> '0E-8' subx126 subtract '10.23456790' '10.23456789' -> '1E-8' subx127 subtract '10.23456791' '10.23456789' -> '2E-8' subx128 subtract '10.23456792' '10.23456789' -> '3E-8' subx129 subtract '10.23456793' '10.23456789' -> '4E-8' subx130 subtract '10.23456794' '10.23456789' -> '5E-8' subx131 subtract '10.23456781' '10.23456786' -> '-5E-8' subx132 subtract '10.23456782' '10.23456786' -> '-4E-8' subx133 subtract '10.23456783' '10.23456786' -> '-3E-8' subx134 subtract '10.23456784' '10.23456786' -> '-2E-8' subx135 subtract '10.23456785' '10.23456786' -> '-1E-8' subx136 subtract '10.23456786' '10.23456786' -> '0E-8' subx137 subtract '10.23456787' '10.23456786' -> '1E-8' subx138 subtract '10.23456788' '10.23456786' -> '2E-8' subx139 subtract '10.23456789' '10.23456786' -> '3E-8' subx140 subtract '10.23456790' '10.23456786' -> '4E-8' subx141 subtract '10.23456791' '10.23456786' -> '5E-8' subx142 subtract '1' '0.999999999' -> '1E-9' subx143 subtract '0.999999999' '1' -> '-1E-9' subx144 subtract '-10.23456780' '-10.23456786' -> '6E-8' subx145 subtract '-10.23456790' '-10.23456786' -> '-4E-8' subx146 subtract '-10.23456791' '-10.23456786' -> '-5E-8' precision: 3 subx150 subtract '12345678900000' '9999999999999' -> 2.35E+12 Inexact Rounded subx151 subtract '9999999999999' '12345678900000' -> -2.35E+12 Inexact Rounded precision: 6 subx152 subtract '12345678900000' '9999999999999' -> 2.34568E+12 Inexact Rounded subx153 subtract '9999999999999' '12345678900000' -> -2.34568E+12 Inexact Rounded precision: 9 subx154 subtract '12345678900000' '9999999999999' -> 2.34567890E+12 Inexact Rounded subx155 subtract '9999999999999' '12345678900000' -> -2.34567890E+12 Inexact Rounded precision: 12 subx156 subtract '12345678900000' '9999999999999' -> 2.34567890000E+12 Inexact Rounded subx157 subtract '9999999999999' '12345678900000' -> -2.34567890000E+12 Inexact Rounded precision: 15 subx158 subtract '12345678900000' '9999999999999' -> 2345678900001 subx159 subtract '9999999999999' '12345678900000' -> -2345678900001 precision: 9 -- additional scaled arithmetic tests [0.97 problem] subx160 subtract '0' '.1' -> '-0.1' subx161 subtract '00' '.97983' -> '-0.97983' subx162 subtract '0' '.9' -> '-0.9' subx163 subtract '0' '0.102' -> '-0.102' subx164 subtract '0' '.4' -> '-0.4' subx165 subtract '0' '.307' -> '-0.307' subx166 subtract '0' '.43822' -> '-0.43822' subx167 subtract '0' '.911' -> '-0.911' subx168 subtract '.0' '.02' -> '-0.02' subx169 subtract '00' '.392' -> '-0.392' subx170 subtract '0' '.26' -> '-0.26' subx171 subtract '0' '0.51' -> '-0.51' subx172 subtract '0' '.2234' -> '-0.2234' subx173 subtract '0' '.2' -> '-0.2' subx174 subtract '.0' '.0008' -> '-0.0008' -- 0. on left subx180 subtract '0.0' '-.1' -> '0.1' subx181 subtract '0.00' '-.97983' -> '0.97983' subx182 subtract '0.0' '-.9' -> '0.9' subx183 subtract '0.0' '-0.102' -> '0.102' subx184 subtract '0.0' '-.4' -> '0.4' subx185 subtract '0.0' '-.307' -> '0.307' subx186 subtract '0.0' '-.43822' -> '0.43822' subx187 subtract '0.0' '-.911' -> '0.911' subx188 subtract '0.0' '-.02' -> '0.02' subx189 subtract '0.00' '-.392' -> '0.392' subx190 subtract '0.0' '-.26' -> '0.26' subx191 subtract '0.0' '-0.51' -> '0.51' subx192 subtract '0.0' '-.2234' -> '0.2234' subx193 subtract '0.0' '-.2' -> '0.2' subx194 subtract '0.0' '-.0008' -> '0.0008' -- negatives of same subx200 subtract '0' '-.1' -> '0.1' subx201 subtract '00' '-.97983' -> '0.97983' subx202 subtract '0' '-.9' -> '0.9' subx203 subtract '0' '-0.102' -> '0.102' subx204 subtract '0' '-.4' -> '0.4' subx205 subtract '0' '-.307' -> '0.307' subx206 subtract '0' '-.43822' -> '0.43822' subx207 subtract '0' '-.911' -> '0.911' subx208 subtract '.0' '-.02' -> '0.02' subx209 subtract '00' '-.392' -> '0.392' subx210 subtract '0' '-.26' -> '0.26' subx211 subtract '0' '-0.51' -> '0.51' subx212 subtract '0' '-.2234' -> '0.2234' subx213 subtract '0' '-.2' -> '0.2' subx214 subtract '.0' '-.0008' -> '0.0008' -- more fixed, LHS swaps [really the same as testcases under add] subx220 subtract '-56267E-12' 0 -> '-5.6267E-8' subx221 subtract '-56267E-11' 0 -> '-5.6267E-7' subx222 subtract '-56267E-10' 0 -> '-0.0000056267' subx223 subtract '-56267E-9' 0 -> '-0.000056267' subx224 subtract '-56267E-8' 0 -> '-0.00056267' subx225 subtract '-56267E-7' 0 -> '-0.0056267' subx226 subtract '-56267E-6' 0 -> '-0.056267' subx227 subtract '-56267E-5' 0 -> '-0.56267' subx228 subtract '-56267E-2' 0 -> '-562.67' subx229 subtract '-56267E-1' 0 -> '-5626.7' subx230 subtract '-56267E-0' 0 -> '-56267' -- symmetry ... subx240 subtract 0 '-56267E-12' -> '5.6267E-8' subx241 subtract 0 '-56267E-11' -> '5.6267E-7' subx242 subtract 0 '-56267E-10' -> '0.0000056267' subx243 subtract 0 '-56267E-9' -> '0.000056267' subx244 subtract 0 '-56267E-8' -> '0.00056267' subx245 subtract 0 '-56267E-7' -> '0.0056267' subx246 subtract 0 '-56267E-6' -> '0.056267' subx247 subtract 0 '-56267E-5' -> '0.56267' subx248 subtract 0 '-56267E-2' -> '562.67' subx249 subtract 0 '-56267E-1' -> '5626.7' subx250 subtract 0 '-56267E-0' -> '56267' -- now some more from the 'new' add precision: 9 subx301 subtract '1.23456789' '1.00000000' -> '0.23456789' subx302 subtract '1.23456789' '1.00000011' -> '0.23456778' subx311 subtract '0.4444444444' '0.5555555555' -> '-0.111111111' Inexact Rounded subx312 subtract '0.4444444440' '0.5555555555' -> '-0.111111112' Inexact Rounded subx313 subtract '0.4444444444' '0.5555555550' -> '-0.111111111' Inexact Rounded subx314 subtract '0.44444444449' '0' -> '0.444444444' Inexact Rounded subx315 subtract '0.444444444499' '0' -> '0.444444444' Inexact Rounded subx316 subtract '0.4444444444999' '0' -> '0.444444444' Inexact Rounded subx317 subtract '0.4444444445000' '0' -> '0.444444445' Inexact Rounded subx318 subtract '0.4444444445001' '0' -> '0.444444445' Inexact Rounded subx319 subtract '0.444444444501' '0' -> '0.444444445' Inexact Rounded subx320 subtract '0.44444444451' '0' -> '0.444444445' Inexact Rounded -- some carrying effects subx321 subtract '0.9998' '0.0000' -> '0.9998' subx322 subtract '0.9998' '0.0001' -> '0.9997' subx323 subtract '0.9998' '0.0002' -> '0.9996' subx324 subtract '0.9998' '0.0003' -> '0.9995' subx325 subtract '0.9998' '-0.0000' -> '0.9998' subx326 subtract '0.9998' '-0.0001' -> '0.9999' subx327 subtract '0.9998' '-0.0002' -> '1.0000' subx328 subtract '0.9998' '-0.0003' -> '1.0001' subx330 subtract '70' '10000e+9' -> '-1.00000000E+13' Inexact Rounded subx331 subtract '700' '10000e+9' -> '-1.00000000E+13' Inexact Rounded subx332 subtract '7000' '10000e+9' -> '-9.99999999E+12' Inexact Rounded subx333 subtract '70000' '10000e+9' -> '-9.99999993E+12' Rounded subx334 subtract '700000' '10000e+9' -> '-9.99999930E+12' Rounded subx335 subtract '7000000' '10000e+9' -> '-9.99999300E+12' Rounded -- symmetry: subx340 subtract '10000e+9' '70' -> '1.00000000E+13' Inexact Rounded subx341 subtract '10000e+9' '700' -> '1.00000000E+13' Inexact Rounded subx342 subtract '10000e+9' '7000' -> '9.99999999E+12' Inexact Rounded subx343 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded subx344 subtract '10000e+9' '700000' -> '9.99999930E+12' Rounded subx345 subtract '10000e+9' '7000000' -> '9.99999300E+12' Rounded -- same, higher precision precision: 15 subx346 subtract '10000e+9' '7' -> '9999999999993' subx347 subtract '10000e+9' '70' -> '9999999999930' subx348 subtract '10000e+9' '700' -> '9999999999300' subx349 subtract '10000e+9' '7000' -> '9999999993000' subx350 subtract '10000e+9' '70000' -> '9999999930000' subx351 subtract '10000e+9' '700000' -> '9999999300000' subx352 subtract '7' '10000e+9' -> '-9999999999993' subx353 subtract '70' '10000e+9' -> '-9999999999930' subx354 subtract '700' '10000e+9' -> '-9999999999300' subx355 subtract '7000' '10000e+9' -> '-9999999993000' subx356 subtract '70000' '10000e+9' -> '-9999999930000' subx357 subtract '700000' '10000e+9' -> '-9999999300000' -- zero preservation precision: 6 subx360 subtract '10000e+9' '70000' -> '1.00000E+13' Inexact Rounded subx361 subtract 1 '0.0001' -> '0.9999' subx362 subtract 1 '0.00001' -> '0.99999' subx363 subtract 1 '0.000001' -> '0.999999' subx364 subtract 1 '0.0000001' -> '1.00000' Inexact Rounded subx365 subtract 1 '0.00000001' -> '1.00000' Inexact Rounded -- some funny zeros [in case of bad signum] subx370 subtract 1 0 -> 1 subx371 subtract 1 0. -> 1 subx372 subtract 1 .0 -> 1.0 subx373 subtract 1 0.0 -> 1.0 subx374 subtract 0 1 -> -1 subx375 subtract 0. 1 -> -1 subx376 subtract .0 1 -> -1.0 subx377 subtract 0.0 1 -> -1.0 precision: 9 -- leading 0 digit before round subx910 subtract -103519362 -51897955.3 -> -51621406.7 subx911 subtract 159579.444 89827.5229 -> 69751.9211 subx920 subtract 333.123456 33.1234566 -> 299.999999 Inexact Rounded subx921 subtract 333.123456 33.1234565 -> 300.000000 Inexact Rounded subx922 subtract 133.123456 33.1234565 -> 99.9999995 subx923 subtract 133.123456 33.1234564 -> 99.9999996 subx924 subtract 133.123456 33.1234540 -> 100.000002 Rounded subx925 subtract 133.123456 43.1234560 -> 90.0000000 subx926 subtract 133.123456 43.1234561 -> 89.9999999 subx927 subtract 133.123456 43.1234566 -> 89.9999994 subx928 subtract 101.123456 91.1234566 -> 9.9999994 subx929 subtract 101.123456 99.1234566 -> 1.9999994 -- more of the same; probe for cluster boundary problems precision: 1 subx930 subtract 11 2 -> 9 precision: 2 subx932 subtract 101 2 -> 99 precision: 3 subx934 subtract 101 2.1 -> 98.9 subx935 subtract 101 92.01 -> 8.99 precision: 4 subx936 subtract 101 2.01 -> 98.99 subx937 subtract 101 92.01 -> 8.99 subx938 subtract 101 92.006 -> 8.994 precision: 5 subx939 subtract 101 2.001 -> 98.999 subx940 subtract 101 92.001 -> 8.999 subx941 subtract 101 92.0006 -> 8.9994 precision: 6 subx942 subtract 101 2.0001 -> 98.9999 subx943 subtract 101 92.0001 -> 8.9999 subx944 subtract 101 92.00006 -> 8.99994 precision: 7 subx945 subtract 101 2.00001 -> 98.99999 subx946 subtract 101 92.00001 -> 8.99999 subx947 subtract 101 92.000006 -> 8.999994 precision: 8 subx948 subtract 101 2.000001 -> 98.999999 subx949 subtract 101 92.000001 -> 8.999999 subx950 subtract 101 92.0000006 -> 8.9999994 precision: 9 subx951 subtract 101 2.0000001 -> 98.9999999 subx952 subtract 101 92.0000001 -> 8.9999999 subx953 subtract 101 92.00000006 -> 8.99999994 precision: 9 -- more LHS swaps [were fixed] subx390 subtract '-56267E-10' 0 -> '-0.0000056267' subx391 subtract '-56267E-6' 0 -> '-0.056267' subx392 subtract '-56267E-5' 0 -> '-0.56267' subx393 subtract '-56267E-4' 0 -> '-5.6267' subx394 subtract '-56267E-3' 0 -> '-56.267' subx395 subtract '-56267E-2' 0 -> '-562.67' subx396 subtract '-56267E-1' 0 -> '-5626.7' subx397 subtract '-56267E-0' 0 -> '-56267' subx398 subtract '-5E-10' 0 -> '-5E-10' subx399 subtract '-5E-7' 0 -> '-5E-7' subx400 subtract '-5E-6' 0 -> '-0.000005' subx401 subtract '-5E-5' 0 -> '-0.00005' subx402 subtract '-5E-4' 0 -> '-0.0005' subx403 subtract '-5E-1' 0 -> '-0.5' subx404 subtract '-5E0' 0 -> '-5' subx405 subtract '-5E1' 0 -> '-50' subx406 subtract '-5E5' 0 -> '-500000' subx407 subtract '-5E8' 0 -> '-500000000' subx408 subtract '-5E9' 0 -> '-5.00000000E+9' Rounded subx409 subtract '-5E10' 0 -> '-5.00000000E+10' Rounded subx410 subtract '-5E11' 0 -> '-5.00000000E+11' Rounded subx411 subtract '-5E100' 0 -> '-5.00000000E+100' Rounded -- more RHS swaps [were fixed] subx420 subtract 0 '-56267E-10' -> '0.0000056267' subx421 subtract 0 '-56267E-6' -> '0.056267' subx422 subtract 0 '-56267E-5' -> '0.56267' subx423 subtract 0 '-56267E-4' -> '5.6267' subx424 subtract 0 '-56267E-3' -> '56.267' subx425 subtract 0 '-56267E-2' -> '562.67' subx426 subtract 0 '-56267E-1' -> '5626.7' subx427 subtract 0 '-56267E-0' -> '56267' subx428 subtract 0 '-5E-10' -> '5E-10' subx429 subtract 0 '-5E-7' -> '5E-7' subx430 subtract 0 '-5E-6' -> '0.000005' subx431 subtract 0 '-5E-5' -> '0.00005' subx432 subtract 0 '-5E-4' -> '0.0005' subx433 subtract 0 '-5E-1' -> '0.5' subx434 subtract 0 '-5E0' -> '5' subx435 subtract 0 '-5E1' -> '50' subx436 subtract 0 '-5E5' -> '500000' subx437 subtract 0 '-5E8' -> '500000000' subx438 subtract 0 '-5E9' -> '5.00000000E+9' Rounded subx439 subtract 0 '-5E10' -> '5.00000000E+10' Rounded subx440 subtract 0 '-5E11' -> '5.00000000E+11' Rounded subx441 subtract 0 '-5E100' -> '5.00000000E+100' Rounded -- try borderline precision, with carries, etc. precision: 15 subx461 subtract '1E+12' '1' -> '999999999999' subx462 subtract '1E+12' '-1.11' -> '1000000000001.11' subx463 subtract '1.11' '-1E+12' -> '1000000000001.11' subx464 subtract '-1' '-1E+12' -> '999999999999' subx465 subtract '7E+12' '1' -> '6999999999999' subx466 subtract '7E+12' '-1.11' -> '7000000000001.11' subx467 subtract '1.11' '-7E+12' -> '7000000000001.11' subx468 subtract '-1' '-7E+12' -> '6999999999999' -- 123456789012345 123456789012345 1 23456789012345 subx470 subtract '0.444444444444444' '-0.555555555555563' -> '1.00000000000001' Inexact Rounded subx471 subtract '0.444444444444444' '-0.555555555555562' -> '1.00000000000001' Inexact Rounded subx472 subtract '0.444444444444444' '-0.555555555555561' -> '1.00000000000001' Inexact Rounded subx473 subtract '0.444444444444444' '-0.555555555555560' -> '1.00000000000000' Inexact Rounded subx474 subtract '0.444444444444444' '-0.555555555555559' -> '1.00000000000000' Inexact Rounded subx475 subtract '0.444444444444444' '-0.555555555555558' -> '1.00000000000000' Inexact Rounded subx476 subtract '0.444444444444444' '-0.555555555555557' -> '1.00000000000000' Inexact Rounded subx477 subtract '0.444444444444444' '-0.555555555555556' -> '1.00000000000000' Rounded subx478 subtract '0.444444444444444' '-0.555555555555555' -> '0.999999999999999' subx479 subtract '0.444444444444444' '-0.555555555555554' -> '0.999999999999998' subx480 subtract '0.444444444444444' '-0.555555555555553' -> '0.999999999999997' subx481 subtract '0.444444444444444' '-0.555555555555552' -> '0.999999999999996' subx482 subtract '0.444444444444444' '-0.555555555555551' -> '0.999999999999995' subx483 subtract '0.444444444444444' '-0.555555555555550' -> '0.999999999999994' -- and some more, including residue effects and different roundings precision: 9 rounding: half_up subx500 subtract '123456789' 0 -> '123456789' subx501 subtract '123456789' 0.000000001 -> '123456789' Inexact Rounded subx502 subtract '123456789' 0.000001 -> '123456789' Inexact Rounded subx503 subtract '123456789' 0.1 -> '123456789' Inexact Rounded subx504 subtract '123456789' 0.4 -> '123456789' Inexact Rounded subx505 subtract '123456789' 0.49 -> '123456789' Inexact Rounded subx506 subtract '123456789' 0.499999 -> '123456789' Inexact Rounded subx507 subtract '123456789' 0.499999999 -> '123456789' Inexact Rounded subx508 subtract '123456789' 0.5 -> '123456789' Inexact Rounded subx509 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded subx510 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded subx511 subtract '123456789' 0.51 -> '123456788' Inexact Rounded subx512 subtract '123456789' 0.6 -> '123456788' Inexact Rounded subx513 subtract '123456789' 0.9 -> '123456788' Inexact Rounded subx514 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded subx515 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded subx516 subtract '123456789' 1 -> '123456788' subx517 subtract '123456789' 1.000000001 -> '123456788' Inexact Rounded subx518 subtract '123456789' 1.00001 -> '123456788' Inexact Rounded subx519 subtract '123456789' 1.1 -> '123456788' Inexact Rounded rounding: half_even subx520 subtract '123456789' 0 -> '123456789' subx521 subtract '123456789' 0.000000001 -> '123456789' Inexact Rounded subx522 subtract '123456789' 0.000001 -> '123456789' Inexact Rounded subx523 subtract '123456789' 0.1 -> '123456789' Inexact Rounded subx524 subtract '123456789' 0.4 -> '123456789' Inexact Rounded subx525 subtract '123456789' 0.49 -> '123456789' Inexact Rounded subx526 subtract '123456789' 0.499999 -> '123456789' Inexact Rounded subx527 subtract '123456789' 0.499999999 -> '123456789' Inexact Rounded subx528 subtract '123456789' 0.5 -> '123456788' Inexact Rounded subx529 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded subx530 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded subx531 subtract '123456789' 0.51 -> '123456788' Inexact Rounded subx532 subtract '123456789' 0.6 -> '123456788' Inexact Rounded subx533 subtract '123456789' 0.9 -> '123456788' Inexact Rounded subx534 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded subx535 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded subx536 subtract '123456789' 1 -> '123456788' subx537 subtract '123456789' 1.00000001 -> '123456788' Inexact Rounded subx538 subtract '123456789' 1.00001 -> '123456788' Inexact Rounded subx539 subtract '123456789' 1.1 -> '123456788' Inexact Rounded -- critical few with even bottom digit... subx540 subtract '123456788' 0.499999999 -> '123456788' Inexact Rounded subx541 subtract '123456788' 0.5 -> '123456788' Inexact Rounded subx542 subtract '123456788' 0.500000001 -> '123456787' Inexact Rounded rounding: down subx550 subtract '123456789' 0 -> '123456789' subx551 subtract '123456789' 0.000000001 -> '123456788' Inexact Rounded subx552 subtract '123456789' 0.000001 -> '123456788' Inexact Rounded subx553 subtract '123456789' 0.1 -> '123456788' Inexact Rounded subx554 subtract '123456789' 0.4 -> '123456788' Inexact Rounded subx555 subtract '123456789' 0.49 -> '123456788' Inexact Rounded subx556 subtract '123456789' 0.499999 -> '123456788' Inexact Rounded subx557 subtract '123456789' 0.499999999 -> '123456788' Inexact Rounded subx558 subtract '123456789' 0.5 -> '123456788' Inexact Rounded subx559 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded subx560 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded subx561 subtract '123456789' 0.51 -> '123456788' Inexact Rounded subx562 subtract '123456789' 0.6 -> '123456788' Inexact Rounded subx563 subtract '123456789' 0.9 -> '123456788' Inexact Rounded subx564 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded subx565 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded subx566 subtract '123456789' 1 -> '123456788' subx567 subtract '123456789' 1.00000001 -> '123456787' Inexact Rounded subx568 subtract '123456789' 1.00001 -> '123456787' Inexact Rounded subx569 subtract '123456789' 1.1 -> '123456787' Inexact Rounded -- symmetry... rounding: half_up subx600 subtract 0 '123456789' -> '-123456789' subx601 subtract 0.000000001 '123456789' -> '-123456789' Inexact Rounded subx602 subtract 0.000001 '123456789' -> '-123456789' Inexact Rounded subx603 subtract 0.1 '123456789' -> '-123456789' Inexact Rounded subx604 subtract 0.4 '123456789' -> '-123456789' Inexact Rounded subx605 subtract 0.49 '123456789' -> '-123456789' Inexact Rounded subx606 subtract 0.499999 '123456789' -> '-123456789' Inexact Rounded subx607 subtract 0.499999999 '123456789' -> '-123456789' Inexact Rounded subx608 subtract 0.5 '123456789' -> '-123456789' Inexact Rounded subx609 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded subx610 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded subx611 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded subx612 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded subx613 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded subx614 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded subx615 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded subx616 subtract 1 '123456789' -> '-123456788' subx617 subtract 1.000000001 '123456789' -> '-123456788' Inexact Rounded subx618 subtract 1.00001 '123456789' -> '-123456788' Inexact Rounded subx619 subtract 1.1 '123456789' -> '-123456788' Inexact Rounded rounding: half_even subx620 subtract 0 '123456789' -> '-123456789' subx621 subtract 0.000000001 '123456789' -> '-123456789' Inexact Rounded subx622 subtract 0.000001 '123456789' -> '-123456789' Inexact Rounded subx623 subtract 0.1 '123456789' -> '-123456789' Inexact Rounded subx624 subtract 0.4 '123456789' -> '-123456789' Inexact Rounded subx625 subtract 0.49 '123456789' -> '-123456789' Inexact Rounded subx626 subtract 0.499999 '123456789' -> '-123456789' Inexact Rounded subx627 subtract 0.499999999 '123456789' -> '-123456789' Inexact Rounded subx628 subtract 0.5 '123456789' -> '-123456788' Inexact Rounded subx629 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded subx630 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded subx631 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded subx632 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded subx633 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded subx634 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded subx635 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded subx636 subtract 1 '123456789' -> '-123456788' subx637 subtract 1.00000001 '123456789' -> '-123456788' Inexact Rounded subx638 subtract 1.00001 '123456789' -> '-123456788' Inexact Rounded subx639 subtract 1.1 '123456789' -> '-123456788' Inexact Rounded -- critical few with even bottom digit... subx640 subtract 0.499999999 '123456788' -> '-123456788' Inexact Rounded subx641 subtract 0.5 '123456788' -> '-123456788' Inexact Rounded subx642 subtract 0.500000001 '123456788' -> '-123456787' Inexact Rounded rounding: down subx650 subtract 0 '123456789' -> '-123456789' subx651 subtract 0.000000001 '123456789' -> '-123456788' Inexact Rounded subx652 subtract 0.000001 '123456789' -> '-123456788' Inexact Rounded subx653 subtract 0.1 '123456789' -> '-123456788' Inexact Rounded subx654 subtract 0.4 '123456789' -> '-123456788' Inexact Rounded subx655 subtract 0.49 '123456789' -> '-123456788' Inexact Rounded subx656 subtract 0.499999 '123456789' -> '-123456788' Inexact Rounded subx657 subtract 0.499999999 '123456789' -> '-123456788' Inexact Rounded subx658 subtract 0.5 '123456789' -> '-123456788' Inexact Rounded subx659 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded subx660 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded subx661 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded subx662 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded subx663 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded subx664 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded subx665 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded subx666 subtract 1 '123456789' -> '-123456788' subx667 subtract 1.00000001 '123456789' -> '-123456787' Inexact Rounded subx668 subtract 1.00001 '123456789' -> '-123456787' Inexact Rounded subx669 subtract 1.1 '123456789' -> '-123456787' Inexact Rounded -- lots of leading zeros in intermediate result, and showing effects of -- input rounding would have affected the following precision: 9 rounding: half_up subx670 subtract '123456789' '123456788.1' -> 0.9 subx671 subtract '123456789' '123456788.9' -> 0.1 subx672 subtract '123456789' '123456789.1' -> -0.1 subx673 subtract '123456789' '123456789.5' -> -0.5 subx674 subtract '123456789' '123456789.9' -> -0.9 rounding: half_even subx680 subtract '123456789' '123456788.1' -> 0.9 subx681 subtract '123456789' '123456788.9' -> 0.1 subx682 subtract '123456789' '123456789.1' -> -0.1 subx683 subtract '123456789' '123456789.5' -> -0.5 subx684 subtract '123456789' '123456789.9' -> -0.9 subx685 subtract '123456788' '123456787.1' -> 0.9 subx686 subtract '123456788' '123456787.9' -> 0.1 subx687 subtract '123456788' '123456788.1' -> -0.1 subx688 subtract '123456788' '123456788.5' -> -0.5 subx689 subtract '123456788' '123456788.9' -> -0.9 rounding: down subx690 subtract '123456789' '123456788.1' -> 0.9 subx691 subtract '123456789' '123456788.9' -> 0.1 subx692 subtract '123456789' '123456789.1' -> -0.1 subx693 subtract '123456789' '123456789.5' -> -0.5 subx694 subtract '123456789' '123456789.9' -> -0.9 -- input preparation tests rounding: half_up precision: 3 subx700 subtract '12345678900000' -9999999999999 -> '2.23E+13' Inexact Rounded subx701 subtract '9999999999999' -12345678900000 -> '2.23E+13' Inexact Rounded subx702 subtract '12E+3' '-3456' -> '1.55E+4' Inexact Rounded subx703 subtract '12E+3' '-3446' -> '1.54E+4' Inexact Rounded subx704 subtract '12E+3' '-3454' -> '1.55E+4' Inexact Rounded subx705 subtract '12E+3' '-3444' -> '1.54E+4' Inexact Rounded subx706 subtract '3456' '-12E+3' -> '1.55E+4' Inexact Rounded subx707 subtract '3446' '-12E+3' -> '1.54E+4' Inexact Rounded subx708 subtract '3454' '-12E+3' -> '1.55E+4' Inexact Rounded subx709 subtract '3444' '-12E+3' -> '1.54E+4' Inexact Rounded -- overflow and underflow tests [subnormals now possible] maxexponent: 999999999 minexponent: -999999999 precision: 9 rounding: down subx710 subtract 1E+999999999 -9E+999999999 -> 9.99999999E+999999999 Overflow Inexact Rounded subx711 subtract 9E+999999999 -1E+999999999 -> 9.99999999E+999999999 Overflow Inexact Rounded rounding: half_up subx712 subtract 1E+999999999 -9E+999999999 -> Infinity Overflow Inexact Rounded subx713 subtract 9E+999999999 -1E+999999999 -> Infinity Overflow Inexact Rounded subx714 subtract -1.1E-999999999 -1E-999999999 -> -1E-1000000000 Subnormal subx715 subtract 1E-999999999 +1.1e-999999999 -> -1E-1000000000 Subnormal subx716 subtract -1E+999999999 +9E+999999999 -> -Infinity Overflow Inexact Rounded subx717 subtract -9E+999999999 +1E+999999999 -> -Infinity Overflow Inexact Rounded subx718 subtract +1.1E-999999999 +1E-999999999 -> 1E-1000000000 Subnormal subx719 subtract -1E-999999999 -1.1e-999999999 -> 1E-1000000000 Subnormal precision: 3 subx720 subtract 1 9.999E+999999999 -> -Infinity Inexact Overflow Rounded subx721 subtract 1 -9.999E+999999999 -> Infinity Inexact Overflow Rounded subx722 subtract 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded subx723 subtract -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded subx724 subtract 1 9.999E+999999999 -> -Infinity Inexact Overflow Rounded subx725 subtract 1 -9.999E+999999999 -> Infinity Inexact Overflow Rounded subx726 subtract 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded subx727 subtract -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded -- [more below] -- long operand checks maxexponent: 999 minexponent: -999 precision: 9 sub731 subtract 12345678000 0 -> 1.23456780E+10 Rounded sub732 subtract 0 12345678000 -> -1.23456780E+10 Rounded sub733 subtract 1234567800 0 -> 1.23456780E+9 Rounded sub734 subtract 0 1234567800 -> -1.23456780E+9 Rounded sub735 subtract 1234567890 0 -> 1.23456789E+9 Rounded sub736 subtract 0 1234567890 -> -1.23456789E+9 Rounded sub737 subtract 1234567891 0 -> 1.23456789E+9 Inexact Rounded sub738 subtract 0 1234567891 -> -1.23456789E+9 Inexact Rounded sub739 subtract 12345678901 0 -> 1.23456789E+10 Inexact Rounded sub740 subtract 0 12345678901 -> -1.23456789E+10 Inexact Rounded sub741 subtract 1234567896 0 -> 1.23456790E+9 Inexact Rounded sub742 subtract 0 1234567896 -> -1.23456790E+9 Inexact Rounded precision: 15 sub751 subtract 12345678000 0 -> 12345678000 sub752 subtract 0 12345678000 -> -12345678000 sub753 subtract 1234567800 0 -> 1234567800 sub754 subtract 0 1234567800 -> -1234567800 sub755 subtract 1234567890 0 -> 1234567890 sub756 subtract 0 1234567890 -> -1234567890 sub757 subtract 1234567891 0 -> 1234567891 sub758 subtract 0 1234567891 -> -1234567891 sub759 subtract 12345678901 0 -> 12345678901 sub760 subtract 0 12345678901 -> -12345678901 sub761 subtract 1234567896 0 -> 1234567896 sub762 subtract 0 1234567896 -> -1234567896 -- Specials subx780 subtract -Inf Inf -> -Infinity subx781 subtract -Inf 1000 -> -Infinity subx782 subtract -Inf 1 -> -Infinity subx783 subtract -Inf -0 -> -Infinity subx784 subtract -Inf -1 -> -Infinity subx785 subtract -Inf -1000 -> -Infinity subx787 subtract -1000 Inf -> -Infinity subx788 subtract -Inf Inf -> -Infinity subx789 subtract -1 Inf -> -Infinity subx790 subtract 0 Inf -> -Infinity subx791 subtract 1 Inf -> -Infinity subx792 subtract 1000 Inf -> -Infinity subx800 subtract Inf Inf -> NaN Invalid_operation subx801 subtract Inf 1000 -> Infinity subx802 subtract Inf 1 -> Infinity subx803 subtract Inf 0 -> Infinity subx804 subtract Inf -0 -> Infinity subx805 subtract Inf -1 -> Infinity subx806 subtract Inf -1000 -> Infinity subx807 subtract Inf -Inf -> Infinity subx808 subtract -1000 -Inf -> Infinity subx809 subtract -Inf -Inf -> NaN Invalid_operation subx810 subtract -1 -Inf -> Infinity subx811 subtract -0 -Inf -> Infinity subx812 subtract 0 -Inf -> Infinity subx813 subtract 1 -Inf -> Infinity subx814 subtract 1000 -Inf -> Infinity subx815 subtract Inf -Inf -> Infinity subx821 subtract NaN Inf -> NaN subx822 subtract -NaN 1000 -> -NaN subx823 subtract NaN 1 -> NaN subx824 subtract NaN 0 -> NaN subx825 subtract NaN -0 -> NaN subx826 subtract NaN -1 -> NaN subx827 subtract NaN -1000 -> NaN subx828 subtract NaN -Inf -> NaN subx829 subtract -NaN NaN -> -NaN subx830 subtract -Inf NaN -> NaN subx831 subtract -1000 NaN -> NaN subx832 subtract -1 NaN -> NaN subx833 subtract -0 NaN -> NaN subx834 subtract 0 NaN -> NaN subx835 subtract 1 NaN -> NaN subx836 subtract 1000 -NaN -> -NaN subx837 subtract Inf NaN -> NaN subx841 subtract sNaN Inf -> NaN Invalid_operation subx842 subtract -sNaN 1000 -> -NaN Invalid_operation subx843 subtract sNaN 1 -> NaN Invalid_operation subx844 subtract sNaN 0 -> NaN Invalid_operation subx845 subtract sNaN -0 -> NaN Invalid_operation subx846 subtract sNaN -1 -> NaN Invalid_operation subx847 subtract sNaN -1000 -> NaN Invalid_operation subx848 subtract sNaN NaN -> NaN Invalid_operation subx849 subtract sNaN sNaN -> NaN Invalid_operation subx850 subtract NaN sNaN -> NaN Invalid_operation subx851 subtract -Inf -sNaN -> -NaN Invalid_operation subx852 subtract -1000 sNaN -> NaN Invalid_operation subx853 subtract -1 sNaN -> NaN Invalid_operation subx854 subtract -0 sNaN -> NaN Invalid_operation subx855 subtract 0 sNaN -> NaN Invalid_operation subx856 subtract 1 sNaN -> NaN Invalid_operation subx857 subtract 1000 sNaN -> NaN Invalid_operation subx858 subtract Inf sNaN -> NaN Invalid_operation subx859 subtract NaN sNaN -> NaN Invalid_operation -- propagating NaNs subx861 subtract NaN01 -Inf -> NaN1 subx862 subtract -NaN02 -1000 -> -NaN2 subx863 subtract NaN03 1000 -> NaN3 subx864 subtract NaN04 Inf -> NaN4 subx865 subtract NaN05 NaN61 -> NaN5 subx866 subtract -Inf -NaN71 -> -NaN71 subx867 subtract -1000 NaN81 -> NaN81 subx868 subtract 1000 NaN91 -> NaN91 subx869 subtract Inf NaN101 -> NaN101 subx871 subtract sNaN011 -Inf -> NaN11 Invalid_operation subx872 subtract sNaN012 -1000 -> NaN12 Invalid_operation subx873 subtract -sNaN013 1000 -> -NaN13 Invalid_operation subx874 subtract sNaN014 NaN171 -> NaN14 Invalid_operation subx875 subtract sNaN015 sNaN181 -> NaN15 Invalid_operation subx876 subtract NaN016 sNaN191 -> NaN191 Invalid_operation subx877 subtract -Inf sNaN201 -> NaN201 Invalid_operation subx878 subtract -1000 sNaN211 -> NaN211 Invalid_operation subx879 subtract 1000 -sNaN221 -> -NaN221 Invalid_operation subx880 subtract Inf sNaN231 -> NaN231 Invalid_operation subx881 subtract NaN025 sNaN241 -> NaN241 Invalid_operation -- edge case spills subx901 subtract 2.E-3 1.002 -> -1.000 subx902 subtract 2.0E-3 1.002 -> -1.0000 subx903 subtract 2.00E-3 1.0020 -> -1.00000 subx904 subtract 2.000E-3 1.00200 -> -1.000000 subx905 subtract 2.0000E-3 1.002000 -> -1.0000000 subx906 subtract 2.00000E-3 1.0020000 -> -1.00000000 subx907 subtract 2.000000E-3 1.00200000 -> -1.000000000 subx908 subtract 2.0000000E-3 1.002000000 -> -1.0000000000 -- subnormals and underflows precision: 3 maxexponent: 999 minexponent: -999 subx1010 subtract 0 1.00E-999 -> -1.00E-999 subx1011 subtract 0 0.1E-999 -> -1E-1000 Subnormal subx1012 subtract 0 0.10E-999 -> -1.0E-1000 Subnormal subx1013 subtract 0 0.100E-999 -> -1.0E-1000 Subnormal Rounded subx1014 subtract 0 0.01E-999 -> -1E-1001 Subnormal -- next is rounded to Emin subx1015 subtract 0 0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow subx1016 subtract 0 0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow subx1017 subtract 0 0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow subx1018 subtract 0 0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1019 subtract 0 0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1020 subtract 0 0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1030 subtract 0 -1.00E-999 -> 1.00E-999 subx1031 subtract 0 -0.1E-999 -> 1E-1000 Subnormal subx1032 subtract 0 -0.10E-999 -> 1.0E-1000 Subnormal subx1033 subtract 0 -0.100E-999 -> 1.0E-1000 Subnormal Rounded subx1034 subtract 0 -0.01E-999 -> 1E-1001 Subnormal -- next is rounded to Emin subx1035 subtract 0 -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow subx1036 subtract 0 -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow subx1037 subtract 0 -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow subx1038 subtract 0 -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1039 subtract 0 -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1040 subtract 0 -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow Clamped -- some non-zero subnormal subtracts -- subx1056 is a tricky case rounding: half_up subx1050 subtract 1.00E-999 0.1E-999 -> 9.0E-1000 Subnormal subx1051 subtract 0.1E-999 0.1E-999 -> 0E-1000 subx1052 subtract 0.10E-999 0.1E-999 -> 0E-1001 subx1053 subtract 0.100E-999 0.1E-999 -> 0E-1001 Clamped subx1054 subtract 0.01E-999 0.1E-999 -> -9E-1001 Subnormal subx1055 subtract 0.999E-999 0.1E-999 -> 9.0E-1000 Inexact Rounded Subnormal Underflow subx1056 subtract 0.099E-999 0.1E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow Clamped subx1057 subtract 0.009E-999 0.1E-999 -> -9E-1001 Inexact Rounded Subnormal Underflow subx1058 subtract 0.001E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow subx1059 subtract 0.0009E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow subx1060 subtract 0.0001E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow -- check for double-rounded subnormals precision: 5 maxexponent: 79 minexponent: -79 subx1101 subtract 0 1.52444E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow subx1102 subtract 0 1.52445E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow subx1103 subtract 0 1.52446E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow subx1104 subtract 1.52444E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow subx1105 subtract 1.52445E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow subx1106 subtract 1.52446E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow subx1111 subtract 1.2345678E-80 1.2345671E-80 -> 0E-83 Inexact Rounded Subnormal Underflow Clamped subx1112 subtract 1.2345678E-80 1.2345618E-80 -> 0E-83 Inexact Rounded Subnormal Underflow Clamped subx1113 subtract 1.2345678E-80 1.2345178E-80 -> 0E-83 Inexact Rounded Subnormal Underflow Clamped subx1114 subtract 1.2345678E-80 1.2341678E-80 -> 0E-83 Inexact Rounded Subnormal Underflow Clamped subx1115 subtract 1.2345678E-80 1.2315678E-80 -> 3E-83 Rounded Subnormal subx1116 subtract 1.2345678E-80 1.2145678E-80 -> 2.0E-82 Rounded Subnormal subx1117 subtract 1.2345678E-80 1.1345678E-80 -> 1.00E-81 Rounded Subnormal subx1118 subtract 1.2345678E-80 0.2345678E-80 -> 1.000E-80 Rounded Subnormal precision: 34 rounding: half_up maxExponent: 6144 minExponent: -6143 -- Examples from SQL proposal (Krishna Kulkarni) subx1125 subtract 130E-2 120E-2 -> 0.10 subx1126 subtract 130E-2 12E-1 -> 0.10 subx1127 subtract 130E-2 1E0 -> 0.30 subx1128 subtract 1E2 1E4 -> -9.9E+3 -- Null tests subx9990 subtract 10 # -> NaN Invalid_operation subx9991 subtract # 10 -> NaN Invalid_operation apd-3.2.1/testdata/tointegral.decTest000066400000000000000000000215071450022325000175550ustar00rootroot00000000000000------------------------------------------------------------------------ -- tointegral.decTest -- round decimal to integral value -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This set of tests tests the extended specification 'round-to-integral -- value' operation (from IEEE 854, later modified in 754r). -- All non-zero results are defined as being those from either copy or -- quantize, so those are assumed to have been tested. -- Note that 754r requires that Inexact not be set, and we similarly -- assume Rounded is not set. extended: 1 precision: 9 rounding: half_up maxExponent: 999 minExponent: -999 intx001 tointegral 0 -> 0 intx002 tointegral 0.0 -> 0 intx003 tointegral 0.1 -> 0 intx004 tointegral 0.2 -> 0 intx005 tointegral 0.3 -> 0 intx006 tointegral 0.4 -> 0 intx007 tointegral 0.5 -> 1 intx008 tointegral 0.6 -> 1 intx009 tointegral 0.7 -> 1 intx010 tointegral 0.8 -> 1 intx011 tointegral 0.9 -> 1 intx012 tointegral 1 -> 1 intx013 tointegral 1.0 -> 1 intx014 tointegral 1.1 -> 1 intx015 tointegral 1.2 -> 1 intx016 tointegral 1.3 -> 1 intx017 tointegral 1.4 -> 1 intx018 tointegral 1.5 -> 2 intx019 tointegral 1.6 -> 2 intx020 tointegral 1.7 -> 2 intx021 tointegral 1.8 -> 2 intx022 tointegral 1.9 -> 2 -- negatives intx031 tointegral -0 -> -0 intx032 tointegral -0.0 -> -0 intx033 tointegral -0.1 -> -0 intx034 tointegral -0.2 -> -0 intx035 tointegral -0.3 -> -0 intx036 tointegral -0.4 -> -0 intx037 tointegral -0.5 -> -1 intx038 tointegral -0.6 -> -1 intx039 tointegral -0.7 -> -1 intx040 tointegral -0.8 -> -1 intx041 tointegral -0.9 -> -1 intx042 tointegral -1 -> -1 intx043 tointegral -1.0 -> -1 intx044 tointegral -1.1 -> -1 intx045 tointegral -1.2 -> -1 intx046 tointegral -1.3 -> -1 intx047 tointegral -1.4 -> -1 intx048 tointegral -1.5 -> -2 intx049 tointegral -1.6 -> -2 intx050 tointegral -1.7 -> -2 intx051 tointegral -1.8 -> -2 intx052 tointegral -1.9 -> -2 -- next two would be NaN using quantize(x, 0) intx053 tointegral 10E+30 -> 1.0E+31 intx054 tointegral -10E+30 -> -1.0E+31 -- numbers around precision precision: 9 intx060 tointegral '56267E-10' -> '0' intx061 tointegral '56267E-5' -> '1' intx062 tointegral '56267E-2' -> '563' intx063 tointegral '56267E-1' -> '5627' intx065 tointegral '56267E-0' -> '56267' intx066 tointegral '56267E+0' -> '56267' intx067 tointegral '56267E+1' -> '5.6267E+5' intx068 tointegral '56267E+2' -> '5.6267E+6' intx069 tointegral '56267E+3' -> '5.6267E+7' intx070 tointegral '56267E+4' -> '5.6267E+8' intx071 tointegral '56267E+5' -> '5.6267E+9' intx072 tointegral '56267E+6' -> '5.6267E+10' intx073 tointegral '1.23E+96' -> '1.23E+96' intx074 tointegral '1.23E+384' -> '1.23E+384' intx075 tointegral '1.23E+999' -> '1.23E+999' intx080 tointegral '-56267E-10' -> '-0' intx081 tointegral '-56267E-5' -> '-1' intx082 tointegral '-56267E-2' -> '-563' intx083 tointegral '-56267E-1' -> '-5627' intx085 tointegral '-56267E-0' -> '-56267' intx086 tointegral '-56267E+0' -> '-56267' intx087 tointegral '-56267E+1' -> '-5.6267E+5' intx088 tointegral '-56267E+2' -> '-5.6267E+6' intx089 tointegral '-56267E+3' -> '-5.6267E+7' intx090 tointegral '-56267E+4' -> '-5.6267E+8' intx091 tointegral '-56267E+5' -> '-5.6267E+9' intx092 tointegral '-56267E+6' -> '-5.6267E+10' intx093 tointegral '-1.23E+96' -> '-1.23E+96' intx094 tointegral '-1.23E+384' -> '-1.23E+384' intx095 tointegral '-1.23E+999' -> '-1.23E+999' -- subnormal inputs intx100 tointegral 1E-999 -> 0 intx101 tointegral 0.1E-999 -> 0 intx102 tointegral 0.01E-999 -> 0 intx103 tointegral 0E-999 -> 0 -- specials and zeros intx120 tointegral 'Inf' -> Infinity intx121 tointegral '-Inf' -> -Infinity intx122 tointegral NaN -> NaN intx123 tointegral sNaN -> NaN Invalid_operation intx124 tointegral 0 -> 0 intx125 tointegral -0 -> -0 intx126 tointegral 0.000 -> 0 intx127 tointegral 0.00 -> 0 intx128 tointegral 0.0 -> 0 intx129 tointegral 0 -> 0 intx130 tointegral 0E-3 -> 0 intx131 tointegral 0E-2 -> 0 intx132 tointegral 0E-1 -> 0 intx133 tointegral 0E-0 -> 0 intx134 tointegral 0E+1 -> 0E+1 intx135 tointegral 0E+2 -> 0E+2 intx136 tointegral 0E+3 -> 0E+3 intx137 tointegral 0E+4 -> 0E+4 intx138 tointegral 0E+5 -> 0E+5 intx139 tointegral -0.000 -> -0 intx140 tointegral -0.00 -> -0 intx141 tointegral -0.0 -> -0 intx142 tointegral -0 -> -0 intx143 tointegral -0E-3 -> -0 intx144 tointegral -0E-2 -> -0 intx145 tointegral -0E-1 -> -0 intx146 tointegral -0E-0 -> -0 intx147 tointegral -0E+1 -> -0E+1 intx148 tointegral -0E+2 -> -0E+2 intx149 tointegral -0E+3 -> -0E+3 intx150 tointegral -0E+4 -> -0E+4 intx151 tointegral -0E+5 -> -0E+5 -- propagating NaNs intx152 tointegral NaN808 -> NaN808 intx153 tointegral sNaN080 -> NaN80 Invalid_operation intx154 tointegral -NaN808 -> -NaN808 intx155 tointegral -sNaN080 -> -NaN80 Invalid_operation intx156 tointegral -NaN -> -NaN intx157 tointegral -sNaN -> -NaN Invalid_operation -- examples rounding: half_up precision: 9 intx200 tointegral 2.1 -> 2 intx201 tointegral 100 -> 100 intx202 tointegral 100.0 -> 100 intx203 tointegral 101.5 -> 102 intx204 tointegral -101.5 -> -102 intx205 tointegral 10E+5 -> 1.0E+6 intx206 tointegral 7.89E+77 -> 7.89E+77 intx207 tointegral -Inf -> -Infinity -- all rounding modes rounding: half_even intx210 tointegral 55.5 -> 56 intx211 tointegral 56.5 -> 56 intx212 tointegral 57.5 -> 58 intx213 tointegral -55.5 -> -56 intx214 tointegral -56.5 -> -56 intx215 tointegral -57.5 -> -58 rounding: half_up intx220 tointegral 55.5 -> 56 intx221 tointegral 56.5 -> 57 intx222 tointegral 57.5 -> 58 intx223 tointegral -55.5 -> -56 intx224 tointegral -56.5 -> -57 intx225 tointegral -57.5 -> -58 rounding: half_down intx230 tointegral 55.5 -> 55 intx231 tointegral 56.5 -> 56 intx232 tointegral 57.5 -> 57 intx233 tointegral -55.5 -> -55 intx234 tointegral -56.5 -> -56 intx235 tointegral -57.5 -> -57 rounding: up intx240 tointegral 55.3 -> 56 intx241 tointegral 56.3 -> 57 intx242 tointegral 57.3 -> 58 intx243 tointegral -55.3 -> -56 intx244 tointegral -56.3 -> -57 intx245 tointegral -57.3 -> -58 rounding: down intx250 tointegral 55.7 -> 55 intx251 tointegral 56.7 -> 56 intx252 tointegral 57.7 -> 57 intx253 tointegral -55.7 -> -55 intx254 tointegral -56.7 -> -56 intx255 tointegral -57.7 -> -57 rounding: ceiling intx260 tointegral 55.3 -> 56 intx261 tointegral 56.3 -> 57 intx262 tointegral 57.3 -> 58 intx263 tointegral -55.3 -> -55 intx264 tointegral -56.3 -> -56 intx265 tointegral -57.3 -> -57 rounding: floor intx270 tointegral 55.7 -> 55 intx271 tointegral 56.7 -> 56 intx272 tointegral 57.7 -> 57 intx273 tointegral -55.7 -> -56 intx274 tointegral -56.7 -> -57 intx275 tointegral -57.7 -> -58 apd-3.2.1/testdata/tointegralx.decTest000066400000000000000000000270121450022325000177420ustar00rootroot00000000000000------------------------------------------------------------------------ -- tointegralx.decTest -- round decimal to integral value, exact -- -- Copyright (c) Mike Cowlishaw, 1981, 2010. All rights reserved. -- -- Parts copyright (c) IBM Corporation, 1981, 2008. -- ------------------------------------------------------------------------ -- Please see the document "General Decimal Arithmetic Testcases" -- -- at http://speleotrove.com/decimal for the description of -- -- these testcases. -- -- -- -- These testcases are experimental ('beta' versions), and they -- -- may contain errors. They are offered on an as-is basis. In -- -- particular, achieving the same results as the tests here is not -- -- a guarantee that an implementation complies with any Standard -- -- or specification. The tests are not exhaustive. -- -- -- -- Please send comments, suggestions, and corrections to the author: -- -- Mike Cowlishaw, mfc@speleotrove.com -- ------------------------------------------------------------------------ version: 2.62 -- This set of tests tests the extended specification 'round-to-integral -- value' operation (from IEEE 854, later modified in 754r). -- All non-zero results are defined as being those from either copy or -- quantize, so those are assumed to have been tested. -- This tests toIntegraExact, which may set Inexact extended: 1 precision: 9 rounding: half_up maxExponent: 999 minExponent: -999 intxx001 tointegralx 0 -> 0 intxx002 tointegralx 0.0 -> 0 intxx003 tointegralx 0.1 -> 0 Inexact Rounded intxx004 tointegralx 0.2 -> 0 Inexact Rounded intxx005 tointegralx 0.3 -> 0 Inexact Rounded intxx006 tointegralx 0.4 -> 0 Inexact Rounded intxx007 tointegralx 0.5 -> 1 Inexact Rounded intxx008 tointegralx 0.6 -> 1 Inexact Rounded intxx009 tointegralx 0.7 -> 1 Inexact Rounded intxx010 tointegralx 0.8 -> 1 Inexact Rounded intxx011 tointegralx 0.9 -> 1 Inexact Rounded intxx012 tointegralx 1 -> 1 intxx013 tointegralx 1.0 -> 1 Rounded intxx014 tointegralx 1.1 -> 1 Inexact Rounded intxx015 tointegralx 1.2 -> 1 Inexact Rounded intxx016 tointegralx 1.3 -> 1 Inexact Rounded intxx017 tointegralx 1.4 -> 1 Inexact Rounded intxx018 tointegralx 1.5 -> 2 Inexact Rounded intxx019 tointegralx 1.6 -> 2 Inexact Rounded intxx020 tointegralx 1.7 -> 2 Inexact Rounded intxx021 tointegralx 1.8 -> 2 Inexact Rounded intxx022 tointegralx 1.9 -> 2 Inexact Rounded -- negatives intxx031 tointegralx -0 -> -0 intxx032 tointegralx -0.0 -> -0 intxx033 tointegralx -0.1 -> -0 Inexact Rounded intxx034 tointegralx -0.2 -> -0 Inexact Rounded intxx035 tointegralx -0.3 -> -0 Inexact Rounded intxx036 tointegralx -0.4 -> -0 Inexact Rounded intxx037 tointegralx -0.5 -> -1 Inexact Rounded intxx038 tointegralx -0.6 -> -1 Inexact Rounded intxx039 tointegralx -0.7 -> -1 Inexact Rounded intxx040 tointegralx -0.8 -> -1 Inexact Rounded intxx041 tointegralx -0.9 -> -1 Inexact Rounded intxx042 tointegralx -1 -> -1 intxx043 tointegralx -1.0 -> -1 Rounded intxx044 tointegralx -1.1 -> -1 Inexact Rounded intxx045 tointegralx -1.2 -> -1 Inexact Rounded intxx046 tointegralx -1.3 -> -1 Inexact Rounded intxx047 tointegralx -1.4 -> -1 Inexact Rounded intxx048 tointegralx -1.5 -> -2 Inexact Rounded intxx049 tointegralx -1.6 -> -2 Inexact Rounded intxx050 tointegralx -1.7 -> -2 Inexact Rounded intxx051 tointegralx -1.8 -> -2 Inexact Rounded intxx052 tointegralx -1.9 -> -2 Inexact Rounded -- next two would be NaN using quantize(x, 0) intxx053 tointegralx 10E+30 -> 1.0E+31 intxx054 tointegralx -10E+30 -> -1.0E+31 -- numbers around precision precision: 9 intxx060 tointegralx '56267E-10' -> '0' Inexact Rounded intxx061 tointegralx '56267E-5' -> '1' Inexact Rounded intxx062 tointegralx '56267E-2' -> '563' Inexact Rounded intxx063 tointegralx '56267E-1' -> '5627' Inexact Rounded intxx065 tointegralx '56267E-0' -> '56267' intxx066 tointegralx '56267E+0' -> '56267' intxx067 tointegralx '56267E+1' -> '5.6267E+5' intxx068 tointegralx '56267E+2' -> '5.6267E+6' intxx069 tointegralx '56267E+3' -> '5.6267E+7' intxx070 tointegralx '56267E+4' -> '5.6267E+8' intxx071 tointegralx '56267E+5' -> '5.6267E+9' intxx072 tointegralx '56267E+6' -> '5.6267E+10' intxx073 tointegralx '1.23E+96' -> '1.23E+96' intxx074 tointegralx '1.23E+384' -> '1.23E+384' intxx075 tointegralx '1.23E+999' -> '1.23E+999' intxx080 tointegralx '-56267E-10' -> '-0' Inexact Rounded intxx081 tointegralx '-56267E-5' -> '-1' Inexact Rounded intxx082 tointegralx '-56267E-2' -> '-563' Inexact Rounded intxx083 tointegralx '-56267E-1' -> '-5627' Inexact Rounded intxx085 tointegralx '-56267E-0' -> '-56267' intxx086 tointegralx '-56267E+0' -> '-56267' intxx087 tointegralx '-56267E+1' -> '-5.6267E+5' intxx088 tointegralx '-56267E+2' -> '-5.6267E+6' intxx089 tointegralx '-56267E+3' -> '-5.6267E+7' intxx090 tointegralx '-56267E+4' -> '-5.6267E+8' intxx091 tointegralx '-56267E+5' -> '-5.6267E+9' intxx092 tointegralx '-56267E+6' -> '-5.6267E+10' intxx093 tointegralx '-1.23E+96' -> '-1.23E+96' intxx094 tointegralx '-1.23E+384' -> '-1.23E+384' intxx095 tointegralx '-1.23E+999' -> '-1.23E+999' -- subnormal inputs intxx100 tointegralx 1E-999 -> 0 Inexact Rounded intxx101 tointegralx 0.1E-999 -> 0 Inexact Rounded intxx102 tointegralx 0.01E-999 -> 0 Inexact Rounded intxx103 tointegralx 0E-999 -> 0 -- specials and zeros intxx120 tointegralx 'Inf' -> Infinity intxx121 tointegralx '-Inf' -> -Infinity intxx122 tointegralx NaN -> NaN intxx123 tointegralx sNaN -> NaN Invalid_operation intxx124 tointegralx 0 -> 0 intxx125 tointegralx -0 -> -0 intxx126 tointegralx 0.000 -> 0 intxx127 tointegralx 0.00 -> 0 intxx128 tointegralx 0.0 -> 0 intxx129 tointegralx 0 -> 0 intxx130 tointegralx 0E-3 -> 0 intxx131 tointegralx 0E-2 -> 0 intxx132 tointegralx 0E-1 -> 0 intxx133 tointegralx 0E-0 -> 0 intxx134 tointegralx 0E+1 -> 0E+1 intxx135 tointegralx 0E+2 -> 0E+2 intxx136 tointegralx 0E+3 -> 0E+3 intxx137 tointegralx 0E+4 -> 0E+4 intxx138 tointegralx 0E+5 -> 0E+5 intxx139 tointegralx -0.000 -> -0 intxx140 tointegralx -0.00 -> -0 intxx141 tointegralx -0.0 -> -0 intxx142 tointegralx -0 -> -0 intxx143 tointegralx -0E-3 -> -0 intxx144 tointegralx -0E-2 -> -0 intxx145 tointegralx -0E-1 -> -0 intxx146 tointegralx -0E-0 -> -0 intxx147 tointegralx -0E+1 -> -0E+1 intxx148 tointegralx -0E+2 -> -0E+2 intxx149 tointegralx -0E+3 -> -0E+3 intxx150 tointegralx -0E+4 -> -0E+4 intxx151 tointegralx -0E+5 -> -0E+5 -- propagating NaNs intxx152 tointegralx NaN808 -> NaN808 intxx153 tointegralx sNaN080 -> NaN80 Invalid_operation intxx154 tointegralx -NaN808 -> -NaN808 intxx155 tointegralx -sNaN080 -> -NaN80 Invalid_operation intxx156 tointegralx -NaN -> -NaN intxx157 tointegralx -sNaN -> -NaN Invalid_operation -- examples rounding: half_up precision: 9 intxx200 tointegralx 2.1 -> 2 Inexact Rounded intxx201 tointegralx 100 -> 100 intxx202 tointegralx 100.0 -> 100 Rounded intxx203 tointegralx 101.5 -> 102 Inexact Rounded intxx204 tointegralx -101.5 -> -102 Inexact Rounded intxx205 tointegralx 10E+5 -> 1.0E+6 intxx206 tointegralx 7.89E+77 -> 7.89E+77 intxx207 tointegralx -Inf -> -Infinity -- all rounding modes rounding: half_even intxx210 tointegralx 55.5 -> 56 Inexact Rounded intxx211 tointegralx 56.5 -> 56 Inexact Rounded intxx212 tointegralx 57.5 -> 58 Inexact Rounded intxx213 tointegralx -55.5 -> -56 Inexact Rounded intxx214 tointegralx -56.5 -> -56 Inexact Rounded intxx215 tointegralx -57.5 -> -58 Inexact Rounded rounding: half_up intxx220 tointegralx 55.5 -> 56 Inexact Rounded intxx221 tointegralx 56.5 -> 57 Inexact Rounded intxx222 tointegralx 57.5 -> 58 Inexact Rounded intxx223 tointegralx -55.5 -> -56 Inexact Rounded intxx224 tointegralx -56.5 -> -57 Inexact Rounded intxx225 tointegralx -57.5 -> -58 Inexact Rounded rounding: half_down intxx230 tointegralx 55.5 -> 55 Inexact Rounded intxx231 tointegralx 56.5 -> 56 Inexact Rounded intxx232 tointegralx 57.5 -> 57 Inexact Rounded intxx233 tointegralx -55.5 -> -55 Inexact Rounded intxx234 tointegralx -56.5 -> -56 Inexact Rounded intxx235 tointegralx -57.5 -> -57 Inexact Rounded rounding: up intxx240 tointegralx 55.3 -> 56 Inexact Rounded intxx241 tointegralx 56.3 -> 57 Inexact Rounded intxx242 tointegralx 57.3 -> 58 Inexact Rounded intxx243 tointegralx -55.3 -> -56 Inexact Rounded intxx244 tointegralx -56.3 -> -57 Inexact Rounded intxx245 tointegralx -57.3 -> -58 Inexact Rounded rounding: down intxx250 tointegralx 55.7 -> 55 Inexact Rounded intxx251 tointegralx 56.7 -> 56 Inexact Rounded intxx252 tointegralx 57.7 -> 57 Inexact Rounded intxx253 tointegralx -55.7 -> -55 Inexact Rounded intxx254 tointegralx -56.7 -> -56 Inexact Rounded intxx255 tointegralx -57.7 -> -57 Inexact Rounded rounding: ceiling intxx260 tointegralx 55.3 -> 56 Inexact Rounded intxx261 tointegralx 56.3 -> 57 Inexact Rounded intxx262 tointegralx 57.3 -> 58 Inexact Rounded intxx263 tointegralx -55.3 -> -55 Inexact Rounded intxx264 tointegralx -56.3 -> -56 Inexact Rounded intxx265 tointegralx -57.3 -> -57 Inexact Rounded rounding: floor intxx270 tointegralx 55.7 -> 55 Inexact Rounded intxx271 tointegralx 56.7 -> 56 Inexact Rounded intxx272 tointegralx 57.7 -> 57 Inexact Rounded intxx273 tointegralx -55.7 -> -56 Inexact Rounded intxx274 tointegralx -56.7 -> -57 Inexact Rounded intxx275 tointegralx -57.7 -> -58 Inexact Rounded -- Int and uInt32 edge values for testing conversions precision: 16 intxx300 tointegralx -2147483646 -> -2147483646 intxx301 tointegralx -2147483647 -> -2147483647 intxx302 tointegralx -2147483648 -> -2147483648 intxx303 tointegralx -2147483649 -> -2147483649 intxx304 tointegralx 2147483646 -> 2147483646 intxx305 tointegralx 2147483647 -> 2147483647 intxx306 tointegralx 2147483648 -> 2147483648 intxx307 tointegralx 2147483649 -> 2147483649 intxx308 tointegralx 4294967294 -> 4294967294 intxx309 tointegralx 4294967295 -> 4294967295 intxx310 tointegralx 4294967296 -> 4294967296 intxx311 tointegralx 4294967297 -> 4294967297