
(FPCore (x y z)
:precision binary64
(/
(*
(- x 2.0)
(+
(*
(+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y)
x)
z))
(+
(* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x)
47.066876606)))
double code(double x, double y, double z) {
return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((x - 2.0d0) * ((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
end function
public static double code(double x, double y, double z) {
return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}
def code(x, y, z): return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)
function code(x, y, z) return Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) end
function tmp = code(x, y, z) tmp = ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606); end
code[x_, y_, z_] := N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 24 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z)
:precision binary64
(/
(*
(- x 2.0)
(+
(*
(+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y)
x)
z))
(+
(* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x)
47.066876606)))
double code(double x, double y, double z) {
return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((x - 2.0d0) * ((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
end function
public static double code(double x, double y, double z) {
return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}
def code(x, y, z): return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)
function code(x, y, z) return Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) end
function tmp = code(x, y, z) tmp = ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606); end
code[x_, y_, z_] := N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606}
\end{array}
(FPCore (x y z)
:precision binary64
(let* ((t_0
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228))))))))
(t_1
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721))))))
(t_2 (/ z t_1)))
(if (<= (/ (* (- x 2.0) (+ t_0 z)) t_1) 5e+274)
(* (+ x -2.0) (+ t_2 (/ t_0 t_1)))
(*
(+ x -2.0)
(*
y
(-
(/ x t_1)
(/
(-
(-
(/
(-
101.7851458539211
(/ (+ 3451.550173699799 (/ -124074.40615218398 x)) x))
x)
4.16438922228)
t_2)
y)))))))
double code(double x, double y, double z) {
double t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))));
double t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_2 = z / t_1;
double tmp;
if ((((x - 2.0) * (t_0 + z)) / t_1) <= 5e+274) {
tmp = (x + -2.0) * (t_2 + (t_0 / t_1));
} else {
tmp = (x + -2.0) * (y * ((x / t_1) - (((((101.7851458539211 - ((3451.550173699799 + (-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - t_2) / y)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = x * (y + (x * (137.519416416d0 + (x * (78.6994924154d0 + (x * 4.16438922228d0))))))
t_1 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
t_2 = z / t_1
if ((((x - 2.0d0) * (t_0 + z)) / t_1) <= 5d+274) then
tmp = (x + (-2.0d0)) * (t_2 + (t_0 / t_1))
else
tmp = (x + (-2.0d0)) * (y * ((x / t_1) - (((((101.7851458539211d0 - ((3451.550173699799d0 + ((-124074.40615218398d0) / x)) / x)) / x) - 4.16438922228d0) - t_2) / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))));
double t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_2 = z / t_1;
double tmp;
if ((((x - 2.0) * (t_0 + z)) / t_1) <= 5e+274) {
tmp = (x + -2.0) * (t_2 + (t_0 / t_1));
} else {
tmp = (x + -2.0) * (y * ((x / t_1) - (((((101.7851458539211 - ((3451.550173699799 + (-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - t_2) / y)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228)))))) t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) t_2 = z / t_1 tmp = 0 if (((x - 2.0) * (t_0 + z)) / t_1) <= 5e+274: tmp = (x + -2.0) * (t_2 + (t_0 / t_1)) else: tmp = (x + -2.0) * (y * ((x / t_1) - (((((101.7851458539211 - ((3451.550173699799 + (-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - t_2) / y))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) t_1 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) t_2 = Float64(z / t_1) tmp = 0.0 if (Float64(Float64(Float64(x - 2.0) * Float64(t_0 + z)) / t_1) <= 5e+274) tmp = Float64(Float64(x + -2.0) * Float64(t_2 + Float64(t_0 / t_1))); else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / t_1) - Float64(Float64(Float64(Float64(Float64(101.7851458539211 - Float64(Float64(3451.550173699799 + Float64(-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - t_2) / y)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228)))))); t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); t_2 = z / t_1; tmp = 0.0; if ((((x - 2.0) * (t_0 + z)) / t_1) <= 5e+274) tmp = (x + -2.0) * (t_2 + (t_0 / t_1)); else tmp = (x + -2.0) * (y * ((x / t_1) - (((((101.7851458539211 - ((3451.550173699799 + (-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - t_2) / y))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z / t$95$1), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(t$95$0 + z), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], 5e+274], N[(N[(x + -2.0), $MachinePrecision] * N[(t$95$2 + N[(t$95$0 / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / t$95$1), $MachinePrecision] - N[(N[(N[(N[(N[(101.7851458539211 - N[(N[(3451.550173699799 + N[(-124074.40615218398 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - 4.16438922228), $MachinePrecision] - t$95$2), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right)\\
t_1 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
t_2 := \frac{z}{t\_1}\\
\mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(t\_0 + z\right)}{t\_1} \leq 5 \cdot 10^{+274}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(t\_2 + \frac{t\_0}{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{t\_1} - \frac{\left(\frac{101.7851458539211 - \frac{3451.550173699799 + \frac{-124074.40615218398}{x}}{x}}{x} - 4.16438922228\right) - t\_2}{y}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 4.9999999999999998e274Initial program 93.3%
associate-/l*98.9%
sub-neg98.9%
metadata-eval98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
Simplified98.9%
Taylor expanded in z around 0 98.9%
if 4.9999999999999998e274 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) Initial program 1.2%
associate-/l*4.8%
sub-neg4.8%
metadata-eval4.8%
fma-define4.8%
fma-define4.8%
fma-define4.8%
fma-define4.8%
fma-define4.8%
fma-define4.8%
fma-define4.8%
Simplified4.8%
Taylor expanded in y around -inf 5.8%
Taylor expanded in x around -inf 98.3%
mul-1-neg98.3%
unsub-neg98.3%
mul-1-neg98.3%
unsub-neg98.3%
sub-neg98.3%
associate-*r/98.3%
metadata-eval98.3%
distribute-neg-frac98.3%
metadata-eval98.3%
Simplified98.3%
Final simplification98.7%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))
(if (<=
(/
(*
(- x 2.0)
(+
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))))
z))
t_0)
2e+268)
(*
(+ x -2.0)
(/
(fma
(fma (fma (fma x 4.16438922228 78.6994924154) x 137.519416416) x y)
x
z)
(fma
(fma (fma (+ x 43.3400022514) x 263.505074721) x 313.399215894)
x
47.066876606)))
(*
(+ x -2.0)
(*
y
(-
(/ x t_0)
(/
(-
(-
(/
(-
101.7851458539211
(/ (+ 3451.550173699799 (/ -124074.40615218398 x)) x))
x)
4.16438922228)
(/ z t_0))
y)))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if ((((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / t_0) <= 2e+268) {
tmp = (x + -2.0) * (fma(fma(fma(fma(x, 4.16438922228, 78.6994924154), x, 137.519416416), x, y), x, z) / fma(fma(fma((x + 43.3400022514), x, 263.505074721), x, 313.399215894), x, 47.066876606));
} else {
tmp = (x + -2.0) * (y * ((x / t_0) - (((((101.7851458539211 - ((3451.550173699799 + (-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - (z / t_0)) / y)));
}
return tmp;
}
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) tmp = 0.0 if (Float64(Float64(Float64(x - 2.0) * Float64(Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) + z)) / t_0) <= 2e+268) tmp = Float64(Float64(x + -2.0) * Float64(fma(fma(fma(fma(x, 4.16438922228, 78.6994924154), x, 137.519416416), x, y), x, z) / fma(fma(fma(Float64(x + 43.3400022514), x, 263.505074721), x, 313.399215894), x, 47.066876606))); else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / t_0) - Float64(Float64(Float64(Float64(Float64(101.7851458539211 - Float64(Float64(3451.550173699799 + Float64(-124074.40615218398 / x)) / x)) / x) - 4.16438922228) - Float64(z / t_0)) / y)))); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], 2e+268], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(N[(N[(N[(x * 4.16438922228 + 78.6994924154), $MachinePrecision] * x + 137.519416416), $MachinePrecision] * x + y), $MachinePrecision] * x + z), $MachinePrecision] / N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x + 263.505074721), $MachinePrecision] * x + 313.399215894), $MachinePrecision] * x + 47.066876606), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / t$95$0), $MachinePrecision] - N[(N[(N[(N[(N[(101.7851458539211 - N[(N[(3451.550173699799 + N[(-124074.40615218398 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - 4.16438922228), $MachinePrecision] - N[(z / t$95$0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
\mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right) + z\right)}{t\_0} \leq 2 \cdot 10^{+268}:\\
\;\;\;\;\left(x + -2\right) \cdot \frac{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(x, 4.16438922228, 78.6994924154\right), x, 137.519416416\right), x, y\right), x, z\right)}{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(x + 43.3400022514, x, 263.505074721\right), x, 313.399215894\right), x, 47.066876606\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{t\_0} - \frac{\left(\frac{101.7851458539211 - \frac{3451.550173699799 + \frac{-124074.40615218398}{x}}{x}}{x} - 4.16438922228\right) - \frac{z}{t\_0}}{y}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 1.9999999999999999e268Initial program 93.1%
associate-/l*98.9%
sub-neg98.9%
metadata-eval98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
Simplified98.9%
if 1.9999999999999999e268 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) Initial program 4.0%
associate-/l*7.5%
sub-neg7.5%
metadata-eval7.5%
fma-define7.5%
fma-define7.5%
fma-define7.5%
fma-define7.5%
fma-define7.5%
fma-define7.5%
fma-define7.5%
Simplified7.5%
Taylor expanded in y around -inf 7.5%
Taylor expanded in x around -inf 97.5%
mul-1-neg97.5%
unsub-neg97.5%
mul-1-neg97.5%
unsub-neg97.5%
sub-neg97.5%
associate-*r/97.5%
metadata-eval97.5%
distribute-neg-frac97.5%
metadata-eval97.5%
Simplified97.5%
Final simplification98.3%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (* x (+ x 43.3400022514)) 263.505074721)))
(t_1
(/
(*
(- x 2.0)
(+
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))))
z))
(+ 47.066876606 (* x (+ 313.399215894 t_0))))))
(if (<= t_1 (- INFINITY))
(*
x
(-
(/ (+ -110.1139242984811 (/ (- (/ y x) -3655.1204654076414) x)) x)
-4.16438922228))
(if (<= t_1 1e+263)
t_1
(*
(+ x -2.0)
(*
y
(+
(/ x (+ 47.066876606 (+ (* x 313.399215894) (* x t_0))))
(/ 4.16438922228 y))))))))
double code(double x, double y, double z) {
double t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721);
double t_1 = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + t_0)));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (t_1 <= 1e+263) {
tmp = t_1;
} else {
tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y)));
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721);
double t_1 = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + t_0)));
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (t_1 <= 1e+263) {
tmp = t_1;
} else {
tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y)));
}
return tmp;
}
def code(x, y, z): t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721) t_1 = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + t_0))) tmp = 0 if t_1 <= -math.inf: tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228) elif t_1 <= 1e+263: tmp = t_1 else: tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721)) t_1 = Float64(Float64(Float64(x - 2.0) * Float64(Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) + z)) / Float64(47.066876606 + Float64(x * Float64(313.399215894 + t_0)))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(x * Float64(Float64(Float64(-110.1139242984811 + Float64(Float64(Float64(y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228)); elseif (t_1 <= 1e+263) tmp = t_1; else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / Float64(47.066876606 + Float64(Float64(x * 313.399215894) + Float64(x * t_0)))) + Float64(4.16438922228 / y)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721); t_1 = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + t_0))); tmp = 0.0; if (t_1 <= -Inf) tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228); elseif (t_1 <= 1e+263) tmp = t_1; else tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(47.066876606 + N[(x * N[(313.399215894 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(x * N[(N[(N[(-110.1139242984811 + N[(N[(N[(y / x), $MachinePrecision] - -3655.1204654076414), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - -4.16438922228), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+263], t$95$1, N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / N[(47.066876606 + N[(N[(x * 313.399215894), $MachinePrecision] + N[(x * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.16438922228 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\\
t_1 := \frac{\left(x - 2\right) \cdot \left(x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right) + z\right)}{47.066876606 + x \cdot \left(313.399215894 + t\_0\right)}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;x \cdot \left(\frac{-110.1139242984811 + \frac{\frac{y}{x} - -3655.1204654076414}{x}}{x} - -4.16438922228\right)\\
\mathbf{elif}\;t\_1 \leq 10^{+263}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{47.066876606 + \left(x \cdot 313.399215894 + x \cdot t\_0\right)} + \frac{4.16438922228}{y}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < -inf.0Initial program 4.4%
associate-/l*89.9%
sub-neg89.9%
metadata-eval89.9%
fma-define89.9%
fma-define89.9%
fma-define89.9%
fma-define89.9%
fma-define89.9%
fma-define89.9%
fma-define89.9%
Simplified89.9%
Taylor expanded in z around 0 4.4%
Taylor expanded in x around -inf 72.0%
Simplified72.0%
Taylor expanded in y around inf 72.0%
if -inf.0 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 1.00000000000000002e263Initial program 99.6%
if 1.00000000000000002e263 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) Initial program 4.9%
associate-/l*8.3%
sub-neg8.3%
metadata-eval8.3%
fma-define8.3%
fma-define8.3%
fma-define8.3%
fma-define8.3%
fma-define8.3%
fma-define8.3%
fma-define8.3%
Simplified8.3%
Taylor expanded in y around -inf 7.5%
Taylor expanded in x around -inf 96.7%
mul-1-neg96.7%
unsub-neg96.7%
mul-1-neg96.7%
unsub-neg96.7%
sub-neg96.7%
associate-*r/96.7%
metadata-eval96.7%
distribute-neg-frac96.7%
metadata-eval96.7%
Simplified96.7%
Taylor expanded in x around inf 95.6%
distribute-lft-in95.7%
+-commutative95.7%
fma-define95.7%
+-commutative95.7%
Applied egg-rr95.7%
Taylor expanded in x around 0 95.7%
Final simplification96.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228))))))))
(t_1
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721))))))
(t_2 (/ z t_1)))
(if (<= (/ (* (- x 2.0) (+ t_0 z)) t_1) 2e+270)
(* (+ x -2.0) (+ t_2 (/ t_0 t_1)))
(* (+ x -2.0) (+ 4.16438922228 t_2)))))
double code(double x, double y, double z) {
double t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))));
double t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_2 = z / t_1;
double tmp;
if ((((x - 2.0) * (t_0 + z)) / t_1) <= 2e+270) {
tmp = (x + -2.0) * (t_2 + (t_0 / t_1));
} else {
tmp = (x + -2.0) * (4.16438922228 + t_2);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = x * (y + (x * (137.519416416d0 + (x * (78.6994924154d0 + (x * 4.16438922228d0))))))
t_1 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
t_2 = z / t_1
if ((((x - 2.0d0) * (t_0 + z)) / t_1) <= 2d+270) then
tmp = (x + (-2.0d0)) * (t_2 + (t_0 / t_1))
else
tmp = (x + (-2.0d0)) * (4.16438922228d0 + t_2)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))));
double t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_2 = z / t_1;
double tmp;
if ((((x - 2.0) * (t_0 + z)) / t_1) <= 2e+270) {
tmp = (x + -2.0) * (t_2 + (t_0 / t_1));
} else {
tmp = (x + -2.0) * (4.16438922228 + t_2);
}
return tmp;
}
def code(x, y, z): t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228)))))) t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) t_2 = z / t_1 tmp = 0 if (((x - 2.0) * (t_0 + z)) / t_1) <= 2e+270: tmp = (x + -2.0) * (t_2 + (t_0 / t_1)) else: tmp = (x + -2.0) * (4.16438922228 + t_2) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) t_1 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) t_2 = Float64(z / t_1) tmp = 0.0 if (Float64(Float64(Float64(x - 2.0) * Float64(t_0 + z)) / t_1) <= 2e+270) tmp = Float64(Float64(x + -2.0) * Float64(t_2 + Float64(t_0 / t_1))); else tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + t_2)); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228)))))); t_1 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); t_2 = z / t_1; tmp = 0.0; if ((((x - 2.0) * (t_0 + z)) / t_1) <= 2e+270) tmp = (x + -2.0) * (t_2 + (t_0 / t_1)); else tmp = (x + -2.0) * (4.16438922228 + t_2); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z / t$95$1), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(t$95$0 + z), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], 2e+270], N[(N[(x + -2.0), $MachinePrecision] * N[(t$95$2 + N[(t$95$0 / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + t$95$2), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right)\\
t_1 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
t_2 := \frac{z}{t\_1}\\
\mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(t\_0 + z\right)}{t\_1} \leq 2 \cdot 10^{+270}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(t\_2 + \frac{t\_0}{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + t\_2\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 2.0000000000000001e270Initial program 93.2%
associate-/l*98.9%
sub-neg98.9%
metadata-eval98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
fma-define98.9%
Simplified98.9%
Taylor expanded in z around 0 98.9%
if 2.0000000000000001e270 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) Initial program 2.2%
associate-/l*5.7%
sub-neg5.7%
metadata-eval5.7%
fma-define5.7%
fma-define5.7%
fma-define5.7%
fma-define5.7%
fma-define5.7%
fma-define5.7%
fma-define5.7%
Simplified5.7%
Taylor expanded in z around 0 5.7%
Taylor expanded in x around inf 97.3%
Final simplification98.2%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (* x (+ x 43.3400022514)) 263.505074721)))
(t_1 (+ 47.066876606 (* x (+ 313.399215894 t_0)))))
(if (<= x -1.7e+25)
(* (+ x -2.0) (+ 4.16438922228 (/ z t_1)))
(if (<= x -2e-29)
(/ (* (- x 2.0) (+ z (* x (+ y (* x 137.519416416))))) t_1)
(if (<= x 0.0195)
(/
(*
(- x 2.0)
(+
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))))
z))
(+ 47.066876606 (* x (+ 313.399215894 (* x 263.505074721)))))
(*
(+ x -2.0)
(*
y
(+
(/ x (+ 47.066876606 (+ (* x 313.399215894) (* x t_0))))
(/ 4.16438922228 y)))))))))
double code(double x, double y, double z) {
double t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721);
double t_1 = 47.066876606 + (x * (313.399215894 + t_0));
double tmp;
if (x <= -1.7e+25) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_1));
} else if (x <= -2e-29) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_1;
} else if (x <= 0.0195) {
tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721))));
} else {
tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = x * ((x * (x + 43.3400022514d0)) + 263.505074721d0)
t_1 = 47.066876606d0 + (x * (313.399215894d0 + t_0))
if (x <= (-1.7d+25)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + (z / t_1))
else if (x <= (-2d-29)) then
tmp = ((x - 2.0d0) * (z + (x * (y + (x * 137.519416416d0))))) / t_1
else if (x <= 0.0195d0) then
tmp = ((x - 2.0d0) * ((x * (y + (x * (137.519416416d0 + (x * (78.6994924154d0 + (x * 4.16438922228d0))))))) + z)) / (47.066876606d0 + (x * (313.399215894d0 + (x * 263.505074721d0))))
else
tmp = (x + (-2.0d0)) * (y * ((x / (47.066876606d0 + ((x * 313.399215894d0) + (x * t_0)))) + (4.16438922228d0 / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721);
double t_1 = 47.066876606 + (x * (313.399215894 + t_0));
double tmp;
if (x <= -1.7e+25) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_1));
} else if (x <= -2e-29) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_1;
} else if (x <= 0.0195) {
tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721))));
} else {
tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y)));
}
return tmp;
}
def code(x, y, z): t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721) t_1 = 47.066876606 + (x * (313.399215894 + t_0)) tmp = 0 if x <= -1.7e+25: tmp = (x + -2.0) * (4.16438922228 + (z / t_1)) elif x <= -2e-29: tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_1 elif x <= 0.0195: tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721)))) else: tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721)) t_1 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + t_0))) tmp = 0.0 if (x <= -1.7e+25) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(z / t_1))); elseif (x <= -2e-29) tmp = Float64(Float64(Float64(x - 2.0) * Float64(z + Float64(x * Float64(y + Float64(x * 137.519416416))))) / t_1); elseif (x <= 0.0195) tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) + z)) / Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * 263.505074721))))); else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / Float64(47.066876606 + Float64(Float64(x * 313.399215894) + Float64(x * t_0)))) + Float64(4.16438922228 / y)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * ((x * (x + 43.3400022514)) + 263.505074721); t_1 = 47.066876606 + (x * (313.399215894 + t_0)); tmp = 0.0; if (x <= -1.7e+25) tmp = (x + -2.0) * (4.16438922228 + (z / t_1)); elseif (x <= -2e-29) tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_1; elseif (x <= 0.0195) tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721)))); else tmp = (x + -2.0) * (y * ((x / (47.066876606 + ((x * 313.399215894) + (x * t_0)))) + (4.16438922228 / y))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(47.066876606 + N[(x * N[(313.399215894 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.7e+25], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(z / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2e-29], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(z + N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[x, 0.0195], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / N[(47.066876606 + N[(N[(x * 313.399215894), $MachinePrecision] + N[(x * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.16438922228 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\\
t_1 := 47.066876606 + x \cdot \left(313.399215894 + t\_0\right)\\
\mathbf{if}\;x \leq -1.7 \cdot 10^{+25}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{z}{t\_1}\right)\\
\mathbf{elif}\;x \leq -2 \cdot 10^{-29}:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(z + x \cdot \left(y + x \cdot 137.519416416\right)\right)}{t\_1}\\
\mathbf{elif}\;x \leq 0.0195:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right) + z\right)}{47.066876606 + x \cdot \left(313.399215894 + x \cdot 263.505074721\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{47.066876606 + \left(x \cdot 313.399215894 + x \cdot t\_0\right)} + \frac{4.16438922228}{y}\right)\right)\\
\end{array}
\end{array}
if x < -1.69999999999999992e25Initial program 15.1%
associate-/l*23.7%
sub-neg23.7%
metadata-eval23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
Simplified23.7%
Taylor expanded in z around 0 23.6%
Taylor expanded in x around inf 96.1%
if -1.69999999999999992e25 < x < -1.99999999999999989e-29Initial program 99.9%
Taylor expanded in x around 0 86.2%
*-commutative86.2%
Simplified86.2%
if -1.99999999999999989e-29 < x < 0.0195Initial program 99.6%
Taylor expanded in x around 0 99.6%
*-commutative99.6%
Simplified99.6%
if 0.0195 < x Initial program 8.8%
associate-/l*19.5%
sub-neg19.5%
metadata-eval19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
Simplified19.5%
Taylor expanded in y around -inf 24.0%
Taylor expanded in x around -inf 99.1%
mul-1-neg99.1%
unsub-neg99.1%
mul-1-neg99.1%
unsub-neg99.1%
sub-neg99.1%
associate-*r/99.1%
metadata-eval99.1%
distribute-neg-frac99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in x around inf 95.9%
distribute-lft-in95.9%
+-commutative95.9%
fma-define95.9%
+-commutative95.9%
Applied egg-rr95.9%
Taylor expanded in x around 0 95.9%
Final simplification97.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))
(if (<= x -3.2e+25)
(* (+ x -2.0) (+ 4.16438922228 (/ z t_0)))
(if (<= x -2e-29)
(/ (* (- x 2.0) (+ z (* x (+ y (* x 137.519416416))))) t_0)
(if (<= x 0.016)
(/
(*
(- x 2.0)
(+
(*
x
(+
y
(*
x
(+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))))
z))
(+ 47.066876606 (* x (+ 313.399215894 (* x 263.505074721)))))
(* (+ x -2.0) (* y (+ (/ x t_0) (/ 4.16438922228 y)))))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.2e+25) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= -2e-29) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else if (x <= 0.016) {
tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721))));
} else {
tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
if (x <= (-3.2d+25)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + (z / t_0))
else if (x <= (-2d-29)) then
tmp = ((x - 2.0d0) * (z + (x * (y + (x * 137.519416416d0))))) / t_0
else if (x <= 0.016d0) then
tmp = ((x - 2.0d0) * ((x * (y + (x * (137.519416416d0 + (x * (78.6994924154d0 + (x * 4.16438922228d0))))))) + z)) / (47.066876606d0 + (x * (313.399215894d0 + (x * 263.505074721d0))))
else
tmp = (x + (-2.0d0)) * (y * ((x / t_0) + (4.16438922228d0 / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.2e+25) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= -2e-29) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else if (x <= 0.016) {
tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721))));
} else {
tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y)));
}
return tmp;
}
def code(x, y, z): t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) tmp = 0 if x <= -3.2e+25: tmp = (x + -2.0) * (4.16438922228 + (z / t_0)) elif x <= -2e-29: tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0 elif x <= 0.016: tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721)))) else: tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y))) return tmp
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) tmp = 0.0 if (x <= -3.2e+25) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(z / t_0))); elseif (x <= -2e-29) tmp = Float64(Float64(Float64(x - 2.0) * Float64(z + Float64(x * Float64(y + Float64(x * 137.519416416))))) / t_0); elseif (x <= 0.016) tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(x * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))) + z)) / Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * 263.505074721))))); else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / t_0) + Float64(4.16438922228 / y)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); tmp = 0.0; if (x <= -3.2e+25) tmp = (x + -2.0) * (4.16438922228 + (z / t_0)); elseif (x <= -2e-29) tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0; elseif (x <= 0.016) tmp = ((x - 2.0) * ((x * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))) + z)) / (47.066876606 + (x * (313.399215894 + (x * 263.505074721)))); else tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.2e+25], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(z / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2e-29], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(z + N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[x, 0.016], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(x * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / t$95$0), $MachinePrecision] + N[(4.16438922228 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
\mathbf{if}\;x \leq -3.2 \cdot 10^{+25}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{z}{t\_0}\right)\\
\mathbf{elif}\;x \leq -2 \cdot 10^{-29}:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(z + x \cdot \left(y + x \cdot 137.519416416\right)\right)}{t\_0}\\
\mathbf{elif}\;x \leq 0.016:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(x \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right) + z\right)}{47.066876606 + x \cdot \left(313.399215894 + x \cdot 263.505074721\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{t\_0} + \frac{4.16438922228}{y}\right)\right)\\
\end{array}
\end{array}
if x < -3.1999999999999999e25Initial program 15.1%
associate-/l*23.7%
sub-neg23.7%
metadata-eval23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
fma-define23.7%
Simplified23.7%
Taylor expanded in z around 0 23.6%
Taylor expanded in x around inf 96.1%
if -3.1999999999999999e25 < x < -1.99999999999999989e-29Initial program 99.9%
Taylor expanded in x around 0 86.2%
*-commutative86.2%
Simplified86.2%
if -1.99999999999999989e-29 < x < 0.016Initial program 99.6%
Taylor expanded in x around 0 99.6%
*-commutative99.6%
Simplified99.6%
if 0.016 < x Initial program 8.8%
associate-/l*19.5%
sub-neg19.5%
metadata-eval19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
Simplified19.5%
Taylor expanded in y around -inf 24.0%
Taylor expanded in x around -inf 99.1%
mul-1-neg99.1%
unsub-neg99.1%
mul-1-neg99.1%
unsub-neg99.1%
sub-neg99.1%
associate-*r/99.1%
metadata-eval99.1%
distribute-neg-frac99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in x around inf 95.9%
Taylor expanded in y around inf 95.7%
Taylor expanded in y around 0 95.9%
Final simplification97.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721))))))
(t_1 (/ z t_0)))
(if (<= x -1.6e+19)
(* (+ x -2.0) (+ 4.16438922228 t_1))
(if (<= x -7.4e-24)
(/ (* x (* (- x 2.0) (+ y (* x 137.519416416)))) t_0)
(if (<= x 9.5e-15)
(* (+ x -2.0) (+ t_1 (* 0.0212463641547976 (* x y))))
(*
x
(+
4.16438922228
(/
(+
-110.1139242984811
(/ (+ 3655.1204654076414 (/ (+ y -130977.50649958357) x)) x))
x))))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_1 = z / t_0;
double tmp;
if (x <= -1.6e+19) {
tmp = (x + -2.0) * (4.16438922228 + t_1);
} else if (x <= -7.4e-24) {
tmp = (x * ((x - 2.0) * (y + (x * 137.519416416)))) / t_0;
} else if (x <= 9.5e-15) {
tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y)));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
t_1 = z / t_0
if (x <= (-1.6d+19)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + t_1)
else if (x <= (-7.4d-24)) then
tmp = (x * ((x - 2.0d0) * (y + (x * 137.519416416d0)))) / t_0
else if (x <= 9.5d-15) then
tmp = (x + (-2.0d0)) * (t_1 + (0.0212463641547976d0 * (x * y)))
else
tmp = x * (4.16438922228d0 + (((-110.1139242984811d0) + ((3655.1204654076414d0 + ((y + (-130977.50649958357d0)) / x)) / x)) / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_1 = z / t_0;
double tmp;
if (x <= -1.6e+19) {
tmp = (x + -2.0) * (4.16438922228 + t_1);
} else if (x <= -7.4e-24) {
tmp = (x * ((x - 2.0) * (y + (x * 137.519416416)))) / t_0;
} else if (x <= 9.5e-15) {
tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y)));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
def code(x, y, z): t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) t_1 = z / t_0 tmp = 0 if x <= -1.6e+19: tmp = (x + -2.0) * (4.16438922228 + t_1) elif x <= -7.4e-24: tmp = (x * ((x - 2.0) * (y + (x * 137.519416416)))) / t_0 elif x <= 9.5e-15: tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y))) else: tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)) return tmp
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) t_1 = Float64(z / t_0) tmp = 0.0 if (x <= -1.6e+19) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + t_1)); elseif (x <= -7.4e-24) tmp = Float64(Float64(x * Float64(Float64(x - 2.0) * Float64(y + Float64(x * 137.519416416)))) / t_0); elseif (x <= 9.5e-15) tmp = Float64(Float64(x + -2.0) * Float64(t_1 + Float64(0.0212463641547976 * Float64(x * y)))); else tmp = Float64(x * Float64(4.16438922228 + Float64(Float64(-110.1139242984811 + Float64(Float64(3655.1204654076414 + Float64(Float64(y + -130977.50649958357) / x)) / x)) / x))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); t_1 = z / t_0; tmp = 0.0; if (x <= -1.6e+19) tmp = (x + -2.0) * (4.16438922228 + t_1); elseif (x <= -7.4e-24) tmp = (x * ((x - 2.0) * (y + (x * 137.519416416)))) / t_0; elseif (x <= 9.5e-15) tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y))); else tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(z / t$95$0), $MachinePrecision]}, If[LessEqual[x, -1.6e+19], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.4e-24], N[(N[(x * N[(N[(x - 2.0), $MachinePrecision] * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[x, 9.5e-15], N[(N[(x + -2.0), $MachinePrecision] * N[(t$95$1 + N[(0.0212463641547976 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 + N[(N[(-110.1139242984811 + N[(N[(3655.1204654076414 + N[(N[(y + -130977.50649958357), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
t_1 := \frac{z}{t\_0}\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+19}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + t\_1\right)\\
\mathbf{elif}\;x \leq -7.4 \cdot 10^{-24}:\\
\;\;\;\;\frac{x \cdot \left(\left(x - 2\right) \cdot \left(y + x \cdot 137.519416416\right)\right)}{t\_0}\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{-15}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(t\_1 + 0.0212463641547976 \cdot \left(x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811 + \frac{3655.1204654076414 + \frac{y + -130977.50649958357}{x}}{x}}{x}\right)\\
\end{array}
\end{array}
if x < -1.6e19Initial program 16.4%
associate-/l*24.8%
sub-neg24.8%
metadata-eval24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
Simplified24.8%
Taylor expanded in z around 0 24.7%
Taylor expanded in x around inf 96.2%
if -1.6e19 < x < -7.39999999999999962e-24Initial program 99.9%
associate-/l*99.4%
sub-neg99.4%
metadata-eval99.4%
fma-define99.4%
fma-define99.4%
fma-define99.4%
fma-define99.4%
fma-define99.3%
fma-define99.3%
fma-define99.3%
Simplified99.3%
Taylor expanded in z around 0 85.2%
Taylor expanded in x around 0 69.0%
*-commutative69.0%
Simplified69.0%
if -7.39999999999999962e-24 < x < 9.5000000000000005e-15Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in z around 0 99.6%
Taylor expanded in x around 0 96.2%
if 9.5000000000000005e-15 < x Initial program 15.6%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
Simplified25.5%
Taylor expanded in z around 0 11.1%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Final simplification93.0%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721))))))
(t_1 (/ z t_0)))
(if (<= x -1.6e+19)
(* (+ x -2.0) (+ 4.16438922228 t_1))
(if (<= x -7.4e-24)
(* (+ x -2.0) (/ (* x (+ y (* x 137.519416416))) t_0))
(if (<= x 9.5e-15)
(* (+ x -2.0) (+ t_1 (* 0.0212463641547976 (* x y))))
(*
x
(+
4.16438922228
(/
(+
-110.1139242984811
(/ (+ 3655.1204654076414 (/ (+ y -130977.50649958357) x)) x))
x))))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_1 = z / t_0;
double tmp;
if (x <= -1.6e+19) {
tmp = (x + -2.0) * (4.16438922228 + t_1);
} else if (x <= -7.4e-24) {
tmp = (x + -2.0) * ((x * (y + (x * 137.519416416))) / t_0);
} else if (x <= 9.5e-15) {
tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y)));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
t_1 = z / t_0
if (x <= (-1.6d+19)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + t_1)
else if (x <= (-7.4d-24)) then
tmp = (x + (-2.0d0)) * ((x * (y + (x * 137.519416416d0))) / t_0)
else if (x <= 9.5d-15) then
tmp = (x + (-2.0d0)) * (t_1 + (0.0212463641547976d0 * (x * y)))
else
tmp = x * (4.16438922228d0 + (((-110.1139242984811d0) + ((3655.1204654076414d0 + ((y + (-130977.50649958357d0)) / x)) / x)) / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double t_1 = z / t_0;
double tmp;
if (x <= -1.6e+19) {
tmp = (x + -2.0) * (4.16438922228 + t_1);
} else if (x <= -7.4e-24) {
tmp = (x + -2.0) * ((x * (y + (x * 137.519416416))) / t_0);
} else if (x <= 9.5e-15) {
tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y)));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
def code(x, y, z): t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) t_1 = z / t_0 tmp = 0 if x <= -1.6e+19: tmp = (x + -2.0) * (4.16438922228 + t_1) elif x <= -7.4e-24: tmp = (x + -2.0) * ((x * (y + (x * 137.519416416))) / t_0) elif x <= 9.5e-15: tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y))) else: tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)) return tmp
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) t_1 = Float64(z / t_0) tmp = 0.0 if (x <= -1.6e+19) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + t_1)); elseif (x <= -7.4e-24) tmp = Float64(Float64(x + -2.0) * Float64(Float64(x * Float64(y + Float64(x * 137.519416416))) / t_0)); elseif (x <= 9.5e-15) tmp = Float64(Float64(x + -2.0) * Float64(t_1 + Float64(0.0212463641547976 * Float64(x * y)))); else tmp = Float64(x * Float64(4.16438922228 + Float64(Float64(-110.1139242984811 + Float64(Float64(3655.1204654076414 + Float64(Float64(y + -130977.50649958357) / x)) / x)) / x))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); t_1 = z / t_0; tmp = 0.0; if (x <= -1.6e+19) tmp = (x + -2.0) * (4.16438922228 + t_1); elseif (x <= -7.4e-24) tmp = (x + -2.0) * ((x * (y + (x * 137.519416416))) / t_0); elseif (x <= 9.5e-15) tmp = (x + -2.0) * (t_1 + (0.0212463641547976 * (x * y))); else tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(z / t$95$0), $MachinePrecision]}, If[LessEqual[x, -1.6e+19], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.4e-24], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.5e-15], N[(N[(x + -2.0), $MachinePrecision] * N[(t$95$1 + N[(0.0212463641547976 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 + N[(N[(-110.1139242984811 + N[(N[(3655.1204654076414 + N[(N[(y + -130977.50649958357), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
t_1 := \frac{z}{t\_0}\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+19}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + t\_1\right)\\
\mathbf{elif}\;x \leq -7.4 \cdot 10^{-24}:\\
\;\;\;\;\left(x + -2\right) \cdot \frac{x \cdot \left(y + x \cdot 137.519416416\right)}{t\_0}\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{-15}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(t\_1 + 0.0212463641547976 \cdot \left(x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811 + \frac{3655.1204654076414 + \frac{y + -130977.50649958357}{x}}{x}}{x}\right)\\
\end{array}
\end{array}
if x < -1.6e19Initial program 16.4%
associate-/l*24.8%
sub-neg24.8%
metadata-eval24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
fma-define24.8%
Simplified24.8%
Taylor expanded in z around 0 24.7%
Taylor expanded in x around inf 96.2%
if -1.6e19 < x < -7.39999999999999962e-24Initial program 99.9%
associate-/l*99.4%
sub-neg99.4%
metadata-eval99.4%
fma-define99.4%
fma-define99.4%
fma-define99.4%
fma-define99.4%
fma-define99.3%
fma-define99.3%
fma-define99.3%
Simplified99.3%
Taylor expanded in z around 0 84.7%
Taylor expanded in x around 0 68.7%
*-commutative69.0%
Simplified68.7%
if -7.39999999999999962e-24 < x < 9.5000000000000005e-15Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in z around 0 99.6%
Taylor expanded in x around 0 96.2%
if 9.5000000000000005e-15 < x Initial program 15.6%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
Simplified25.5%
Taylor expanded in z around 0 11.1%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Final simplification93.0%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))
(if (<= x -3.4e+43)
(* (+ x -2.0) (+ 4.16438922228 (/ z t_0)))
(if (<= x 5e-7)
(/ (* (- x 2.0) (+ z (* x (+ y (* x 137.519416416))))) t_0)
(* (+ x -2.0) (* y (+ (/ x t_0) (/ 4.16438922228 y))))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.4e+43) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= 5e-7) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else {
tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
if (x <= (-3.4d+43)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + (z / t_0))
else if (x <= 5d-7) then
tmp = ((x - 2.0d0) * (z + (x * (y + (x * 137.519416416d0))))) / t_0
else
tmp = (x + (-2.0d0)) * (y * ((x / t_0) + (4.16438922228d0 / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.4e+43) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= 5e-7) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else {
tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y)));
}
return tmp;
}
def code(x, y, z): t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) tmp = 0 if x <= -3.4e+43: tmp = (x + -2.0) * (4.16438922228 + (z / t_0)) elif x <= 5e-7: tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0 else: tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y))) return tmp
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) tmp = 0.0 if (x <= -3.4e+43) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(z / t_0))); elseif (x <= 5e-7) tmp = Float64(Float64(Float64(x - 2.0) * Float64(z + Float64(x * Float64(y + Float64(x * 137.519416416))))) / t_0); else tmp = Float64(Float64(x + -2.0) * Float64(y * Float64(Float64(x / t_0) + Float64(4.16438922228 / y)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); tmp = 0.0; if (x <= -3.4e+43) tmp = (x + -2.0) * (4.16438922228 + (z / t_0)); elseif (x <= 5e-7) tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0; else tmp = (x + -2.0) * (y * ((x / t_0) + (4.16438922228 / y))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.4e+43], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(z / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 5e-7], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(z + N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(y * N[(N[(x / t$95$0), $MachinePrecision] + N[(4.16438922228 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
\mathbf{if}\;x \leq -3.4 \cdot 10^{+43}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{z}{t\_0}\right)\\
\mathbf{elif}\;x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(z + x \cdot \left(y + x \cdot 137.519416416\right)\right)}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(y \cdot \left(\frac{x}{t\_0} + \frac{4.16438922228}{y}\right)\right)\\
\end{array}
\end{array}
if x < -3.40000000000000012e43Initial program 5.3%
associate-/l*14.8%
sub-neg14.8%
metadata-eval14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
Simplified14.8%
Taylor expanded in z around 0 14.8%
Taylor expanded in x around inf 97.3%
if -3.40000000000000012e43 < x < 4.99999999999999977e-7Initial program 99.6%
Taylor expanded in x around 0 94.8%
*-commutative94.8%
Simplified94.8%
if 4.99999999999999977e-7 < x Initial program 10.3%
associate-/l*20.8%
sub-neg20.8%
metadata-eval20.8%
fma-define20.8%
fma-define20.8%
fma-define20.8%
fma-define20.8%
fma-define20.8%
fma-define20.8%
fma-define20.8%
Simplified20.8%
Taylor expanded in y around -inf 25.2%
Taylor expanded in x around -inf 97.6%
mul-1-neg97.6%
unsub-neg97.6%
mul-1-neg97.6%
unsub-neg97.6%
sub-neg97.6%
associate-*r/97.6%
metadata-eval97.6%
distribute-neg-frac97.6%
metadata-eval97.6%
Simplified97.6%
Taylor expanded in x around inf 94.5%
Taylor expanded in y around inf 94.4%
Taylor expanded in y around 0 94.5%
Final simplification95.3%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))
(if (<= x -3.4e+43)
(* (+ x -2.0) (+ 4.16438922228 (/ z t_0)))
(if (<= x 580000.0)
(/ (* (- x 2.0) (+ z (* x (+ y (* x 137.519416416))))) t_0)
(*
(+ x -2.0)
(-
4.16438922228
(/
(+
101.7851458539211
(/ (- (/ (- 124074.40615218398 y) x) 3451.550173699799) x))
x)))))))
double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.4e+43) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= 580000.0) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else {
tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 + ((((124074.40615218398 - y) / x) - 3451.550173699799) / x)) / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0))))
if (x <= (-3.4d+43)) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + (z / t_0))
else if (x <= 580000.0d0) then
tmp = ((x - 2.0d0) * (z + (x * (y + (x * 137.519416416d0))))) / t_0
else
tmp = (x + (-2.0d0)) * (4.16438922228d0 - ((101.7851458539211d0 + ((((124074.40615218398d0 - y) / x) - 3451.550173699799d0) / x)) / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))));
double tmp;
if (x <= -3.4e+43) {
tmp = (x + -2.0) * (4.16438922228 + (z / t_0));
} else if (x <= 580000.0) {
tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0;
} else {
tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 + ((((124074.40615218398 - y) / x) - 3451.550173699799) / x)) / x));
}
return tmp;
}
def code(x, y, z): t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))) tmp = 0 if x <= -3.4e+43: tmp = (x + -2.0) * (4.16438922228 + (z / t_0)) elif x <= 580000.0: tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0 else: tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 + ((((124074.40615218398 - y) / x) - 3451.550173699799) / x)) / x)) return tmp
function code(x, y, z) t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721))))) tmp = 0.0 if (x <= -3.4e+43) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(z / t_0))); elseif (x <= 580000.0) tmp = Float64(Float64(Float64(x - 2.0) * Float64(z + Float64(x * Float64(y + Float64(x * 137.519416416))))) / t_0); else tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 - Float64(Float64(101.7851458539211 + Float64(Float64(Float64(Float64(124074.40615218398 - y) / x) - 3451.550173699799) / x)) / x))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = 47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))); tmp = 0.0; if (x <= -3.4e+43) tmp = (x + -2.0) * (4.16438922228 + (z / t_0)); elseif (x <= 580000.0) tmp = ((x - 2.0) * (z + (x * (y + (x * 137.519416416))))) / t_0; else tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 + ((((124074.40615218398 - y) / x) - 3451.550173699799) / x)) / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.4e+43], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(z / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 580000.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(z + N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 - N[(N[(101.7851458539211 + N[(N[(N[(N[(124074.40615218398 - y), $MachinePrecision] / x), $MachinePrecision] - 3451.550173699799), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)\\
\mathbf{if}\;x \leq -3.4 \cdot 10^{+43}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{z}{t\_0}\right)\\
\mathbf{elif}\;x \leq 580000:\\
\;\;\;\;\frac{\left(x - 2\right) \cdot \left(z + x \cdot \left(y + x \cdot 137.519416416\right)\right)}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 - \frac{101.7851458539211 + \frac{\frac{124074.40615218398 - y}{x} - 3451.550173699799}{x}}{x}\right)\\
\end{array}
\end{array}
if x < -3.40000000000000012e43Initial program 5.3%
associate-/l*14.8%
sub-neg14.8%
metadata-eval14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
fma-define14.8%
Simplified14.8%
Taylor expanded in z around 0 14.8%
Taylor expanded in x around inf 97.3%
if -3.40000000000000012e43 < x < 5.8e5Initial program 99.6%
Taylor expanded in x around 0 94.4%
*-commutative94.4%
Simplified94.4%
if 5.8e5 < x Initial program 8.8%
associate-/l*19.5%
sub-neg19.5%
metadata-eval19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
fma-define19.5%
Simplified19.5%
Taylor expanded in x around -inf 95.3%
mul-1-neg95.3%
unsub-neg95.3%
mul-1-neg95.3%
unsub-neg95.3%
mul-1-neg95.3%
unsub-neg95.3%
mul-1-neg95.3%
unsub-neg95.3%
Simplified95.3%
Final simplification95.3%
(FPCore (x y z)
:precision binary64
(let* ((t_0
(/
z
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))
(t_1 (* (+ x -2.0) (+ 4.16438922228 t_0))))
(if (<= x -3.6e+28)
t_1
(if (<= x 5e-7)
(* (+ x -2.0) (+ t_0 (* 0.0212463641547976 (* x y))))
(if (<= x 7.8e+56)
(*
(+ x -2.0)
(+
4.16438922228
(/ (- (/ (+ 3451.550173699799 (/ y x)) x) 101.7851458539211) x)))
t_1)))))
double code(double x, double y, double z) {
double t_0 = z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))));
double t_1 = (x + -2.0) * (4.16438922228 + t_0);
double tmp;
if (x <= -3.6e+28) {
tmp = t_1;
} else if (x <= 5e-7) {
tmp = (x + -2.0) * (t_0 + (0.0212463641547976 * (x * y)));
} else if (x <= 7.8e+56) {
tmp = (x + -2.0) * (4.16438922228 + ((((3451.550173699799 + (y / x)) / x) - 101.7851458539211) / x));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = z / (47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0)))))
t_1 = (x + (-2.0d0)) * (4.16438922228d0 + t_0)
if (x <= (-3.6d+28)) then
tmp = t_1
else if (x <= 5d-7) then
tmp = (x + (-2.0d0)) * (t_0 + (0.0212463641547976d0 * (x * y)))
else if (x <= 7.8d+56) then
tmp = (x + (-2.0d0)) * (4.16438922228d0 + ((((3451.550173699799d0 + (y / x)) / x) - 101.7851458539211d0) / x))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))));
double t_1 = (x + -2.0) * (4.16438922228 + t_0);
double tmp;
if (x <= -3.6e+28) {
tmp = t_1;
} else if (x <= 5e-7) {
tmp = (x + -2.0) * (t_0 + (0.0212463641547976 * (x * y)));
} else if (x <= 7.8e+56) {
tmp = (x + -2.0) * (4.16438922228 + ((((3451.550173699799 + (y / x)) / x) - 101.7851458539211) / x));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z): t_0 = z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))))) t_1 = (x + -2.0) * (4.16438922228 + t_0) tmp = 0 if x <= -3.6e+28: tmp = t_1 elif x <= 5e-7: tmp = (x + -2.0) * (t_0 + (0.0212463641547976 * (x * y))) elif x <= 7.8e+56: tmp = (x + -2.0) * (4.16438922228 + ((((3451.550173699799 + (y / x)) / x) - 101.7851458539211) / x)) else: tmp = t_1 return tmp
function code(x, y, z) t_0 = Float64(z / Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721)))))) t_1 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + t_0)) tmp = 0.0 if (x <= -3.6e+28) tmp = t_1; elseif (x <= 5e-7) tmp = Float64(Float64(x + -2.0) * Float64(t_0 + Float64(0.0212463641547976 * Float64(x * y)))); elseif (x <= 7.8e+56) tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(Float64(Float64(3451.550173699799 + Float64(y / x)) / x) - 101.7851458539211) / x))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z) t_0 = z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))))); t_1 = (x + -2.0) * (4.16438922228 + t_0); tmp = 0.0; if (x <= -3.6e+28) tmp = t_1; elseif (x <= 5e-7) tmp = (x + -2.0) * (t_0 + (0.0212463641547976 * (x * y))); elseif (x <= 7.8e+56) tmp = (x + -2.0) * (4.16438922228 + ((((3451.550173699799 + (y / x)) / x) - 101.7851458539211) / x)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z / N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.6e+28], t$95$1, If[LessEqual[x, 5e-7], N[(N[(x + -2.0), $MachinePrecision] * N[(t$95$0 + N[(0.0212463641547976 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7.8e+56], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(N[(N[(3451.550173699799 + N[(y / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - 101.7851458539211), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{z}{47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)}\\
t_1 := \left(x + -2\right) \cdot \left(4.16438922228 + t\_0\right)\\
\mathbf{if}\;x \leq -3.6 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(t\_0 + 0.0212463641547976 \cdot \left(x \cdot y\right)\right)\\
\mathbf{elif}\;x \leq 7.8 \cdot 10^{+56}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{\frac{3451.550173699799 + \frac{y}{x}}{x} - 101.7851458539211}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.5999999999999999e28 or 7.79999999999999989e56 < x Initial program 8.6%
associate-/l*17.4%
sub-neg17.4%
metadata-eval17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
Simplified17.4%
Taylor expanded in z around 0 17.4%
Taylor expanded in x around inf 96.7%
if -3.5999999999999999e28 < x < 4.99999999999999977e-7Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in z around 0 99.6%
Taylor expanded in x around 0 90.0%
if 4.99999999999999977e-7 < x < 7.79999999999999989e56Initial program 58.2%
associate-/l*78.9%
sub-neg78.9%
metadata-eval78.9%
fma-define78.9%
fma-define78.9%
fma-define78.9%
fma-define78.9%
fma-define78.9%
fma-define78.9%
fma-define78.9%
Simplified78.9%
Taylor expanded in x around -inf 82.1%
mul-1-neg82.1%
unsub-neg82.1%
mul-1-neg82.1%
unsub-neg82.1%
mul-1-neg82.1%
unsub-neg82.1%
mul-1-neg82.1%
unsub-neg82.1%
Simplified82.1%
Taylor expanded in y around inf 82.9%
mul-1-neg82.9%
distribute-neg-frac282.9%
Simplified82.9%
Final simplification92.9%
(FPCore (x y z)
:precision binary64
(if (<= x -5.5)
(*
x
(-
(/
(+
-110.1139242984811
(/ (- (* (+ y -130977.50649958357) (/ 1.0 x)) -3655.1204654076414) x))
x)
-4.16438922228))
(if (<= x 3.1e-35)
(+ (* z -0.0424927283095952) (* y (* z (* x (/ -0.0424927283095952 z)))))
(*
(+ x -2.0)
(+
4.16438922228
(/
z
(+
47.066876606
(*
x
(+
313.399215894
(* x (+ (* x (+ x 43.3400022514)) 263.505074721)))))))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.5) {
tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 3.1e-35) {
tmp = (z * -0.0424927283095952) + (y * (z * (x * (-0.0424927283095952 / z))));
} else {
tmp = (x + -2.0) * (4.16438922228 + (z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))))));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.5d0)) then
tmp = x * ((((-110.1139242984811d0) + ((((y + (-130977.50649958357d0)) * (1.0d0 / x)) - (-3655.1204654076414d0)) / x)) / x) - (-4.16438922228d0))
else if (x <= 3.1d-35) then
tmp = (z * (-0.0424927283095952d0)) + (y * (z * (x * ((-0.0424927283095952d0) / z))))
else
tmp = (x + (-2.0d0)) * (4.16438922228d0 + (z / (47.066876606d0 + (x * (313.399215894d0 + (x * ((x * (x + 43.3400022514d0)) + 263.505074721d0)))))))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.5) {
tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 3.1e-35) {
tmp = (z * -0.0424927283095952) + (y * (z * (x * (-0.0424927283095952 / z))));
} else {
tmp = (x + -2.0) * (4.16438922228 + (z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721)))))));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.5: tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228) elif x <= 3.1e-35: tmp = (z * -0.0424927283095952) + (y * (z * (x * (-0.0424927283095952 / z)))) else: tmp = (x + -2.0) * (4.16438922228 + (z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))))))) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.5) tmp = Float64(x * Float64(Float64(Float64(-110.1139242984811 + Float64(Float64(Float64(Float64(y + -130977.50649958357) * Float64(1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228)); elseif (x <= 3.1e-35) tmp = Float64(Float64(z * -0.0424927283095952) + Float64(y * Float64(z * Float64(x * Float64(-0.0424927283095952 / z))))); else tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(z / Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721)))))))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.5) tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228); elseif (x <= 3.1e-35) tmp = (z * -0.0424927283095952) + (y * (z * (x * (-0.0424927283095952 / z)))); else tmp = (x + -2.0) * (4.16438922228 + (z / (47.066876606 + (x * (313.399215894 + (x * ((x * (x + 43.3400022514)) + 263.505074721))))))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.5], N[(x * N[(N[(N[(-110.1139242984811 + N[(N[(N[(N[(y + -130977.50649958357), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] - -3655.1204654076414), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - -4.16438922228), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.1e-35], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(y * N[(z * N[(x * N[(-0.0424927283095952 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(z / N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.5:\\
\;\;\;\;x \cdot \left(\frac{-110.1139242984811 + \frac{\left(y + -130977.50649958357\right) \cdot \frac{1}{x} - -3655.1204654076414}{x}}{x} - -4.16438922228\right)\\
\mathbf{elif}\;x \leq 3.1 \cdot 10^{-35}:\\
\;\;\;\;z \cdot -0.0424927283095952 + y \cdot \left(z \cdot \left(x \cdot \frac{-0.0424927283095952}{z}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{z}{47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right)\right)}\right)\\
\end{array}
\end{array}
if x < -5.5Initial program 23.1%
associate-/l*30.8%
sub-neg30.8%
metadata-eval30.8%
fma-define30.8%
fma-define30.8%
fma-define30.8%
fma-define30.8%
fma-define30.8%
fma-define30.8%
fma-define30.8%
Simplified30.8%
Taylor expanded in z around 0 19.3%
Taylor expanded in x around -inf 91.9%
Simplified91.9%
div-inv91.9%
Applied egg-rr91.9%
if -5.5 < x < 3.10000000000000012e-35Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 95.1%
Taylor expanded in y around inf 89.8%
*-commutative89.8%
associate-/l*81.2%
distribute-lft-out81.2%
distribute-rgt-out--81.2%
metadata-eval81.2%
associate-/l*81.2%
Simplified81.2%
Taylor expanded in z around inf 89.8%
Taylor expanded in z around 0 95.1%
associate-*r/95.1%
*-commutative95.1%
associate-/l*95.1%
Simplified95.1%
if 3.10000000000000012e-35 < x Initial program 20.3%
associate-/l*29.6%
sub-neg29.6%
metadata-eval29.6%
fma-define29.6%
fma-define29.6%
fma-define29.6%
fma-define29.6%
fma-define29.6%
fma-define29.6%
fma-define29.6%
Simplified29.6%
Taylor expanded in z around 0 29.6%
Taylor expanded in x around inf 84.0%
Final simplification91.1%
(FPCore (x y z)
:precision binary64
(if (<= x -1.75e+18)
(*
x
(-
(/
(+
-110.1139242984811
(/ (- (* (+ y -130977.50649958357) (/ 1.0 x)) -3655.1204654076414) x))
x)
-4.16438922228))
(if (<= x 9.5e-15)
(+ (* z -0.0424927283095952) (* y (* x -0.0424927283095952)))
(*
x
(+
4.16438922228
(/
(+
-110.1139242984811
(/ (+ 3655.1204654076414 (/ (+ y -130977.50649958357) x)) x))
x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.75e+18) {
tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-1.75d+18)) then
tmp = x * ((((-110.1139242984811d0) + ((((y + (-130977.50649958357d0)) * (1.0d0 / x)) - (-3655.1204654076414d0)) / x)) / x) - (-4.16438922228d0))
else if (x <= 9.5d-15) then
tmp = (z * (-0.0424927283095952d0)) + (y * (x * (-0.0424927283095952d0)))
else
tmp = x * (4.16438922228d0 + (((-110.1139242984811d0) + ((3655.1204654076414d0 + ((y + (-130977.50649958357d0)) / x)) / x)) / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1.75e+18) {
tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.75e+18: tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228) elif x <= 9.5e-15: tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)) else: tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.75e+18) tmp = Float64(x * Float64(Float64(Float64(-110.1139242984811 + Float64(Float64(Float64(Float64(y + -130977.50649958357) * Float64(1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228)); elseif (x <= 9.5e-15) tmp = Float64(Float64(z * -0.0424927283095952) + Float64(y * Float64(x * -0.0424927283095952))); else tmp = Float64(x * Float64(4.16438922228 + Float64(Float64(-110.1139242984811 + Float64(Float64(3655.1204654076414 + Float64(Float64(y + -130977.50649958357) / x)) / x)) / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.75e+18) tmp = x * (((-110.1139242984811 + ((((y + -130977.50649958357) * (1.0 / x)) - -3655.1204654076414) / x)) / x) - -4.16438922228); elseif (x <= 9.5e-15) tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)); else tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.75e+18], N[(x * N[(N[(N[(-110.1139242984811 + N[(N[(N[(N[(y + -130977.50649958357), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] - -3655.1204654076414), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - -4.16438922228), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.5e-15], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(y * N[(x * -0.0424927283095952), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 + N[(N[(-110.1139242984811 + N[(N[(3655.1204654076414 + N[(N[(y + -130977.50649958357), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.75 \cdot 10^{+18}:\\
\;\;\;\;x \cdot \left(\frac{-110.1139242984811 + \frac{\left(y + -130977.50649958357\right) \cdot \frac{1}{x} - -3655.1204654076414}{x}}{x} - -4.16438922228\right)\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{-15}:\\
\;\;\;\;z \cdot -0.0424927283095952 + y \cdot \left(x \cdot -0.0424927283095952\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811 + \frac{3655.1204654076414 + \frac{y + -130977.50649958357}{x}}{x}}{x}\right)\\
\end{array}
\end{array}
if x < -1.75e18Initial program 17.6%
associate-/l*25.9%
sub-neg25.9%
metadata-eval25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
Simplified25.9%
Taylor expanded in z around 0 14.8%
Taylor expanded in x around -inf 93.7%
Simplified93.7%
div-inv93.8%
Applied egg-rr93.8%
if -1.75e18 < x < 9.5000000000000005e-15Initial program 99.7%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 90.8%
Taylor expanded in y around inf 85.2%
*-commutative85.2%
associate-/l*77.1%
distribute-lft-out77.1%
distribute-rgt-out--77.1%
metadata-eval77.1%
associate-/l*77.1%
Simplified77.1%
Taylor expanded in z around 0 90.8%
*-commutative90.8%
Simplified90.8%
if 9.5000000000000005e-15 < x Initial program 15.6%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
Simplified25.5%
Taylor expanded in z around 0 11.1%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Final simplification91.0%
(FPCore (x y z)
:precision binary64
(if (<= x -1.75e+18)
(*
x
(-
(/ (+ -110.1139242984811 (/ (- (/ y x) -3655.1204654076414) x)) x)
-4.16438922228))
(if (<= x 9.5e-15)
(+ (* z -0.0424927283095952) (* y (* x -0.0424927283095952)))
(*
x
(+
4.16438922228
(/
(+
-110.1139242984811
(/ (+ 3655.1204654076414 (/ (+ y -130977.50649958357) x)) x))
x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.75e+18) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-1.75d+18)) then
tmp = x * ((((-110.1139242984811d0) + (((y / x) - (-3655.1204654076414d0)) / x)) / x) - (-4.16438922228d0))
else if (x <= 9.5d-15) then
tmp = (z * (-0.0424927283095952d0)) + (y * (x * (-0.0424927283095952d0)))
else
tmp = x * (4.16438922228d0 + (((-110.1139242984811d0) + ((3655.1204654076414d0 + ((y + (-130977.50649958357d0)) / x)) / x)) / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1.75e+18) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.75e+18: tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228) elif x <= 9.5e-15: tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)) else: tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.75e+18) tmp = Float64(x * Float64(Float64(Float64(-110.1139242984811 + Float64(Float64(Float64(y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228)); elseif (x <= 9.5e-15) tmp = Float64(Float64(z * -0.0424927283095952) + Float64(y * Float64(x * -0.0424927283095952))); else tmp = Float64(x * Float64(4.16438922228 + Float64(Float64(-110.1139242984811 + Float64(Float64(3655.1204654076414 + Float64(Float64(y + -130977.50649958357) / x)) / x)) / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.75e+18) tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228); elseif (x <= 9.5e-15) tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)); else tmp = x * (4.16438922228 + ((-110.1139242984811 + ((3655.1204654076414 + ((y + -130977.50649958357) / x)) / x)) / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.75e+18], N[(x * N[(N[(N[(-110.1139242984811 + N[(N[(N[(y / x), $MachinePrecision] - -3655.1204654076414), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - -4.16438922228), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.5e-15], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(y * N[(x * -0.0424927283095952), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 + N[(N[(-110.1139242984811 + N[(N[(3655.1204654076414 + N[(N[(y + -130977.50649958357), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.75 \cdot 10^{+18}:\\
\;\;\;\;x \cdot \left(\frac{-110.1139242984811 + \frac{\frac{y}{x} - -3655.1204654076414}{x}}{x} - -4.16438922228\right)\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{-15}:\\
\;\;\;\;z \cdot -0.0424927283095952 + y \cdot \left(x \cdot -0.0424927283095952\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811 + \frac{3655.1204654076414 + \frac{y + -130977.50649958357}{x}}{x}}{x}\right)\\
\end{array}
\end{array}
if x < -1.75e18Initial program 17.6%
associate-/l*25.9%
sub-neg25.9%
metadata-eval25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
fma-define25.9%
Simplified25.9%
Taylor expanded in z around 0 14.8%
Taylor expanded in x around -inf 93.7%
Simplified93.7%
Taylor expanded in y around inf 93.7%
if -1.75e18 < x < 9.5000000000000005e-15Initial program 99.7%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 90.8%
Taylor expanded in y around inf 85.2%
*-commutative85.2%
associate-/l*77.1%
distribute-lft-out77.1%
distribute-rgt-out--77.1%
metadata-eval77.1%
associate-/l*77.1%
Simplified77.1%
Taylor expanded in z around 0 90.8%
*-commutative90.8%
Simplified90.8%
if 9.5000000000000005e-15 < x Initial program 15.6%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
Simplified25.5%
Taylor expanded in z around 0 11.1%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Taylor expanded in x around -inf 88.6%
Simplified88.6%
Final simplification91.0%
(FPCore (x y z)
:precision binary64
(if (or (<= x -1.75e+18) (not (<= x 5.9e-12)))
(*
x
(-
(/ (+ -110.1139242984811 (/ (- (/ y x) -3655.1204654076414) x)) x)
-4.16438922228))
(+ (* z -0.0424927283095952) (* y (* x -0.0424927283095952)))))
double code(double x, double y, double z) {
double tmp;
if ((x <= -1.75e+18) || !(x <= 5.9e-12)) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((x <= (-1.75d+18)) .or. (.not. (x <= 5.9d-12))) then
tmp = x * ((((-110.1139242984811d0) + (((y / x) - (-3655.1204654076414d0)) / x)) / x) - (-4.16438922228d0))
else
tmp = (z * (-0.0424927283095952d0)) + (y * (x * (-0.0424927283095952d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((x <= -1.75e+18) || !(x <= 5.9e-12)) {
tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228);
} else {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
}
return tmp;
}
def code(x, y, z): tmp = 0 if (x <= -1.75e+18) or not (x <= 5.9e-12): tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228) else: tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)) return tmp
function code(x, y, z) tmp = 0.0 if ((x <= -1.75e+18) || !(x <= 5.9e-12)) tmp = Float64(x * Float64(Float64(Float64(-110.1139242984811 + Float64(Float64(Float64(y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228)); else tmp = Float64(Float64(z * -0.0424927283095952) + Float64(y * Float64(x * -0.0424927283095952))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((x <= -1.75e+18) || ~((x <= 5.9e-12))) tmp = x * (((-110.1139242984811 + (((y / x) - -3655.1204654076414) / x)) / x) - -4.16438922228); else tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[x, -1.75e+18], N[Not[LessEqual[x, 5.9e-12]], $MachinePrecision]], N[(x * N[(N[(N[(-110.1139242984811 + N[(N[(N[(y / x), $MachinePrecision] - -3655.1204654076414), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] - -4.16438922228), $MachinePrecision]), $MachinePrecision], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(y * N[(x * -0.0424927283095952), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.75 \cdot 10^{+18} \lor \neg \left(x \leq 5.9 \cdot 10^{-12}\right):\\
\;\;\;\;x \cdot \left(\frac{-110.1139242984811 + \frac{\frac{y}{x} - -3655.1204654076414}{x}}{x} - -4.16438922228\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot -0.0424927283095952 + y \cdot \left(x \cdot -0.0424927283095952\right)\\
\end{array}
\end{array}
if x < -1.75e18 or 5.9e-12 < x Initial program 14.7%
associate-/l*24.0%
sub-neg24.0%
metadata-eval24.0%
fma-define24.0%
fma-define24.0%
fma-define24.0%
fma-define24.0%
fma-define24.0%
fma-define24.0%
fma-define24.0%
Simplified24.0%
Taylor expanded in z around 0 12.5%
Taylor expanded in x around -inf 93.1%
Simplified93.1%
Taylor expanded in y around inf 93.1%
if -1.75e18 < x < 5.9e-12Initial program 99.7%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 90.2%
Taylor expanded in y around inf 84.7%
*-commutative84.7%
associate-/l*76.9%
distribute-lft-out76.9%
distribute-rgt-out--76.9%
metadata-eval76.9%
associate-/l*76.9%
Simplified76.9%
Taylor expanded in z around 0 90.0%
*-commutative90.0%
Simplified90.0%
Final simplification91.6%
(FPCore (x y z)
:precision binary64
(if (<= x -5.4e+29)
(* x 4.16438922228)
(if (<= x 9.5e-15)
(+ (* z -0.0424927283095952) (* y (* x -0.0424927283095952)))
(* x (- 4.16438922228 (/ 110.1139242984811 x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 9.5d-15) then
tmp = (z * (-0.0424927283095952d0)) + (y * (x * (-0.0424927283095952d0)))
else
tmp = x * (4.16438922228d0 - (110.1139242984811d0 / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 9.5e-15) {
tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 9.5e-15: tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)) else: tmp = x * (4.16438922228 - (110.1139242984811 / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 9.5e-15) tmp = Float64(Float64(z * -0.0424927283095952) + Float64(y * Float64(x * -0.0424927283095952))); else tmp = Float64(x * Float64(4.16438922228 - Float64(110.1139242984811 / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 9.5e-15) tmp = (z * -0.0424927283095952) + (y * (x * -0.0424927283095952)); else tmp = x * (4.16438922228 - (110.1139242984811 / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 9.5e-15], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(y * N[(x * -0.0424927283095952), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 - N[(110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{-15}:\\
\;\;\;\;z \cdot -0.0424927283095952 + y \cdot \left(x \cdot -0.0424927283095952\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 - \frac{110.1139242984811}{x}\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 9.5000000000000005e-15Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 88.0%
Taylor expanded in y around inf 82.6%
*-commutative82.6%
associate-/l*74.8%
distribute-lft-out74.8%
distribute-rgt-out--74.8%
metadata-eval74.8%
associate-/l*74.8%
Simplified74.8%
Taylor expanded in z around 0 88.1%
*-commutative88.1%
Simplified88.1%
if 9.5000000000000005e-15 < x Initial program 15.6%
associate-/l*25.5%
sub-neg25.5%
metadata-eval25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
fma-define25.5%
Simplified25.5%
Taylor expanded in x around inf 82.1%
associate-*r/82.1%
metadata-eval82.1%
Simplified82.1%
Final simplification87.4%
(FPCore (x y z)
:precision binary64
(if (<= x -5.4e+29)
(* x 4.16438922228)
(if (<= x 5.9e-12)
(+ (* z -0.0424927283095952) (* x (* y -0.0424927283095952)))
(* x (- 4.16438922228 (/ 110.1139242984811 x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = (z * -0.0424927283095952) + (x * (y * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 5.9d-12) then
tmp = (z * (-0.0424927283095952d0)) + (x * (y * (-0.0424927283095952d0)))
else
tmp = x * (4.16438922228d0 - (110.1139242984811d0 / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = (z * -0.0424927283095952) + (x * (y * -0.0424927283095952));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 5.9e-12: tmp = (z * -0.0424927283095952) + (x * (y * -0.0424927283095952)) else: tmp = x * (4.16438922228 - (110.1139242984811 / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 5.9e-12) tmp = Float64(Float64(z * -0.0424927283095952) + Float64(x * Float64(y * -0.0424927283095952))); else tmp = Float64(x * Float64(4.16438922228 - Float64(110.1139242984811 / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 5.9e-12) tmp = (z * -0.0424927283095952) + (x * (y * -0.0424927283095952)); else tmp = x * (4.16438922228 - (110.1139242984811 / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 5.9e-12], N[(N[(z * -0.0424927283095952), $MachinePrecision] + N[(x * N[(y * -0.0424927283095952), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 - N[(110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 5.9 \cdot 10^{-12}:\\
\;\;\;\;z \cdot -0.0424927283095952 + x \cdot \left(y \cdot -0.0424927283095952\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 - \frac{110.1139242984811}{x}\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 5.9e-12Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 87.5%
Taylor expanded in z around 0 87.3%
*-commutative87.3%
associate-*l*87.3%
Simplified87.3%
if 5.9e-12 < x Initial program 11.6%
associate-/l*22.0%
sub-neg22.0%
metadata-eval22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
Simplified22.0%
Taylor expanded in x around inf 85.7%
associate-*r/85.7%
metadata-eval85.7%
Simplified85.7%
Final simplification88.0%
(FPCore (x y z)
:precision binary64
(if (<= x -5.4e+29)
(* x 4.16438922228)
(if (<= x 5.9e-12)
(* -0.0424927283095952 (+ z (* x y)))
(* x (- 4.16438922228 (/ 110.1139242984811 x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 5.9d-12) then
tmp = (-0.0424927283095952d0) * (z + (x * y))
else
tmp = x * (4.16438922228d0 - (110.1139242984811d0 / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = x * (4.16438922228 - (110.1139242984811 / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 5.9e-12: tmp = -0.0424927283095952 * (z + (x * y)) else: tmp = x * (4.16438922228 - (110.1139242984811 / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 5.9e-12) tmp = Float64(-0.0424927283095952 * Float64(z + Float64(x * y))); else tmp = Float64(x * Float64(4.16438922228 - Float64(110.1139242984811 / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 5.9e-12) tmp = -0.0424927283095952 * (z + (x * y)); else tmp = x * (4.16438922228 - (110.1139242984811 / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 5.9e-12], N[(-0.0424927283095952 * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 - N[(110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 5.9 \cdot 10^{-12}:\\
\;\;\;\;-0.0424927283095952 \cdot \left(z + x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 - \frac{110.1139242984811}{x}\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 5.9e-12Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 87.5%
Taylor expanded in z around 0 87.3%
*-commutative87.3%
Simplified87.3%
Taylor expanded in z around 0 87.3%
distribute-lft-out87.3%
+-commutative87.3%
*-commutative87.3%
Simplified87.3%
if 5.9e-12 < x Initial program 11.6%
associate-/l*22.0%
sub-neg22.0%
metadata-eval22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
Simplified22.0%
Taylor expanded in x around inf 85.7%
associate-*r/85.7%
metadata-eval85.7%
Simplified85.7%
Final simplification88.0%
(FPCore (x y z)
:precision binary64
(if (<= x -5.4e+29)
(* x 4.16438922228)
(if (<= x 5.9e-12)
(* -0.0424927283095952 (+ z (* x y)))
(* x (- 4.16438922228 (/ 8.32877844456 x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = x * (4.16438922228 - (8.32877844456 / x));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 5.9d-12) then
tmp = (-0.0424927283095952d0) * (z + (x * y))
else
tmp = x * (4.16438922228d0 - (8.32877844456d0 / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = x * (4.16438922228 - (8.32877844456 / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 5.9e-12: tmp = -0.0424927283095952 * (z + (x * y)) else: tmp = x * (4.16438922228 - (8.32877844456 / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 5.9e-12) tmp = Float64(-0.0424927283095952 * Float64(z + Float64(x * y))); else tmp = Float64(x * Float64(4.16438922228 - Float64(8.32877844456 / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 5.9e-12) tmp = -0.0424927283095952 * (z + (x * y)); else tmp = x * (4.16438922228 - (8.32877844456 / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 5.9e-12], N[(-0.0424927283095952 * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(4.16438922228 - N[(8.32877844456 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 5.9 \cdot 10^{-12}:\\
\;\;\;\;-0.0424927283095952 \cdot \left(z + x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(4.16438922228 - \frac{8.32877844456}{x}\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 5.9e-12Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 87.5%
Taylor expanded in z around 0 87.3%
*-commutative87.3%
Simplified87.3%
Taylor expanded in z around 0 87.3%
distribute-lft-out87.3%
+-commutative87.3%
*-commutative87.3%
Simplified87.3%
if 5.9e-12 < x Initial program 11.6%
associate-/l*22.0%
sub-neg22.0%
metadata-eval22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
Simplified22.0%
Taylor expanded in z around 0 22.0%
Taylor expanded in x around inf 89.8%
Taylor expanded in x around inf 85.4%
associate-*r/85.4%
metadata-eval85.4%
Simplified85.4%
Final simplification87.9%
(FPCore (x y z)
:precision binary64
(if (<= x -5.4e+29)
(* x 4.16438922228)
(if (<= x 5.9e-12)
(* -0.0424927283095952 (+ z (* x y)))
(* 4.16438922228 (+ x -2.0)))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = 4.16438922228 * (x + -2.0);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 5.9d-12) then
tmp = (-0.0424927283095952d0) * (z + (x * y))
else
tmp = 4.16438922228d0 * (x + (-2.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 5.9e-12) {
tmp = -0.0424927283095952 * (z + (x * y));
} else {
tmp = 4.16438922228 * (x + -2.0);
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 5.9e-12: tmp = -0.0424927283095952 * (z + (x * y)) else: tmp = 4.16438922228 * (x + -2.0) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 5.9e-12) tmp = Float64(-0.0424927283095952 * Float64(z + Float64(x * y))); else tmp = Float64(4.16438922228 * Float64(x + -2.0)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 5.9e-12) tmp = -0.0424927283095952 * (z + (x * y)); else tmp = 4.16438922228 * (x + -2.0); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 5.9e-12], N[(-0.0424927283095952 * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(4.16438922228 * N[(x + -2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 5.9 \cdot 10^{-12}:\\
\;\;\;\;-0.0424927283095952 \cdot \left(z + x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;4.16438922228 \cdot \left(x + -2\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 5.9e-12Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 87.5%
Taylor expanded in z around 0 87.3%
*-commutative87.3%
Simplified87.3%
Taylor expanded in z around 0 87.3%
distribute-lft-out87.3%
+-commutative87.3%
*-commutative87.3%
Simplified87.3%
if 5.9e-12 < x Initial program 11.6%
associate-/l*22.0%
sub-neg22.0%
metadata-eval22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
fma-define22.0%
Simplified22.0%
Taylor expanded in x around inf 85.4%
Final simplification87.9%
(FPCore (x y z) :precision binary64 (if (<= x -5.4e+29) (* x 4.16438922228) (if (<= x 8e-14) (* z -0.0424927283095952) (* 4.16438922228 (+ x -2.0)))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 8e-14) {
tmp = z * -0.0424927283095952;
} else {
tmp = 4.16438922228 * (x + -2.0);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-5.4d+29)) then
tmp = x * 4.16438922228d0
else if (x <= 8d-14) then
tmp = z * (-0.0424927283095952d0)
else
tmp = 4.16438922228d0 * (x + (-2.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -5.4e+29) {
tmp = x * 4.16438922228;
} else if (x <= 8e-14) {
tmp = z * -0.0424927283095952;
} else {
tmp = 4.16438922228 * (x + -2.0);
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5.4e+29: tmp = x * 4.16438922228 elif x <= 8e-14: tmp = z * -0.0424927283095952 else: tmp = 4.16438922228 * (x + -2.0) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5.4e+29) tmp = Float64(x * 4.16438922228); elseif (x <= 8e-14) tmp = Float64(z * -0.0424927283095952); else tmp = Float64(4.16438922228 * Float64(x + -2.0)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -5.4e+29) tmp = x * 4.16438922228; elseif (x <= 8e-14) tmp = z * -0.0424927283095952; else tmp = 4.16438922228 * (x + -2.0); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5.4e+29], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 8e-14], N[(z * -0.0424927283095952), $MachinePrecision], N[(4.16438922228 * N[(x + -2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29}:\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{elif}\;x \leq 8 \cdot 10^{-14}:\\
\;\;\;\;z \cdot -0.0424927283095952\\
\mathbf{else}:\\
\;\;\;\;4.16438922228 \cdot \left(x + -2\right)\\
\end{array}
\end{array}
if x < -5.4e29Initial program 12.6%
associate-/l*21.3%
sub-neg21.3%
metadata-eval21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
fma-define21.3%
Simplified21.3%
Taylor expanded in z around 0 21.3%
Taylor expanded in x around inf 96.1%
Taylor expanded in x around inf 91.7%
if -5.4e29 < x < 7.99999999999999999e-14Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 57.8%
*-commutative57.8%
Simplified57.8%
if 7.99999999999999999e-14 < x Initial program 13.0%
associate-/l*23.2%
sub-neg23.2%
metadata-eval23.2%
fma-define23.2%
fma-define23.2%
fma-define23.2%
fma-define23.2%
fma-define23.2%
fma-define23.2%
fma-define23.2%
Simplified23.2%
Taylor expanded in x around inf 84.1%
Final simplification73.1%
(FPCore (x y z) :precision binary64 (if (or (<= x -5.4e+29) (not (<= x 8e-14))) (* x 4.16438922228) (* z -0.0424927283095952)))
double code(double x, double y, double z) {
double tmp;
if ((x <= -5.4e+29) || !(x <= 8e-14)) {
tmp = x * 4.16438922228;
} else {
tmp = z * -0.0424927283095952;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((x <= (-5.4d+29)) .or. (.not. (x <= 8d-14))) then
tmp = x * 4.16438922228d0
else
tmp = z * (-0.0424927283095952d0)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((x <= -5.4e+29) || !(x <= 8e-14)) {
tmp = x * 4.16438922228;
} else {
tmp = z * -0.0424927283095952;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (x <= -5.4e+29) or not (x <= 8e-14): tmp = x * 4.16438922228 else: tmp = z * -0.0424927283095952 return tmp
function code(x, y, z) tmp = 0.0 if ((x <= -5.4e+29) || !(x <= 8e-14)) tmp = Float64(x * 4.16438922228); else tmp = Float64(z * -0.0424927283095952); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((x <= -5.4e+29) || ~((x <= 8e-14))) tmp = x * 4.16438922228; else tmp = z * -0.0424927283095952; end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[x, -5.4e+29], N[Not[LessEqual[x, 8e-14]], $MachinePrecision]], N[(x * 4.16438922228), $MachinePrecision], N[(z * -0.0424927283095952), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.4 \cdot 10^{+29} \lor \neg \left(x \leq 8 \cdot 10^{-14}\right):\\
\;\;\;\;x \cdot 4.16438922228\\
\mathbf{else}:\\
\;\;\;\;z \cdot -0.0424927283095952\\
\end{array}
\end{array}
if x < -5.4e29 or 7.99999999999999999e-14 < x Initial program 12.8%
associate-/l*22.3%
sub-neg22.3%
metadata-eval22.3%
fma-define22.3%
fma-define22.3%
fma-define22.3%
fma-define22.3%
fma-define22.3%
fma-define22.3%
fma-define22.3%
Simplified22.3%
Taylor expanded in z around 0 22.3%
Taylor expanded in x around inf 92.2%
Taylor expanded in x around inf 87.9%
if -5.4e29 < x < 7.99999999999999999e-14Initial program 99.6%
associate-/l*99.6%
sub-neg99.6%
metadata-eval99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in x around 0 57.8%
*-commutative57.8%
Simplified57.8%
Final simplification73.1%
(FPCore (x y z) :precision binary64 (* x 4.16438922228))
double code(double x, double y, double z) {
return x * 4.16438922228;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * 4.16438922228d0
end function
public static double code(double x, double y, double z) {
return x * 4.16438922228;
}
def code(x, y, z): return x * 4.16438922228
function code(x, y, z) return Float64(x * 4.16438922228) end
function tmp = code(x, y, z) tmp = x * 4.16438922228; end
code[x_, y_, z_] := N[(x * 4.16438922228), $MachinePrecision]
\begin{array}{l}
\\
x \cdot 4.16438922228
\end{array}
Initial program 55.5%
associate-/l*60.3%
sub-neg60.3%
metadata-eval60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
Simplified60.3%
Taylor expanded in z around 0 60.3%
Taylor expanded in x around inf 69.2%
Taylor expanded in x around inf 47.4%
Final simplification47.4%
(FPCore (x y z) :precision binary64 -8.32877844456)
double code(double x, double y, double z) {
return -8.32877844456;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = -8.32877844456d0
end function
public static double code(double x, double y, double z) {
return -8.32877844456;
}
def code(x, y, z): return -8.32877844456
function code(x, y, z) return -8.32877844456 end
function tmp = code(x, y, z) tmp = -8.32877844456; end
code[x_, y_, z_] := -8.32877844456
\begin{array}{l}
\\
-8.32877844456
\end{array}
Initial program 55.5%
associate-/l*60.3%
sub-neg60.3%
metadata-eval60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
fma-define60.3%
Simplified60.3%
Taylor expanded in x around inf 47.2%
Taylor expanded in x around 0 3.2%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811)))
(if (< x -3.326128725870005e+62)
t_0
(if (< x 9.429991714554673e+55)
(*
(/ (- x 2.0) 1.0)
(/
(+
(*
(+
(* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x)
y)
x)
z)
(+
(*
(+
(+ (* 263.505074721 x) (+ (* 43.3400022514 (* x x)) (* x (* x x))))
313.399215894)
x)
47.066876606)))
t_0))))
double code(double x, double y, double z) {
double t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811;
double tmp;
if (x < -3.326128725870005e+62) {
tmp = t_0;
} else if (x < 9.429991714554673e+55) {
tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = ((y / (x * x)) + (4.16438922228d0 * x)) - 110.1139242984811d0
if (x < (-3.326128725870005d+62)) then
tmp = t_0
else if (x < 9.429991714554673d+55) then
tmp = ((x - 2.0d0) / 1.0d0) * (((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z) / (((((263.505074721d0 * x) + ((43.3400022514d0 * (x * x)) + (x * (x * x)))) + 313.399215894d0) * x) + 47.066876606d0))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811;
double tmp;
if (x < -3.326128725870005e+62) {
tmp = t_0;
} else if (x < 9.429991714554673e+55) {
tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811 tmp = 0 if x < -3.326128725870005e+62: tmp = t_0 elif x < 9.429991714554673e+55: tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606)) else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(Float64(Float64(y / Float64(x * x)) + Float64(4.16438922228 * x)) - 110.1139242984811) tmp = 0.0 if (x < -3.326128725870005e+62) tmp = t_0; elseif (x < 9.429991714554673e+55) tmp = Float64(Float64(Float64(x - 2.0) / 1.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / Float64(Float64(Float64(Float64(Float64(263.505074721 * x) + Float64(Float64(43.3400022514 * Float64(x * x)) + Float64(x * Float64(x * x)))) + 313.399215894) * x) + 47.066876606))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811; tmp = 0.0; if (x < -3.326128725870005e+62) tmp = t_0; elseif (x < 9.429991714554673e+55) tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(4.16438922228 * x), $MachinePrecision]), $MachinePrecision] - 110.1139242984811), $MachinePrecision]}, If[Less[x, -3.326128725870005e+62], t$95$0, If[Less[x, 9.429991714554673e+55], N[(N[(N[(x - 2.0), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision] / N[(N[(N[(N[(N[(263.505074721 * x), $MachinePrecision] + N[(N[(43.3400022514 * N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\frac{y}{x \cdot x} + 4.16438922228 \cdot x\right) - 110.1139242984811\\
\mathbf{if}\;x < -3.326128725870005 \cdot 10^{+62}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x < 9.429991714554673 \cdot 10^{+55}:\\
\;\;\;\;\frac{x - 2}{1} \cdot \frac{\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z}{\left(\left(263.505074721 \cdot x + \left(43.3400022514 \cdot \left(x \cdot x\right) + x \cdot \left(x \cdot x\right)\right)\right) + 313.399215894\right) \cdot x + 47.066876606}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
herbie shell --seed 2024107
(FPCore (x y z)
:name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2, C"
:precision binary64
:alt
(if (< x -3.326128725870005e+62) (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811) (if (< x 9.429991714554673e+55) (* (/ (- x 2.0) 1.0) (/ (+ (* (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y) x) z) (+ (* (+ (+ (* 263.505074721 x) (+ (* 43.3400022514 (* x x)) (* x (* x x)))) 313.399215894) x) 47.066876606))) (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811)))
(/ (* (- x 2.0) (+ (* (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y) x) z)) (+ (* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x) 47.066876606)))