
(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 12 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}
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (if (<= y_m 2.6e-169) (fma (- z) (/ z (* (- t) t)) (pow (/ x y_m) 2.0)) (fma (/ (/ x y_m) y_m) x (pow (/ z t) 2.0))))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double tmp;
if (y_m <= 2.6e-169) {
tmp = fma(-z, (z / (-t * t)), pow((x / y_m), 2.0));
} else {
tmp = fma(((x / y_m) / y_m), x, pow((z / t), 2.0));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) tmp = 0.0 if (y_m <= 2.6e-169) tmp = fma(Float64(-z), Float64(z / Float64(Float64(-t) * t)), (Float64(x / y_m) ^ 2.0)); else tmp = fma(Float64(Float64(x / y_m) / y_m), x, (Float64(z / t) ^ 2.0)); end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := If[LessEqual[y$95$m, 2.6e-169], N[((-z) * N[(z / N[((-t) * t), $MachinePrecision]), $MachinePrecision] + N[Power[N[(x / y$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 2.6 \cdot 10^{-169}:\\
\;\;\;\;\mathsf{fma}\left(-z, \frac{z}{\left(-t\right) \cdot t}, {\left(\frac{x}{y\_m}\right)}^{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{x}{y\_m}}{y\_m}, x, {\left(\frac{z}{t}\right)}^{2}\right)\\
\end{array}
\end{array}
if y < 2.60000000000000014e-169Initial program 63.5%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
associate-/l*N/A
lower-fma.f64N/A
lower-neg.f64N/A
frac-2negN/A
remove-double-negN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6467.0
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6489.3
Applied rewrites89.3%
if 2.60000000000000014e-169 < y Initial program 69.4%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6478.0
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6498.5
Applied rewrites98.5%
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (if (<= (/ (* z z) (* t t)) 1e+292) (fma (- z) (/ z (* (- t) t)) (pow (/ x y_m) 2.0)) (fma (- x) (/ x (* (- y_m) y_m)) (pow (/ z t) 2.0))))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double tmp;
if (((z * z) / (t * t)) <= 1e+292) {
tmp = fma(-z, (z / (-t * t)), pow((x / y_m), 2.0));
} else {
tmp = fma(-x, (x / (-y_m * y_m)), pow((z / t), 2.0));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) tmp = 0.0 if (Float64(Float64(z * z) / Float64(t * t)) <= 1e+292) tmp = fma(Float64(-z), Float64(z / Float64(Float64(-t) * t)), (Float64(x / y_m) ^ 2.0)); else tmp = fma(Float64(-x), Float64(x / Float64(Float64(-y_m) * y_m)), (Float64(z / t) ^ 2.0)); end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := If[LessEqual[N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision], 1e+292], N[((-z) * N[(z / N[((-t) * t), $MachinePrecision]), $MachinePrecision] + N[Power[N[(x / y$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[((-x) * N[(x / N[((-y$95$m) * y$95$m), $MachinePrecision]), $MachinePrecision] + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{z \cdot z}{t \cdot t} \leq 10^{+292}:\\
\;\;\;\;\mathsf{fma}\left(-z, \frac{z}{\left(-t\right) \cdot t}, {\left(\frac{x}{y\_m}\right)}^{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, \frac{x}{\left(-y\_m\right) \cdot y\_m}, {\left(\frac{z}{t}\right)}^{2}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 1e292Initial program 65.5%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
associate-/l*N/A
lower-fma.f64N/A
lower-neg.f64N/A
frac-2negN/A
remove-double-negN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6466.8
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6494.8
Applied rewrites94.8%
if 1e292 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 66.2%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
associate-/l*N/A
lower-fma.f64N/A
lower-neg.f64N/A
frac-2negN/A
remove-double-negN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.9
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 1e+292)
(+ (* (/ x y_m) (/ x y_m)) t_1)
(fma (- x) (/ x (* (- y_m) y_m)) (pow (/ z t) 2.0)))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 1e+292) {
tmp = ((x / y_m) * (x / y_m)) + t_1;
} else {
tmp = fma(-x, (x / (-y_m * y_m)), pow((z / t), 2.0));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 1e+292) tmp = Float64(Float64(Float64(x / y_m) * Float64(x / y_m)) + t_1); else tmp = fma(Float64(-x), Float64(x / Float64(Float64(-y_m) * y_m)), (Float64(z / t) ^ 2.0)); end return tmp end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e+292], N[(N[(N[(x / y$95$m), $MachinePrecision] * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[((-x) * N[(x / N[((-y$95$m) * y$95$m), $MachinePrecision]), $MachinePrecision] + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 10^{+292}:\\
\;\;\;\;\frac{x}{y\_m} \cdot \frac{x}{y\_m} + t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, \frac{x}{\left(-y\_m\right) \cdot y\_m}, {\left(\frac{z}{t}\right)}^{2}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 1e292Initial program 65.5%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6493.4
Applied rewrites93.4%
if 1e292 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 66.2%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
associate-/l*N/A
lower-fma.f64N/A
lower-neg.f64N/A
frac-2negN/A
remove-double-negN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.9
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* x x) (* y_m y_m))))
(if (<= t_1 1e-318)
(* (/ z t) (/ z t))
(if (<= t_1 5e+256) (fma (/ z (* t t)) z t_1) (* (/ (/ x y_m) y_m) x)))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (x * x) / (y_m * y_m);
double tmp;
if (t_1 <= 1e-318) {
tmp = (z / t) * (z / t);
} else if (t_1 <= 5e+256) {
tmp = fma((z / (t * t)), z, t_1);
} else {
tmp = ((x / y_m) / y_m) * x;
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(x * x) / Float64(y_m * y_m)) tmp = 0.0 if (t_1 <= 1e-318) tmp = Float64(Float64(z / t) * Float64(z / t)); elseif (t_1 <= 5e+256) tmp = fma(Float64(z / Float64(t * t)), z, t_1); else tmp = Float64(Float64(Float64(x / y_m) / y_m) * x); end return tmp end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(x * x), $MachinePrecision] / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e-318], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+256], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z + t$95$1), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{x \cdot x}{y\_m \cdot y\_m}\\
\mathbf{if}\;t\_1 \leq 10^{-318}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+256}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{t \cdot t}, z, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y\_m}}{y\_m} \cdot x\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 9.9999875e-319Initial program 67.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6470.5
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6496.2
Applied rewrites96.2%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.7
Applied rewrites92.7%
if 9.9999875e-319 < (/.f64 (*.f64 x x) (*.f64 y y)) < 5.00000000000000015e256Initial program 89.9%
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-/.f6497.4
Applied rewrites97.4%
Applied rewrites94.7%
Applied rewrites90.7%
if 5.00000000000000015e256 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 55.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6488.0
Applied rewrites88.0%
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
lift-/.f64N/A
associate-*r/N/A
associate-*l/N/A
lift-/.f64N/A
sqrt-prodN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6416.7
Applied rewrites16.7%
Taylor expanded in x around -inf
associate-*r/N/A
mul-1-negN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-fracN/A
remove-double-negN/A
unpow2N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6477.4
Applied rewrites77.4%
Final simplification85.9%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* x x) (* y_m y_m))))
(if (<= t_1 1e-318)
(* (/ z t) (/ z t))
(if (<= t_1 5e+256)
(fma (/ z (* t t)) z (* (/ x (* y_m y_m)) x))
(* (/ (/ x y_m) y_m) x)))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (x * x) / (y_m * y_m);
double tmp;
if (t_1 <= 1e-318) {
tmp = (z / t) * (z / t);
} else if (t_1 <= 5e+256) {
tmp = fma((z / (t * t)), z, ((x / (y_m * y_m)) * x));
} else {
tmp = ((x / y_m) / y_m) * x;
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(x * x) / Float64(y_m * y_m)) tmp = 0.0 if (t_1 <= 1e-318) tmp = Float64(Float64(z / t) * Float64(z / t)); elseif (t_1 <= 5e+256) tmp = fma(Float64(z / Float64(t * t)), z, Float64(Float64(x / Float64(y_m * y_m)) * x)); else tmp = Float64(Float64(Float64(x / y_m) / y_m) * x); end return tmp end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(x * x), $MachinePrecision] / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e-318], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+256], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z + N[(N[(x / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{x \cdot x}{y\_m \cdot y\_m}\\
\mathbf{if}\;t\_1 \leq 10^{-318}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+256}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{t \cdot t}, z, \frac{x}{y\_m \cdot y\_m} \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y\_m}}{y\_m} \cdot x\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 9.9999875e-319Initial program 67.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6470.5
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6496.2
Applied rewrites96.2%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.7
Applied rewrites92.7%
if 9.9999875e-319 < (/.f64 (*.f64 x x) (*.f64 y y)) < 5.00000000000000015e256Initial program 89.9%
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-/.f6497.4
Applied rewrites97.4%
Applied rewrites93.3%
Applied rewrites90.7%
if 5.00000000000000015e256 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 55.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6488.0
Applied rewrites88.0%
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
lift-/.f64N/A
associate-*r/N/A
associate-*l/N/A
lift-/.f64N/A
sqrt-prodN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6416.7
Applied rewrites16.7%
Taylor expanded in x around -inf
associate-*r/N/A
mul-1-negN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-fracN/A
remove-double-negN/A
unpow2N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6477.4
Applied rewrites77.4%
Final simplification85.9%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 2e-113)
(+ (* (/ x y_m) (/ x y_m)) t_1)
(fma (/ (/ z t) t) z (* (/ (/ x y_m) y_m) x)))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 2e-113) {
tmp = ((x / y_m) * (x / y_m)) + t_1;
} else {
tmp = fma(((z / t) / t), z, (((x / y_m) / y_m) * x));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 2e-113) tmp = Float64(Float64(Float64(x / y_m) * Float64(x / y_m)) + t_1); else tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(Float64(x / y_m) / y_m) * x)); end return tmp end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e-113], N[(N[(N[(x / y$95$m), $MachinePrecision] * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-113}:\\
\;\;\;\;\frac{x}{y\_m} \cdot \frac{x}{y\_m} + t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{\frac{x}{y\_m}}{y\_m} \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 1.99999999999999996e-113Initial program 63.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6491.9
Applied rewrites91.9%
if 1.99999999999999996e-113 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 67.3%
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.7
Applied rewrites96.7%
Final simplification94.6%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (or (<= t_1 1e-39) (not (<= t_1 INFINITY)))
(* (/ (/ x y_m) y_m) x)
(* (/ z (* t t)) z))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if ((t_1 <= 1e-39) || !(t_1 <= ((double) INFINITY))) {
tmp = ((x / y_m) / y_m) * x;
} else {
tmp = (z / (t * t)) * z;
}
return tmp;
}
y_m = Math.abs(y);
public static double code(double x, double y_m, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if ((t_1 <= 1e-39) || !(t_1 <= Double.POSITIVE_INFINITY)) {
tmp = ((x / y_m) / y_m) * x;
} else {
tmp = (z / (t * t)) * z;
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m, z, t): t_1 = (z * z) / (t * t) tmp = 0 if (t_1 <= 1e-39) or not (t_1 <= math.inf): tmp = ((x / y_m) / y_m) * x else: tmp = (z / (t * t)) * z return tmp
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if ((t_1 <= 1e-39) || !(t_1 <= Inf)) tmp = Float64(Float64(Float64(x / y_m) / y_m) * x); else tmp = Float64(Float64(z / Float64(t * t)) * z); end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m, z, t) t_1 = (z * z) / (t * t); tmp = 0.0; if ((t_1 <= 1e-39) || ~((t_1 <= Inf))) tmp = ((x / y_m) / y_m) * x; else tmp = (z / (t * t)) * z; end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, 1e-39], N[Not[LessEqual[t$95$1, Infinity]], $MachinePrecision]], N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 10^{-39} \lor \neg \left(t\_1 \leq \infty\right):\\
\;\;\;\;\frac{\frac{x}{y\_m}}{y\_m} \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 9.99999999999999929e-40 or +inf.0 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 53.5%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6475.1
Applied rewrites75.1%
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
lift-/.f64N/A
associate-*r/N/A
associate-*l/N/A
lift-/.f64N/A
sqrt-prodN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6424.5
Applied rewrites24.5%
Taylor expanded in x around -inf
associate-*r/N/A
mul-1-negN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-fracN/A
remove-double-negN/A
unpow2N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6471.5
Applied rewrites71.5%
if 9.99999999999999929e-40 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 80.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-/.f6488.3
Applied rewrites88.3%
Applied rewrites86.2%
Final simplification78.2%
y_m = (fabs.f64 y)
(FPCore (x y_m z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 2e+227)
(+ (* (/ x y_m) (/ x y_m)) t_1)
(fma (/ (/ z t) t) z (* (/ x (* y_m y_m)) x)))))y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if (t_1 <= 2e+227) {
tmp = ((x / y_m) * (x / y_m)) + t_1;
} else {
tmp = fma(((z / t) / t), z, ((x / (y_m * y_m)) * x));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if (t_1 <= 2e+227) tmp = Float64(Float64(Float64(x / y_m) * Float64(x / y_m)) + t_1); else tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(x / Float64(y_m * y_m)) * x)); end return tmp end
y_m = N[Abs[y], $MachinePrecision]
code[x_, y$95$m_, z_, t_] := Block[{t$95$1 = N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e+227], N[(N[(N[(x / y$95$m), $MachinePrecision] * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(x / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{+227}:\\
\;\;\;\;\frac{x}{y\_m} \cdot \frac{x}{y\_m} + t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{x}{y\_m \cdot y\_m} \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2.0000000000000002e227Initial program 66.4%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6493.2
Applied rewrites93.2%
if 2.0000000000000002e227 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 65.0%
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.9
Applied rewrites95.9%
Applied rewrites95.0%
Final simplification94.0%
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (if (<= (/ (* x x) (* y_m y_m)) 2e+295) (fma (/ (/ z t) t) z (* (/ x (* y_m y_m)) x)) (fma (/ z (* t t)) z (* (/ (/ x y_m) y_m) x))))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double tmp;
if (((x * x) / (y_m * y_m)) <= 2e+295) {
tmp = fma(((z / t) / t), z, ((x / (y_m * y_m)) * x));
} else {
tmp = fma((z / (t * t)), z, (((x / y_m) / y_m) * x));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) tmp = 0.0 if (Float64(Float64(x * x) / Float64(y_m * y_m)) <= 2e+295) tmp = fma(Float64(Float64(z / t) / t), z, Float64(Float64(x / Float64(y_m * y_m)) * x)); else tmp = fma(Float64(z / Float64(t * t)), z, Float64(Float64(Float64(x / y_m) / y_m) * x)); end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := If[LessEqual[N[(N[(x * x), $MachinePrecision] / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision], 2e+295], N[(N[(N[(z / t), $MachinePrecision] / t), $MachinePrecision] * z + N[(N[(x / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z + N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{x \cdot x}{y\_m \cdot y\_m} \leq 2 \cdot 10^{+295}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{z}{t}}{t}, z, \frac{x}{y\_m \cdot y\_m} \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{t \cdot t}, z, \frac{\frac{x}{y\_m}}{y\_m} \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 2e295Initial program 72.3%
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-/.f6494.2
Applied rewrites94.2%
Applied rewrites92.3%
if 2e295 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 56.7%
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-/.f6491.0
Applied rewrites91.0%
Applied rewrites90.2%
Final simplification91.4%
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (if (<= (/ (* x x) (* y_m y_m)) 1e-318) (* (/ z t) (/ z t)) (fma (/ z (* t t)) z (* (/ (/ x y_m) y_m) x))))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double tmp;
if (((x * x) / (y_m * y_m)) <= 1e-318) {
tmp = (z / t) * (z / t);
} else {
tmp = fma((z / (t * t)), z, (((x / y_m) / y_m) * x));
}
return tmp;
}
y_m = abs(y) function code(x, y_m, z, t) tmp = 0.0 if (Float64(Float64(x * x) / Float64(y_m * y_m)) <= 1e-318) tmp = Float64(Float64(z / t) * Float64(z / t)); else tmp = fma(Float64(z / Float64(t * t)), z, Float64(Float64(Float64(x / y_m) / y_m) * x)); end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := If[LessEqual[N[(N[(x * x), $MachinePrecision] / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision], 1e-318], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z + N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{x \cdot x}{y\_m \cdot y\_m} \leq 10^{-318}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{t \cdot t}, z, \frac{\frac{x}{y\_m}}{y\_m} \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 9.9999875e-319Initial program 67.0%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6470.5
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6496.2
Applied rewrites96.2%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.7
Applied rewrites92.7%
if 9.9999875e-319 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 64.9%
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-/.f6492.8
Applied rewrites92.8%
Applied rewrites89.9%
Final simplification91.1%
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (if (<= (/ (* x x) (* y_m y_m)) 6e+122) (* (/ z t) (/ z t)) (* (/ (/ x y_m) y_m) x)))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
double tmp;
if (((x * x) / (y_m * y_m)) <= 6e+122) {
tmp = (z / t) * (z / t);
} else {
tmp = ((x / y_m) / y_m) * x;
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (((x * x) / (y_m * y_m)) <= 6d+122) then
tmp = (z / t) * (z / t)
else
tmp = ((x / y_m) / y_m) * x
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m, double z, double t) {
double tmp;
if (((x * x) / (y_m * y_m)) <= 6e+122) {
tmp = (z / t) * (z / t);
} else {
tmp = ((x / y_m) / y_m) * x;
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m, z, t): tmp = 0 if ((x * x) / (y_m * y_m)) <= 6e+122: tmp = (z / t) * (z / t) else: tmp = ((x / y_m) / y_m) * x return tmp
y_m = abs(y) function code(x, y_m, z, t) tmp = 0.0 if (Float64(Float64(x * x) / Float64(y_m * y_m)) <= 6e+122) tmp = Float64(Float64(z / t) * Float64(z / t)); else tmp = Float64(Float64(Float64(x / y_m) / y_m) * x); end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m, z, t) tmp = 0.0; if (((x * x) / (y_m * y_m)) <= 6e+122) tmp = (z / t) * (z / t); else tmp = ((x / y_m) / y_m) * x; end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := If[LessEqual[N[(N[(x * x), $MachinePrecision] / N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision], 6e+122], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] / y$95$m), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{x \cdot x}{y\_m \cdot y\_m} \leq 6 \cdot 10^{+122}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y\_m}}{y\_m} \cdot x\\
\end{array}
\end{array}
if (/.f64 (*.f64 x x) (*.f64 y y)) < 5.99999999999999972e122Initial program 72.6%
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lower-fma.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6475.8
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6496.9
Applied rewrites96.9%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6487.2
Applied rewrites87.2%
if 5.99999999999999972e122 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 58.2%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6487.5
Applied rewrites87.5%
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
lift-/.f64N/A
associate-*r/N/A
associate-*l/N/A
lift-/.f64N/A
sqrt-prodN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6418.3
Applied rewrites18.3%
Taylor expanded in x around -inf
associate-*r/N/A
mul-1-negN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-fracN/A
remove-double-negN/A
unpow2N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6475.7
Applied rewrites75.7%
y_m = (fabs.f64 y) (FPCore (x y_m z t) :precision binary64 (* (/ z (* t t)) z))
y_m = fabs(y);
double code(double x, double y_m, double z, double t) {
return (z / (t * t)) * z;
}
y_m = abs(y)
real(8) function code(x, y_m, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (z / (t * t)) * z
end function
y_m = Math.abs(y);
public static double code(double x, double y_m, double z, double t) {
return (z / (t * t)) * z;
}
y_m = math.fabs(y) def code(x, y_m, z, t): return (z / (t * t)) * z
y_m = abs(y) function code(x, y_m, z, t) return Float64(Float64(z / Float64(t * t)) * z) end
y_m = abs(y); function tmp = code(x, y_m, z, t) tmp = (z / (t * t)) * z; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_, z_, t_] := N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]
\begin{array}{l}
y_m = \left|y\right|
\\
\frac{z}{t \cdot t} \cdot z
\end{array}
Initial program 65.8%
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-/.f6460.4
Applied rewrites60.4%
Applied rewrites53.4%
Final simplification53.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 2024337
(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))))