math.sqrt on complex, real part

Time bar (total: 10.9s)

start0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

analyze88.0ms (0.8%)

Memory
14.0MiB live, 171.2MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.9%0.1%0%0%0%0
0%0%99.9%0.1%0%0%0%1
50%50%50%0.1%0%0%0%2
50%50%50%0.1%0%0%0%3
50%50%50%0.1%0%0%0%4
62.5%62.4%37.5%0.1%0%0%0%5
62.5%62.4%37.5%0.1%0%0%0%6
68.8%68.7%31.2%0.1%0%0%0%7
68.8%68.7%31.2%0.1%0%0%0%8
71.9%71.8%28.1%0.1%0%0%0%9
71.9%71.8%28.1%0.1%0%0%0%10
73.4%73.4%26.5%0.1%0%0%0%11
73.4%73.4%26.5%0.1%0%0%0%12
Compiler

Compiled 17 to 11 computations (35.3% saved)

sample1.1s (10.6%)

Memory
24.5MiB live, 2 067.4MiB allocated
Samples
442.0ms6 244×0valid
160.0ms788×2valid
127.0ms442×3valid
119.0ms782×1valid
Precisions
Click to see histograms. Total time spent on operations: 621.0ms
ival-hypot: 261.0ms (42% of total)
ival-mult: 146.0ms (23.5% of total)
ival-sqrt: 96.0ms (15.5% of total)
ival-add: 62.0ms (10% of total)
adjust: 39.0ms (6.3% of total)
exact: 8.0ms (1.3% of total)
ival-true: 6.0ms (1% of total)
ival-assert: 4.0ms (0.6% of total)
Bogosity

explain183.0ms (1.7%)

Memory
33.9MiB live, 354.3MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1280-1(-4.60477997019705e-162 6.148607321872036e-177)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
370-0-(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
341(-1.1881580064182035e+135 -1.0764851593373744e-255)0-(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 re re)
00-0-im
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-#s(literal 2 binary64)
00-0-(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
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-rescue1140
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow114
↳(*.f64 re re)overflow71
↳(*.f64 im im)overflow65
+.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-rescue350
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow13
↳(*.f64 im im)underflow60
↳(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))underflow5
↳(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))underflow40
↳(*.f64 re re)underflow49
↳(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)underflow40
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue130
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow13
↳(*.f64 re re)underflow49
↳(*.f64 im im)underflow60
Confusion
Predicted +Predicted -
+1660
-189
Precision
0.9940119760479041
Recall
1.0
Confusion?
Predicted +Predicted MaybePredicted -
+16600
-1089
Precision?
0.9940119760479041
Recall?
1.0
Freqs
test
numberfreq
089
1135
232
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
36.0ms358×0valid
15.0ms58×2valid
15.0ms42×3valid
10.0ms54×1valid
Compiler

Compiled 171 to 40 computations (76.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 54.0ms
ival-hypot: 18.0ms (33.2% of total)
ival-mult: 18.0ms (33.2% of total)
ival-add: 7.0ms (12.9% of total)
ival-sqrt: 6.0ms (11.1% of total)
adjust: 5.0ms (9.2% of total)
exact: 1.0ms (1.8% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

preprocess32.0ms (0.3%)

Memory
-19.5MiB live, 58.1MiB allocated
Algorithm
1×egg-herbie
Rules
120×distribute-rgt-in
112×sub-neg
84×distribute-lft-in
82×unsub-neg
78×distribute-lft-neg-in
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03075
19475
216975
325975
439675
552375
664575
774575
877375
01215
02015
13015
23215
03210
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 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
Symmetry

(abs im)

Samples
0.0ms1×2valid
0.0ms1×0valid
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-assert: 0.0ms (0% of total)
ival-sub: 0.0ms (0% of total)
ival-sqrt: 0.0ms (0% of total)
ival-add: 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.8MiB live, 1.8MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶38.3%
(*.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)

simplify324.0ms (3%)

Memory
-14.3MiB live, 637.3MiB 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
20×lower-*.f32
12×lower-*.f64
12×lower-fma.f64
12×lower-fma.f32
12×lower-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01275
02075
13075
23275
03249
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 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
#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 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
(*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
#s(literal 2 binary64)
(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
(+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(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
154.0ms3 211×0valid
1.0ms5×2valid
Compiler

Compiled 28 136 to 18 413 computations (34.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 84.0ms
ival-hypot: 34.0ms (40.3% of total)
ival-mult: 30.0ms (35.6% of total)
ival-sqrt: 9.0ms (10.7% of total)
ival-add: 6.0ms (7.1% of total)
ival-true: 3.0ms (3.6% of total)
ival-assert: 1.0ms (1.2% of total)
ival-sub: 1.0ms (1.2% of total)
exact: 1.0ms (1.2% of total)
adjust: 0.0ms (0% of total)

localize59.0ms (0.5%)

Memory
-4.5MiB live, 73.4MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0.00390625
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
accuracy7.837621545782454
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
accuracy8.798883573292224
(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
accuracy29.627433369614756
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
22.0ms179×0valid
8.0ms21×3valid
7.0ms29×2valid
5.0ms27×1valid
Compiler

Compiled 77 to 14 computations (81.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 31.0ms
ival-mult: 13.0ms (42.6% of total)
ival-hypot: 8.0ms (26.2% of total)
ival-sqrt: 3.0ms (9.8% of total)
ival-add: 3.0ms (9.8% of total)
adjust: 2.0ms (6.6% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series21.0ms (0.2%)

Memory
29.4MiB live, 29.4MiB 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/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 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))) (* 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 (* (sqrt re) (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 (* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (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 (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (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 (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (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) (* (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 -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (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 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (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 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (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) (pow (sqrt 2) 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/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 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 re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3))))))) (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 re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 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 (* 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/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 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/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 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 (* -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/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 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 (/ (+ (* 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/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (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 (* (sqrt re) (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 (* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (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 (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (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 (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (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) (* (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 -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (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 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (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 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (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 (* (sqrt re) (pow (sqrt 2) 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 (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 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 re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3))))))) (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 re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 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 (* (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/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 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/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 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 (* -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/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 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 (/ (+ (* 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 im) (* 2 re)) (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 (+ 2 (/ re 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 (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 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 (* 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 (* 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 (* 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 (* 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 (* -1 (/ (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/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 (/ (+ (* -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 (/ (+ (* 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 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 (+ (* 4 re) (/ (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 (+ (* 4 re) (* (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 (+ (* 4 re) (* (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 (* 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 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 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 (* -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 (/ (+ (* -1 (/ (pow re 2) im)) (* 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 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 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 (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 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 (* 1/2 (/ re 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 (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 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 (* 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 (* 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 (* 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 (* 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 -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 (/ (+ (* -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 (/ (+ (* -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 (/ (+ (* -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 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 (+ (* 1/2 (/ (pow im 2) re)) (* 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 (+ (* 2 re) (* (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 (+ (* 2 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 (+.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 (/ 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 (* -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 (/ (+ re (* -1/2 (/ (pow re 2) im))) 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 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) 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
re
@-inf
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
1.0ms
im
@0
(* 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
re
@inf
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
1.0ms
re
@0
(* 2 (+ (sqrt (+ (* re re) (* im im))) re))

simplify9.0s (82.9%)

Memory
213.0MiB live, 14 574.0MiB allocated
Algorithm
1×egg-herbie
Rules
10 342×lower-fma.f64
10 342×lower-fma.f32
7 766×lower-*.f64
7 766×lower-*.f32
2 698×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05003104
116592919
259062897
080792716
Stop Event
1×iter limit
1×node limit
Samples
2.5s30 592×0valid
984.0ms6 275×0invalid
Compiler

Compiled 935 978 to 610 444 computations (34.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 2.5s
ival-mult: 1.1s (46.4% of total)
ival-div: 409.0ms (16.5% of total)
ival-sqrt: 311.0ms (12.6% of total)
ival-add: 243.0ms (9.8% of total)
ival-pow: 201.0ms (8.1% of total)
exact: 45.0ms (1.8% of total)
ival-neg: 42.0ms (1.7% of total)
ival-true: 32.0ms (1.3% of total)
ival-assert: 18.0ms (0.7% of total)
ival-pow2: 18.0ms (0.7% of total)
ival-sub: 7.0ms (0.3% of total)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...