
(FPCore (x y z t) :precision binary64 (+ (/ (* x x) (* y y)) (/ (* z z) (* t t))))
double code(double x, double y, double z, double t) {
return ((x * x) / (y * y)) + ((z * z) / (t * t));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = ((x * x) / (y * y)) + ((z * z) / (t * t))
end function
public static double code(double x, double y, double z, double t) {
return ((x * x) / (y * y)) + ((z * z) / (t * t));
}
def code(x, y, z, t): return ((x * x) / (y * y)) + ((z * z) / (t * t))
function code(x, y, z, t) return Float64(Float64(Float64(x * x) / Float64(y * y)) + Float64(Float64(z * z) / Float64(t * t))) end
function tmp = code(x, y, z, t) tmp = ((x * x) / (y * y)) + ((z * z) / (t * t)); end
code[x_, y_, z_, t_] := N[(N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision] + N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot x}{y \cdot y} + \frac{z \cdot z}{t \cdot t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (/ (* x x) (* y y)) (/ (* z z) (* t t))))
double code(double x, double y, double z, double t) {
return ((x * x) / (y * y)) + ((z * z) / (t * t));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = ((x * x) / (y * y)) + ((z * z) / (t * t))
end function
public static double code(double x, double y, double z, double t) {
return ((x * x) / (y * y)) + ((z * z) / (t * t));
}
def code(x, y, z, t): return ((x * x) / (y * y)) + ((z * z) / (t * t))
function code(x, y, z, t) return Float64(Float64(Float64(x * x) / Float64(y * y)) + Float64(Float64(z * z) / Float64(t * t))) end
function tmp = code(x, y, z, t) tmp = ((x * x) / (y * y)) + ((z * z) / (t * t)); end
code[x_, y_, z_, t_] := N[(N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision] + N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot x}{y \cdot y} + \frac{z \cdot z}{t \cdot t}
\end{array}
(FPCore (x y z t) :precision binary64 (fma (/ x y) (pow (/ y x) -1.0) (pow (/ z t) 2.0)))
double code(double x, double y, double z, double t) {
return fma((x / y), pow((y / x), -1.0), pow((z / t), 2.0));
}
function code(x, y, z, t) return fma(Float64(x / y), (Float64(y / x) ^ -1.0), (Float64(z / t) ^ 2.0)) end
code[x_, y_, z_, t_] := N[(N[(x / y), $MachinePrecision] * N[Power[N[(y / x), $MachinePrecision], -1.0], $MachinePrecision] + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{x}{y}, {\left(\frac{y}{x}\right)}^{-1}, {\left(\frac{z}{t}\right)}^{2}\right)
\end{array}
Initial program 70.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6482.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
Final simplification99.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 0.0)
(pow (/ (/ y x) (/ x y)) -1.0)
(if (<= t_1 5e+259)
(+ (* (/ x (* y y)) x) t_1)
(if (<= t_1 INFINITY)
(* (/ z (* t t)) z)
(pow (* (/ y x) (/ y x)) -1.0))))))
double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 0.0) {
tmp = pow(((y / x) / (x / y)), -1.0);
} else if (t_1 <= 5e+259) {
tmp = ((x / (y * y)) * x) + t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (z / (t * t)) * z;
} else {
tmp = pow(((y / x) * (y / x)), -1.0);
}
return tmp;
}
public static double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 0.0) {
tmp = Math.pow(((y / x) / (x / y)), -1.0);
} else if (t_1 <= 5e+259) {
tmp = ((x / (y * y)) * x) + t_1;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (z / (t * t)) * z;
} else {
tmp = Math.pow(((y / x) * (y / x)), -1.0);
}
return tmp;
}
def code(x, y, z, t): t_1 = (z * z) / (t * t) tmp = 0 if t_1 <= 0.0: tmp = math.pow(((y / x) / (x / y)), -1.0) elif t_1 <= 5e+259: tmp = ((x / (y * y)) * x) + t_1 elif t_1 <= math.inf: tmp = (z / (t * t)) * z else: tmp = math.pow(((y / x) * (y / x)), -1.0) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(Float64(y / x) / Float64(x / y)) ^ -1.0; elseif (t_1 <= 5e+259) tmp = Float64(Float64(Float64(x / Float64(y * y)) * x) + t_1); elseif (t_1 <= Inf) tmp = Float64(Float64(z / Float64(t * t)) * z); else tmp = Float64(Float64(y / x) * Float64(y / x)) ^ -1.0; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (z * z) / (t * t); tmp = 0.0; if (t_1 <= 0.0) tmp = ((y / x) / (x / y)) ^ -1.0; elseif (t_1 <= 5e+259) tmp = ((x / (y * y)) * x) + t_1; elseif (t_1 <= Inf) tmp = (z / (t * t)) * z; else tmp = ((y / x) * (y / x)) ^ -1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[Power[N[(N[(y / x), $MachinePrecision] / N[(x / y), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision], If[LessEqual[t$95$1, 5e+259], N[(N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[Power[N[(N[(y / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;{\left(\frac{\frac{y}{x}}{\frac{x}{y}}\right)}^{-1}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+259}:\\
\;\;\;\;\frac{x}{y \cdot y} \cdot x + t\_1\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{y}{x} \cdot \frac{y}{x}\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 0.0Initial program 77.8%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6478.6
Applied rewrites78.6%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6496.3
Applied rewrites96.3%
Applied rewrites96.3%
if 0.0 < (/.f64 (*.f64 z z) (*.f64 t t)) < 5.00000000000000033e259Initial program 85.4%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6497.0
Applied rewrites97.0%
Applied rewrites91.0%
if 5.00000000000000033e259 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 79.2%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6492.4
Applied rewrites92.4%
Applied rewrites95.6%
if +inf.0 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 0.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6448.0
Applied rewrites48.0%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6454.5
Applied rewrites54.5%
Final simplification89.9%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 5e+259)
(fma (/ x y) (/ x y) t_1)
(if (<= t_1 INFINITY)
(* (/ z (* t t)) z)
(pow (* (/ y x) (/ y x)) -1.0)))))
double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 5e+259) {
tmp = fma((x / y), (x / y), t_1);
} else if (t_1 <= ((double) INFINITY)) {
tmp = (z / (t * t)) * z;
} else {
tmp = pow(((y / x) * (y / x)), -1.0);
}
return tmp;
}
function code(x, y, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 5e+259) tmp = fma(Float64(x / y), Float64(x / y), t_1); elseif (t_1 <= Inf) tmp = Float64(Float64(z / Float64(t * t)) * z); else tmp = Float64(Float64(y / x) * Float64(y / x)) ^ -1.0; end return tmp end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e+259], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[Power[N[(N[(y / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{+259}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y}, \frac{x}{y}, t\_1\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{y}{x} \cdot \frac{y}{x}\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 5.00000000000000033e259Initial program 80.5%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6497.3
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.5
Applied rewrites99.5%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f6497.3
Applied rewrites97.3%
if 5.00000000000000033e259 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 79.2%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6492.4
Applied rewrites92.4%
Applied rewrites95.6%
if +inf.0 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 0.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6448.0
Applied rewrites48.0%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6454.5
Applied rewrites54.5%
Final simplification91.4%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* x x) (* y y))))
(if (or (<= t_1 2e-225) (not (<= t_1 INFINITY)))
(/ (/ z t) (/ t z))
(pow (* (/ y (* x x)) y) -1.0))))
double code(double x, double y, double z, double t) {
double t_1 = (x * x) / (y * y);
double tmp;
if ((t_1 <= 2e-225) || !(t_1 <= ((double) INFINITY))) {
tmp = (z / t) / (t / z);
} else {
tmp = pow(((y / (x * x)) * y), -1.0);
}
return tmp;
}
public static double code(double x, double y, double z, double t) {
double t_1 = (x * x) / (y * y);
double tmp;
if ((t_1 <= 2e-225) || !(t_1 <= Double.POSITIVE_INFINITY)) {
tmp = (z / t) / (t / z);
} else {
tmp = Math.pow(((y / (x * x)) * y), -1.0);
}
return tmp;
}
def code(x, y, z, t): t_1 = (x * x) / (y * y) tmp = 0 if (t_1 <= 2e-225) or not (t_1 <= math.inf): tmp = (z / t) / (t / z) else: tmp = math.pow(((y / (x * x)) * y), -1.0) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(x * x) / Float64(y * y)) tmp = 0.0 if ((t_1 <= 2e-225) || !(t_1 <= Inf)) tmp = Float64(Float64(z / t) / Float64(t / z)); else tmp = Float64(Float64(y / Float64(x * x)) * y) ^ -1.0; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (x * x) / (y * y); tmp = 0.0; if ((t_1 <= 2e-225) || ~((t_1 <= Inf))) tmp = (z / t) / (t / z); else tmp = ((y / (x * x)) * y) ^ -1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, 2e-225], N[Not[LessEqual[t$95$1, Infinity]], $MachinePrecision]], N[(N[(z / t), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], -1.0], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot x}{y \cdot y}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-225} \lor \neg \left(t\_1 \leq \infty\right):\\
\;\;\;\;\frac{\frac{z}{t}}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{y}{x \cdot x} \cdot y\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 1.9999999999999999e-225 or +inf.0 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 56.4%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6480.2
Applied rewrites80.2%
Applied rewrites71.0%
Applied rewrites84.7%
if 1.9999999999999999e-225 < (/.f64 (*.f64 x x) (*.f64 y y)) < +inf.0Initial program 81.3%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6484.9
Applied rewrites84.9%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6483.9
Applied rewrites83.9%
Applied rewrites83.3%
Applied rewrites82.4%
Final simplification83.5%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* x x) (* y y))))
(if (or (<= t_1 2e-225) (not (<= t_1 INFINITY)))
(* (/ z t) (/ z t))
(pow (* (/ y (* x x)) y) -1.0))))
double code(double x, double y, double z, double t) {
double t_1 = (x * x) / (y * y);
double tmp;
if ((t_1 <= 2e-225) || !(t_1 <= ((double) INFINITY))) {
tmp = (z / t) * (z / t);
} else {
tmp = pow(((y / (x * x)) * y), -1.0);
}
return tmp;
}
public static double code(double x, double y, double z, double t) {
double t_1 = (x * x) / (y * y);
double tmp;
if ((t_1 <= 2e-225) || !(t_1 <= Double.POSITIVE_INFINITY)) {
tmp = (z / t) * (z / t);
} else {
tmp = Math.pow(((y / (x * x)) * y), -1.0);
}
return tmp;
}
def code(x, y, z, t): t_1 = (x * x) / (y * y) tmp = 0 if (t_1 <= 2e-225) or not (t_1 <= math.inf): tmp = (z / t) * (z / t) else: tmp = math.pow(((y / (x * x)) * y), -1.0) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(x * x) / Float64(y * y)) tmp = 0.0 if ((t_1 <= 2e-225) || !(t_1 <= Inf)) tmp = Float64(Float64(z / t) * Float64(z / t)); else tmp = Float64(Float64(y / Float64(x * x)) * y) ^ -1.0; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (x * x) / (y * y); tmp = 0.0; if ((t_1 <= 2e-225) || ~((t_1 <= Inf))) tmp = (z / t) * (z / t); else tmp = ((y / (x * x)) * y) ^ -1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, 2e-225], N[Not[LessEqual[t$95$1, Infinity]], $MachinePrecision]], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], -1.0], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot x}{y \cdot y}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-225} \lor \neg \left(t\_1 \leq \infty\right):\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{y}{x \cdot x} \cdot y\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 1.9999999999999999e-225 or +inf.0 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 56.4%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6476.0
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.5
Applied rewrites99.5%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6484.6
Applied rewrites84.6%
if 1.9999999999999999e-225 < (/.f64 (*.f64 x x) (*.f64 y y)) < +inf.0Initial program 81.3%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6484.9
Applied rewrites84.9%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6483.9
Applied rewrites83.9%
Applied rewrites83.3%
Applied rewrites82.4%
Final simplification83.4%
(FPCore (x y z t) :precision binary64 (if (<= (/ (* x x) (* y y)) 2e-225) (/ (/ z t) (/ t z)) (pow (/ (/ y x) (/ x y)) -1.0)))
double code(double x, double y, double z, double t) {
double tmp;
if (((x * x) / (y * y)) <= 2e-225) {
tmp = (z / t) / (t / z);
} else {
tmp = pow(((y / x) / (x / y)), -1.0);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (((x * x) / (y * y)) <= 2d-225) then
tmp = (z / t) / (t / z)
else
tmp = ((y / x) / (x / y)) ** (-1.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((x * x) / (y * y)) <= 2e-225) {
tmp = (z / t) / (t / z);
} else {
tmp = Math.pow(((y / x) / (x / y)), -1.0);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((x * x) / (y * y)) <= 2e-225: tmp = (z / t) / (t / z) else: tmp = math.pow(((y / x) / (x / y)), -1.0) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(Float64(x * x) / Float64(y * y)) <= 2e-225) tmp = Float64(Float64(z / t) / Float64(t / z)); else tmp = Float64(Float64(y / x) / Float64(x / y)) ^ -1.0; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((x * x) / (y * y)) <= 2e-225) tmp = (z / t) / (t / z); else tmp = ((y / x) / (x / y)) ^ -1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision], 2e-225], N[(N[(z / t), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(y / x), $MachinePrecision] / N[(x / y), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x \cdot x}{y \cdot y} \leq 2 \cdot 10^{-225}:\\
\;\;\;\;\frac{\frac{z}{t}}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\frac{y}{x}}{\frac{x}{y}}\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 1.9999999999999999e-225Initial program 72.7%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6489.4
Applied rewrites89.4%
Applied rewrites79.7%
Applied rewrites94.3%
if 1.9999999999999999e-225 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 68.6%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6480.8
Applied rewrites80.8%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Applied rewrites78.9%
Final simplification84.3%
(FPCore (x y z t) :precision binary64 (if (<= (/ (* x x) (* y y)) 2e-225) (/ (/ z t) (/ t z)) (pow (* (/ y x) (/ y x)) -1.0)))
double code(double x, double y, double z, double t) {
double tmp;
if (((x * x) / (y * y)) <= 2e-225) {
tmp = (z / t) / (t / z);
} else {
tmp = pow(((y / x) * (y / x)), -1.0);
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (((x * x) / (y * y)) <= 2d-225) then
tmp = (z / t) / (t / z)
else
tmp = ((y / x) * (y / x)) ** (-1.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((x * x) / (y * y)) <= 2e-225) {
tmp = (z / t) / (t / z);
} else {
tmp = Math.pow(((y / x) * (y / x)), -1.0);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((x * x) / (y * y)) <= 2e-225: tmp = (z / t) / (t / z) else: tmp = math.pow(((y / x) * (y / x)), -1.0) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(Float64(x * x) / Float64(y * y)) <= 2e-225) tmp = Float64(Float64(z / t) / Float64(t / z)); else tmp = Float64(Float64(y / x) * Float64(y / x)) ^ -1.0; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((x * x) / (y * y)) <= 2e-225) tmp = (z / t) / (t / z); else tmp = ((y / x) * (y / x)) ^ -1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision], 2e-225], N[(N[(z / t), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(y / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x \cdot x}{y \cdot y} \leq 2 \cdot 10^{-225}:\\
\;\;\;\;\frac{\frac{z}{t}}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{y}{x} \cdot \frac{y}{x}\right)}^{-1}\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 1.9999999999999999e-225Initial program 72.7%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6489.4
Applied rewrites89.4%
Applied rewrites79.7%
Applied rewrites94.3%
if 1.9999999999999999e-225 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 68.6%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
frac-addN/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6480.8
Applied rewrites80.8%
Taylor expanded in x around inf
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Final simplification84.3%
(FPCore (x y z t) :precision binary64 (fma (/ x y) (/ x y) (pow (/ z t) 2.0)))
double code(double x, double y, double z, double t) {
return fma((x / y), (x / y), pow((z / t), 2.0));
}
function code(x, y, z, t) return fma(Float64(x / y), Float64(x / y), (Float64(z / t) ^ 2.0)) end
code[x_, y_, z_, t_] := N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision] + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{x}{y}, \frac{x}{y}, {\left(\frac{z}{t}\right)}^{2}\right)
\end{array}
Initial program 70.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6482.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 5e+259)
(fma (/ x y) (/ x y) t_1)
(if (<= t_1 INFINITY)
(* (/ z (* t t)) z)
(+ (/ (* x x) (* y y)) (/ (* (/ z t) z) t))))))
double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 5e+259) {
tmp = fma((x / y), (x / y), t_1);
} else if (t_1 <= ((double) INFINITY)) {
tmp = (z / (t * t)) * z;
} else {
tmp = ((x * x) / (y * y)) + (((z / t) * z) / t);
}
return tmp;
}
function code(x, y, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 5e+259) tmp = fma(Float64(x / y), Float64(x / y), t_1); elseif (t_1 <= Inf) tmp = Float64(Float64(z / Float64(t * t)) * z); else tmp = Float64(Float64(Float64(x * x) / Float64(y * y)) + Float64(Float64(Float64(z / t) * z) / t)); end return tmp end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e+259], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[(N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(z / t), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{+259}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y}, \frac{x}{y}, t\_1\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot x}{y \cdot y} + \frac{\frac{z}{t} \cdot z}{t}\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 5.00000000000000033e259Initial program 80.5%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6497.3
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.5
Applied rewrites99.5%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f6497.3
Applied rewrites97.3%
if 5.00000000000000033e259 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 79.2%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6492.4
Applied rewrites92.4%
Applied rewrites95.6%
if +inf.0 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 0.0%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f6469.0
Applied rewrites69.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 5e+290)
(fma (/ x y) (/ x y) t_1)
(fma (/ (/ z t) t) z (* (/ (/ x y) y) x)))))
double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 5e+290) {
tmp = fma((x / y), (x / y), t_1);
} else {
tmp = fma(((z / t) / t), z, (((x / y) / y) * x));
}
return tmp;
}
function code(x, y, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 5e+290) tmp = fma(Float64(x / y), Float64(x / y), t_1); else tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(Float64(x / y) / y) * x)); end return tmp end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e+290], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{+290}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y}, \frac{x}{y}, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{\frac{x}{y}}{y} \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 4.9999999999999998e290Initial program 80.1%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6497.4
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.5
Applied rewrites99.5%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f6497.4
Applied rewrites97.4%
if 4.9999999999999998e290 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 58.2%
Taylor expanded in x around 0
+-commutativeN/A
unpow2N/A
associate-*l/N/A
lower-fma.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f64N/A
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6495.0
Applied rewrites95.0%
(FPCore (x y z t) :precision binary64 (if (<= (* z z) 2e+265) (+ (/ (/ x y) (/ y x)) (/ (* (/ z t) z) t)) (fma (/ (/ z t) t) z (* (/ (/ x y) y) x))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z * z) <= 2e+265) {
tmp = ((x / y) / (y / x)) + (((z / t) * z) / t);
} else {
tmp = fma(((z / t) / t), z, (((x / y) / y) * x));
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (Float64(z * z) <= 2e+265) tmp = Float64(Float64(Float64(x / y) / Float64(y / x)) + Float64(Float64(Float64(z / t) * z) / t)); else tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(Float64(x / y) / y) * x)); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e+265], N[(N[(N[(x / y), $MachinePrecision] / N[(y / x), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(z / t), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{+265}:\\
\;\;\;\;\frac{\frac{x}{y}}{\frac{y}{x}} + \frac{\frac{z}{t} \cdot z}{t}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{\frac{x}{y}}{y} \cdot x\right)\\
\end{array}
\end{array}
if (*.f64 z z) < 2.00000000000000013e265Initial program 73.0%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f6479.6
Applied rewrites79.6%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lift-/.f64N/A
clear-numN/A
lift-/.f64N/A
un-div-invN/A
lower-/.f6498.7
Applied rewrites98.7%
if 2.00000000000000013e265 < (*.f64 z z) Initial program 62.5%
Taylor expanded in x around 0
+-commutativeN/A
unpow2N/A
associate-*l/N/A
lower-fma.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f64N/A
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6498.5
Applied rewrites98.5%
(FPCore (x y z t) :precision binary64 (if (<= z 6.5e+166) (fma (/ x y) (/ x y) (/ (* (/ z t) z) t)) (fma (/ (/ z t) t) z (* (/ (/ x y) y) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= 6.5e+166) {
tmp = fma((x / y), (x / y), (((z / t) * z) / t));
} else {
tmp = fma(((z / t) / t), z, (((x / y) / y) * x));
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (z <= 6.5e+166) tmp = fma(Float64(x / y), Float64(x / y), Float64(Float64(Float64(z / t) * z) / t)); else tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(Float64(x / y) / y) * x)); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[z, 6.5e+166], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision] + N[(N[(N[(z / t), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 6.5 \cdot 10^{+166}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y}, \frac{x}{y}, \frac{\frac{z}{t} \cdot z}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{\frac{x}{y}}{y} \cdot x\right)\\
\end{array}
\end{array}
if z < 6.5000000000000005e166Initial program 71.6%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6485.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
associate-*l/N/A
lift-*.f64N/A
lower-/.f6497.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6497.3
Applied rewrites97.3%
if 6.5000000000000005e166 < z Initial program 56.5%
Taylor expanded in x around 0
+-commutativeN/A
unpow2N/A
associate-*l/N/A
lower-fma.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f64N/A
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6496.2
Applied rewrites96.2%
(FPCore (x y z t) :precision binary64 (if (<= x 6e+172) (* (/ z t) (/ z t)) (* (/ z (* t t)) z)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= 6e+172) {
tmp = (z / t) * (z / t);
} else {
tmp = (z / (t * t)) * z;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= 6d+172) then
tmp = (z / t) * (z / t)
else
tmp = (z / (t * t)) * z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= 6e+172) {
tmp = (z / t) * (z / t);
} else {
tmp = (z / (t * t)) * z;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= 6e+172: tmp = (z / t) * (z / t) else: tmp = (z / (t * t)) * z return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= 6e+172) tmp = Float64(Float64(z / t) * Float64(z / t)); else tmp = Float64(Float64(z / Float64(t * t)) * z); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= 6e+172) tmp = (z / t) * (z / t); else tmp = (z / (t * t)) * z; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, 6e+172], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 6 \cdot 10^{+172}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\end{array}
\end{array}
if x < 5.9999999999999998e172Initial program 69.8%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6481.9
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6456.3
Applied rewrites56.3%
if 5.9999999999999998e172 < x Initial program 72.0%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6446.0
Applied rewrites46.0%
Applied rewrites57.4%
Final simplification56.4%
(FPCore (x y z t) :precision binary64 (* (/ z (* t t)) z))
double code(double x, double y, double z, double t) {
return (z / (t * t)) * z;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (z / (t * t)) * z
end function
public static double code(double x, double y, double z, double t) {
return (z / (t * t)) * z;
}
def code(x, y, z, t): return (z / (t * t)) * z
function code(x, y, z, t) return Float64(Float64(z / Float64(t * t)) * z) end
function tmp = code(x, y, z, t) tmp = (z / (t * t)) * z; end
code[x_, y_, z_, t_] := N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]
\begin{array}{l}
\\
\frac{z}{t \cdot t} \cdot z
\end{array}
Initial program 70.0%
Taylor expanded in x around 0
unpow2N/A
associate-*l/N/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6454.0
Applied rewrites54.0%
Applied rewrites52.4%
(FPCore (x y z t) :precision binary64 (+ (pow (/ x y) 2.0) (pow (/ z t) 2.0)))
double code(double x, double y, double z, double t) {
return pow((x / y), 2.0) + pow((z / t), 2.0);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = ((x / y) ** 2.0d0) + ((z / t) ** 2.0d0)
end function
public static double code(double x, double y, double z, double t) {
return Math.pow((x / y), 2.0) + Math.pow((z / t), 2.0);
}
def code(x, y, z, t): return math.pow((x / y), 2.0) + math.pow((z / t), 2.0)
function code(x, y, z, t) return Float64((Float64(x / y) ^ 2.0) + (Float64(z / t) ^ 2.0)) end
function tmp = code(x, y, z, t) tmp = ((x / y) ^ 2.0) + ((z / t) ^ 2.0); end
code[x_, y_, z_, t_] := N[(N[Power[N[(x / y), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{\left(\frac{x}{y}\right)}^{2} + {\left(\frac{z}{t}\right)}^{2}
\end{array}
herbie shell --seed 2024318
(FPCore (x y z t)
:name "Graphics.Rasterific.Svg.PathConverter:arcToSegments from rasterific-svg-0.2.3.1"
:precision binary64
:alt
(! :herbie-platform default (+ (pow (/ x y) 2) (pow (/ z t) 2)))
(+ (/ (* x x) (* y y)) (/ (* z z) (* t t))))