math.sqrt on complex, imaginary part, im greater than 0 branch

Time bar (total: 12.0s)

start0.0ms (0%)

Memory
0.1MiB live, 0.1MiB allocated

analyze94.0ms (0.8%)

Memory
-0.6MiB live, 164.0MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%50%50%0%0%0%0
0%0%50%50%0%0%0%1
50%25%25%50%0%0%0%2
50%25%25%50%0%0%0%3
62.5%31.2%18.7%50%0%0%0%4
62.5%31.2%18.7%50%0%0%0%5
68.8%34.3%15.6%50%0%0%0%6
68.8%34.3%15.6%50%0%0%0%7
71.9%35.9%14%50%0%0%0%8
71.9%35.9%14%50%0%0%0%9
73.4%36.7%13.3%50%0%0%0%10
73.4%36.7%13.3%50%0%0%0%11
74.2%37.1%12.9%50%0%0%0%12
Compiler

Compiled 19 to 12 computations (36.8% saved)

sample1.1s (9.5%)

Memory
30.1MiB live, 1 829.3MiB allocated
Samples
434.0ms6 187×0valid
166.0ms835×2valid
131.0ms439×3valid
100.0ms795×1valid
Precisions
Click to see histograms. Total time spent on operations: 617.0ms
ival-hypot: 247.0ms (40% of total)
ival-mult: 136.0ms (22% of total)
ival-sqrt: 91.0ms (14.8% of total)
ival-sub: 59.0ms (9.6% of total)
adjust: 39.0ms (6.3% of total)
ival->: 28.0ms (4.5% of total)
exact: 12.0ms (1.9% of total)
ival-assert: 3.0ms (0.5% of total)
Bogosity

explain175.0ms (1.5%)

Memory
4.3MiB live, 319.7MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1130-2(6.675558846391269e-307 2.6834082825482314e-157)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
370-0-(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
240-2(2.838857890837015e-21 1.3514421925598808e-169)(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
00-0-(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
00-0-(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
00-0-(*.f64 re re)
00-0-im
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-#s(literal 2 binary64)
00-0-re
00-0-#s(literal 1/2 binary64)
00-0-(*.f64 im im)
Explanations
Click to see full explanations table
OperatorSubexpressionExplanationCount
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))oflow-rescue1010
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow101
↳(*.f64 re re)overflow63
↳(*.f64 im im)overflow56
-.f64(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)cancellation370
sqrt.f64(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))uflow-rescue220
↳(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))underflow31
↳(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))underflow9
↳(*.f64 re re)underflow55
↳(*.f64 im im)underflow60
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow10
↳(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)underflow31
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue100
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow10
↳(*.f64 re re)underflow55
↳(*.f64 im im)underflow60
Confusion
Predicted +Predicted -
+1461
-0109
Precision
1.0
Recall
0.9931972789115646
Confusion?
Predicted +Predicted MaybePredicted -
+14601
-00109
Precision?
1.0
Recall?
0.9931972789115646
Freqs
test
numberfreq
0110
1122
224
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
36.0ms378×0valid
13.0ms32×3valid
12.0ms48×2valid
9.0ms54×1valid
Compiler

Compiled 171 to 40 computations (76.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 49.0ms
ival-hypot: 15.0ms (30.4% of total)
ival-mult: 15.0ms (30.4% of total)
adjust: 5.0ms (10.1% of total)
ival-sub: 5.0ms (10.1% of total)
ival-sqrt: 5.0ms (10.1% of total)
ival-add: 3.0ms (6.1% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

preprocess54.0ms (0.5%)

Memory
-2.5MiB live, 74.5MiB allocated
Algorithm
1×egg-herbie
Rules
368×lower-fma.f64
368×lower-fma.f32
228×lower-*.f32
220×lower-*.f64
136×distribute-rgt-in
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03077
17175
215275
328575
442475
551575
663775
777575
883075
01215
02015
12515
23615
35215
47315
59815
615415
722715
831015
936015
1042015
1143415
1245015
1347015
1450015
1553115
1654315
1754515
054510
Stop Event
1×iter limit
1×saturated
1×iter limit
1×saturated
Calls
Call 1
Inputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
Symmetry

(abs im)

Samples
0.0ms2×2valid
Compiler

Compiled 67 to 35 computations (47.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 0.0ms
adjust: 0.0ms (0% of total)
ival-hypot: 0.0ms (0% of total)
ival-sub: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)
ival-sqrt: 0.0ms (0% of total)
ival-mult: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.4MiB live, 0.4MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

Memory
1.6MiB live, 1.6MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶45.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
Compiler

Compiled 17 to 12 computations (29.4% saved)

simplify404.0ms (3.4%)

Memory
35.7MiB live, 744.4MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
cost-diff0
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
cost-diff128
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
368×lower-fma.f64
368×lower-fma.f32
228×lower-*.f32
220×lower-*.f64
104×lower-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01275
02075
12575
23675
35275
47375
59875
615475
722775
831075
936075
1042075
1143475
1245075
1347075
1450075
1553175
1654375
1754575
054549
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
#s(literal 1/2 binary64)
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
#s(literal 2 binary64)
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
#s(literal 1/2 binary64)
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))
#s(literal 2 binary64)
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
(-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
Samples
104.0ms2 744×0valid
30.0ms163×2valid
30.0ms258×1valid
13.0ms51×3valid
Compiler

Compiled 30 096 to 20 629 computations (31.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 101.0ms
ival-hypot: 44.0ms (43.5% of total)
ival-mult: 18.0ms (17.8% of total)
ival-sqrt: 9.0ms (8.9% of total)
ival-add: 9.0ms (8.9% of total)
ival-sub: 7.0ms (6.9% of total)
adjust: 7.0ms (6.9% of total)
ival-true: 3.0ms (3% of total)
exact: 2.0ms (2% of total)
ival-assert: 1.0ms (1% of total)
ival-neg: 1.0ms (1% of total)

localize53.0ms (0.4%)

Memory
-28.4MiB live, 86.7MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0.00390625
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
accuracy5.406145298796429
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
accuracy8.226426885405672
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
accuracy25.903661049980084
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
17.0ms189×0valid
10.0ms24×2valid
6.0ms16×3valid
5.0ms27×1valid
Compiler

Compiled 77 to 14 computations (81.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 23.0ms
ival-hypot: 7.0ms (30.2% of total)
ival-mult: 7.0ms (30.2% of total)
ival-sqrt: 3.0ms (12.9% of total)
adjust: 2.0ms (8.6% of total)
ival-sub: 2.0ms (8.6% of total)
ival-add: 1.0ms (4.3% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series22.0ms (0.2%)

Memory
35.1MiB live, 35.1MiB allocated
Counts
6 → 144
Calls
Call 1
Inputs
#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())
#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())
#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())
Outputs
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (* (sqrt im) (sqrt 2))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2)))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2))))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2)))))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/1024 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2)))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/64 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/32 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/4 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re))))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/4 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/4 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2)))))))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (* (sqrt im) (sqrt 2))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2)))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) (patch (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt im) (sqrt 2)) (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2))) (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))))) (* (sqrt im) (sqrt 2))) (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2))) (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))) (taylor inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))) (taylor inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))) (taylor inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/512 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))) (taylor inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2)))) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1/4 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/32 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))) (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))))) (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re))))))) (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/2 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2)))))))))) (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt im) (sqrt 2)) (taylor inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))) (taylor inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))) (taylor inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2)))) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) (patch (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) #<representation binary64>) () ())) ())
#s(alt (* 2 im) (taylor 0 re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 re) (* 2 im)) (taylor 0 re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 im) (* re (- (/ re im) 2))) (taylor 0 re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 im) (* re (- (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))) 2))) (taylor 0 re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (/ (pow im 2) re) (taylor inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re) (taylor inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re) (taylor inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re) (taylor inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -4 re) (taylor -inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 4 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (/ (pow im 2) re) (taylor 0 im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))) (taylor 0 im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))) (taylor 0 im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/64 (/ (pow im 2) (pow re 7))) (* 1/8 (/ 1 (pow re 5))))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))) (taylor 0 im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 im) (taylor inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 2 (* -2 (/ re im)))) (taylor inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 2 (+ (* -2 (/ re im)) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 2 (+ (* -2 (/ re im)) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -2 im) (taylor -inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 2 (* 2 (/ re im))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (pow re 2) im))) im))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im))) im))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) (patch (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (+ im (* -1 re)) (taylor 0 re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (+ im (* re (- (* 1/2 (/ re im)) 1))) (taylor 0 re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (+ im (* re (- (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))) 1))) (taylor 0 re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re) (taylor inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re) (taylor inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re) (taylor inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -2 re) (taylor -inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor 0 im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))) (taylor 0 im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))) (taylor 0 im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/128 (/ (pow im 2) (pow re 7))) (* 1/16 (/ 1 (pow re 5))))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))) (taylor 0 im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* -1 (/ re im)))) (taylor inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* im (- (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))) (/ re im))) (taylor inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* im (- (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (/ re im))) (taylor inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (/ re im)))) (taylor -inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1/2 (/ (pow re 2) im)) re) im))))) (taylor -inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im)) re) im))))) (taylor -inf im) (#s(alt (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) (patch (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #<representation binary64>) () ())) ())
Calls

36 calls:

TimeVariablePointExpression
2.0ms
im
@0
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
2.0ms
re
@inf
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
2.0ms
re
@-inf
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
1.0ms
im
@inf
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
1.0ms
im
@inf
(sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re)))

simplify10.0s (83.8%)

Memory
243.0MiB live, 16 242.4MiB allocated
Algorithm
1×egg-herbie
Rules
11 848×lower-fma.f64
11 848×lower-fma.f32
8 470×lower-*.f64
8 470×lower-*.f32
3 078×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05513257
118143103
263803088
081972913
Stop Event
1×iter limit
1×node limit
Samples
3.5s31 054×0valid
866.0ms6 155×0invalid
1.0ms3×2valid
0.0ms2×5exit
Compiler

Compiled 995 016 to 656 905 computations (34% saved)

Precisions
Click to see histograms. Total time spent on operations: 2.7s
ival-mult: 1.3s (46.1% of total)
ival-div: 487.0ms (17.7% of total)
ival-sqrt: 329.0ms (12% of total)
ival-add: 253.0ms (9.2% of total)
ival-pow: 223.0ms (8.1% of total)
ival-neg: 50.0ms (1.8% of total)
exact: 48.0ms (1.7% of total)
ival-true: 32.0ms (1.2% of total)
ival-pow2: 24.0ms (0.9% of total)
ival-sub: 21.0ms (0.8% of total)
ival-assert: 16.0ms (0.6% of total)
adjust: 0.0ms (0% of total)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...