
(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}
(FPCore (x y z t) :precision binary64 (fma (/ (/ x y) y) x (pow (/ z t) 2.0)))
double code(double x, double y, double z, double t) {
return fma(((x / y) / y), x, pow((z / t), 2.0));
}
function code(x, y, z, t) return fma(Float64(Float64(x / y) / y), x, (Float64(z / t) ^ 2.0)) end
code[x_, y_, z_, t_] := N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x + N[Power[N[(z / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{\frac{x}{y}}{y}, x, {\left(\frac{z}{t}\right)}^{2}\right)
\end{array}
Initial program 66.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-/.f6480.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6497.1
Applied rewrites97.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 0.0)
(* (/ x y) (/ x y))
(if (<= t_1 5e+261)
(fma (/ (/ x y) y) x t_1)
(fma (/ x (* y y)) x (/ (* (/ 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 <= 0.0) {
tmp = (x / y) * (x / y);
} else if (t_1 <= 5e+261) {
tmp = fma(((x / y) / y), x, t_1);
} else {
tmp = fma((x / (y * y)), x, (((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 <= 0.0) tmp = Float64(Float64(x / y) * Float64(x / y)); elseif (t_1 <= 5e+261) tmp = fma(Float64(Float64(x / y) / y), x, t_1); else tmp = fma(Float64(x / Float64(y * y)), x, 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, 0.0], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+261], N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x + t$95$1), $MachinePrecision], N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x + 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 0:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+261}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{x}{y}}{y}, x, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y \cdot y}, x, \frac{\frac{z}{t} \cdot z}{t}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 0.0Initial program 66.6%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6494.4
Applied rewrites94.4%
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.f6426.4
Applied rewrites26.4%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6494.4
Applied rewrites94.4%
if 0.0 < (/.f64 (*.f64 z z) (*.f64 t t)) < 5.0000000000000001e261Initial program 80.7%
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-/.f6496.9
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6497.5
Applied rewrites97.5%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f6496.9
Applied rewrites96.9%
if 5.0000000000000001e261 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 60.5%
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-/.f6467.2
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-*.f6496.0
Applied rewrites96.0%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-*.f64N/A
lower-/.f6492.0
Applied rewrites92.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 2e-79)
(* (/ x y) (/ x y))
(if (<= t_1 2e+212) (fma (/ x (* y y)) x t_1) (* (/ 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 <= 2e-79) {
tmp = (x / y) * (x / y);
} else if (t_1 <= 2e+212) {
tmp = fma((x / (y * y)), x, t_1);
} else {
tmp = (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 <= 2e-79) tmp = Float64(Float64(x / y) * Float64(x / y)); elseif (t_1 <= 2e+212) tmp = fma(Float64(x / Float64(y * y)), x, t_1); else tmp = Float64(Float64(z / t) * Float64(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, 2e-79], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+212], N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x + t$95$1), $MachinePrecision], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-79}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+212}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y \cdot y}, x, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2e-79Initial program 68.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6495.2
Applied rewrites95.2%
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.f6425.7
Applied rewrites25.7%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.9
Applied rewrites92.9%
if 2e-79 < (/.f64 (*.f64 z z) (*.f64 t t)) < 1.9999999999999998e212Initial program 82.8%
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-/.f6498.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.2
Applied rewrites99.2%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
sqr-neg-revN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
distribute-lft-neg-outN/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
frac-2neg-revN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6498.1
Applied rewrites98.1%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-*.f64N/A
lower-/.f6490.0
Applied rewrites90.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
times-fracN/A
lift-neg.f64N/A
lift-neg.f64N/A
frac-2negN/A
times-fracN/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f6490.0
Applied rewrites90.0%
if 1.9999999999999998e212 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 60.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-/.f6468.0
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.7
Applied rewrites99.7%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6484.1
Applied rewrites84.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* x x) (* y y))))
(if (<= t_1 1e+105)
(+ t_1 (* (/ z t) (/ z t)))
(fma (/ (/ z t) t) z (* (/ (/ x y) y) x)))))
double code(double x, double y, double z, double t) {
double t_1 = (x * x) / (y * y);
double tmp;
if (t_1 <= 1e+105) {
tmp = t_1 + ((z / t) * (z / t));
} else {
tmp = fma(((z / t) / t), z, (((x / y) / y) * x));
}
return tmp;
}
function code(x, y, z, t) t_1 = Float64(Float64(x * x) / Float64(y * y)) tmp = 0.0 if (t_1 <= 1e+105) tmp = Float64(t_1 + Float64(Float64(z / t) * Float64(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_] := Block[{t$95$1 = N[(N[(x * x), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e+105], N[(t$95$1 + N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $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}
t_1 := \frac{x \cdot x}{y \cdot y}\\
\mathbf{if}\;t\_1 \leq 10^{+105}:\\
\;\;\;\;t\_1 + \frac{z}{t} \cdot \frac{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 (*.f64 x x) (*.f64 y y)) < 9.9999999999999994e104Initial program 75.4%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6494.9
Applied rewrites94.9%
if 9.9999999999999994e104 < (/.f64 (*.f64 x x) (*.f64 y y)) Initial program 58.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-/.f6495.8
Applied rewrites95.8%
Final simplification95.4%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (or (<= t_1 2e-79) (not (<= t_1 INFINITY)))
(* (/ x y) (/ x y))
(* (/ z (* t t)) z))))
double code(double x, double y, double z, double t) {
double t_1 = (z * z) / (t * t);
double tmp;
if ((t_1 <= 2e-79) || !(t_1 <= ((double) INFINITY))) {
tmp = (x / y) * (x / y);
} else {
tmp = (z / (t * t)) * z;
}
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 <= 2e-79) || !(t_1 <= Double.POSITIVE_INFINITY)) {
tmp = (x / y) * (x / y);
} else {
tmp = (z / (t * t)) * z;
}
return tmp;
}
def code(x, y, z, t): t_1 = (z * z) / (t * t) tmp = 0 if (t_1 <= 2e-79) or not (t_1 <= math.inf): tmp = (x / y) * (x / y) else: tmp = (z / (t * t)) * z return tmp
function code(x, y, z, t) t_1 = Float64(Float64(z * z) / Float64(t * t)) tmp = 0.0 if ((t_1 <= 2e-79) || !(t_1 <= Inf)) tmp = Float64(Float64(x / y) * Float64(x / y)); else tmp = Float64(Float64(z / Float64(t * t)) * z); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (z * z) / (t * t); tmp = 0.0; if ((t_1 <= 2e-79) || ~((t_1 <= Inf))) tmp = (x / y) * (x / y); else tmp = (z / (t * t)) * z; 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[Or[LessEqual[t$95$1, 2e-79], N[Not[LessEqual[t$95$1, Infinity]], $MachinePrecision]], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-79} \lor \neg \left(t\_1 \leq \infty\right):\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2e-79 or +inf.0 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 53.2%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6474.2
Applied rewrites74.2%
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.f6420.0
Applied rewrites20.0%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6483.8
Applied rewrites83.8%
if 2e-79 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 79.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-/.f6486.0
Applied rewrites86.0%
Applied rewrites86.3%
Final simplification85.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 2e-79)
(* (/ x y) (/ x y))
(if (<= t_1 INFINITY) (* (/ 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 <= 2e-79) {
tmp = (x / y) * (x / y);
} else if (t_1 <= ((double) INFINITY)) {
tmp = (z / (t * t)) * z;
} else {
tmp = ((x / y) / y) * x;
}
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 <= 2e-79) {
tmp = (x / y) * (x / y);
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (z / (t * t)) * z;
} else {
tmp = ((x / y) / y) * x;
}
return tmp;
}
def code(x, y, z, t): t_1 = (z * z) / (t * t) tmp = 0 if t_1 <= 2e-79: tmp = (x / y) * (x / y) elif t_1 <= math.inf: tmp = (z / (t * t)) * z else: tmp = ((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 <= 2e-79) tmp = Float64(Float64(x / y) * Float64(x / y)); elseif (t_1 <= Inf) tmp = Float64(Float64(z / Float64(t * t)) * z); else tmp = Float64(Float64(Float64(x / y) / y) * x); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (z * z) / (t * t); tmp = 0.0; if (t_1 <= 2e-79) tmp = (x / y) * (x / y); elseif (t_1 <= Inf) tmp = (z / (t * t)) * z; else tmp = ((x / y) / y) * x; 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, 2e-79], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot z}{t \cdot t}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-79}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{z}{t \cdot t} \cdot z\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y} \cdot x\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2e-79Initial program 68.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6495.2
Applied rewrites95.2%
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.f6425.7
Applied rewrites25.7%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.9
Applied rewrites92.9%
if 2e-79 < (/.f64 (*.f64 z z) (*.f64 t t)) < +inf.0Initial program 79.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-/.f6486.0
Applied rewrites86.0%
Applied rewrites86.3%
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
lower-*.f64N/A
lower-/.f64N/A
lower-/.f640.0
Applied rewrites0.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.f640.0
Applied rewrites0.0%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6451.7
Applied rewrites51.7%
Taylor expanded in x around -inf
associate-*r/N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
mul-1-negN/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-/.f6451.7
Applied rewrites51.7%
Final simplification85.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* z z) (* t t))))
(if (<= t_1 5e+261)
(+ (* (/ x y) (/ x y)) t_1)
(fma (/ x (* y y)) x (/ (* (/ 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+261) {
tmp = ((x / y) * (x / y)) + t_1;
} else {
tmp = fma((x / (y * y)), x, (((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+261) tmp = Float64(Float64(Float64(x / y) * Float64(x / y)) + t_1); else tmp = fma(Float64(x / Float64(y * y)), x, 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+261], N[(N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x + 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^{+261}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y} + t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y \cdot y}, x, \frac{\frac{z}{t} \cdot z}{t}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 5.0000000000000001e261Initial program 72.0%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6496.0
Applied rewrites96.0%
if 5.0000000000000001e261 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 60.5%
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-/.f6467.2
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-*.f6496.0
Applied rewrites96.0%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-*.f64N/A
lower-/.f6492.0
Applied rewrites92.0%
(FPCore (x y z t) :precision binary64 (if (<= (/ (* z z) (* t t)) 2e-79) (* (/ x y) (/ x y)) (fma (/ x (* y y)) x (/ (* (/ z t) z) t))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * z) / (t * t)) <= 2e-79) {
tmp = (x / y) * (x / y);
} else {
tmp = fma((x / (y * y)), x, (((z / t) * z) / t));
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (Float64(Float64(z * z) / Float64(t * t)) <= 2e-79) tmp = Float64(Float64(x / y) * Float64(x / y)); else tmp = fma(Float64(x / Float64(y * y)), x, Float64(Float64(Float64(z / t) * z) / t)); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision], 2e-79], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[(N[(z / t), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{z \cdot z}{t \cdot t} \leq 2 \cdot 10^{-79}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y \cdot y}, x, \frac{\frac{z}{t} \cdot z}{t}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2e-79Initial program 68.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6495.2
Applied rewrites95.2%
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.f6425.7
Applied rewrites25.7%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.9
Applied rewrites92.9%
if 2e-79 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 65.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-/.f6474.7
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
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-*.f6496.9
Applied rewrites96.9%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-*.f64N/A
lower-/.f6491.4
Applied rewrites91.4%
(FPCore (x y z t)
:precision binary64
(if (<= t 2.55e-228)
(* (/ z t) (/ z t))
(if (<= t 1.35e+154)
(fma (/ x (* y y)) x (* z (/ z (* t t))))
(* (/ x y) (/ x y)))))
double code(double x, double y, double z, double t) {
double tmp;
if (t <= 2.55e-228) {
tmp = (z / t) * (z / t);
} else if (t <= 1.35e+154) {
tmp = fma((x / (y * y)), x, (z * (z / (t * t))));
} else {
tmp = (x / y) * (x / y);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (t <= 2.55e-228) tmp = Float64(Float64(z / t) * Float64(z / t)); elseif (t <= 1.35e+154) tmp = fma(Float64(x / Float64(y * y)), x, Float64(z * Float64(z / Float64(t * t)))); else tmp = Float64(Float64(x / y) * Float64(x / y)); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[t, 2.55e-228], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.35e+154], N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] * x + N[(z * N[(z / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.55 \cdot 10^{-228}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{+154}:\\
\;\;\;\;\mathsf{fma}\left(\frac{x}{y \cdot y}, x, z \cdot \frac{z}{t \cdot t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\end{array}
\end{array}
if t < 2.5500000000000001e-228Initial program 68.9%
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-/.f6479.2
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6498.4
Applied rewrites98.4%
Taylor expanded in x around 0
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6467.4
Applied rewrites67.4%
if 2.5500000000000001e-228 < t < 1.35000000000000003e154Initial program 68.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-/.f6485.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%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
sqr-neg-revN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
sqr-neg-revN/A
distribute-lft-neg-outN/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
frac-2neg-revN/A
lower-/.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6489.4
Applied rewrites89.4%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-*.f64N/A
lower-/.f6484.4
Applied rewrites84.4%
if 1.35000000000000003e154 < t Initial program 52.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6474.0
Applied rewrites74.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.f6417.2
Applied rewrites17.2%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6485.8
Applied rewrites85.8%
Final simplification75.0%
(FPCore (x y z t) :precision binary64 (fma (/ (/ x y) y) x (/ (* (/ z t) z) t)))
double code(double x, double y, double z, double t) {
return fma(((x / y) / y), x, (((z / t) * z) / t));
}
function code(x, y, z, t) return fma(Float64(Float64(x / y) / y), x, Float64(Float64(Float64(z / t) * z) / t)) end
code[x_, y_, z_, t_] := N[(N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision] * x + N[(N[(N[(z / t), $MachinePrecision] * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{\frac{x}{y}}{y}, x, \frac{\frac{z}{t} \cdot z}{t}\right)
\end{array}
Initial program 66.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-/.f6480.1
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
pow2N/A
lower-pow.f64N/A
lower-/.f6497.1
Applied rewrites97.1%
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-/.f64N/A
times-fracN/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-*.f6494.7
Applied rewrites94.7%
(FPCore (x y z t) :precision binary64 (if (<= (/ (* z z) (* t t)) 2e-79) (* (/ x y) (/ x y)) (* (/ z t) (/ z t))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * z) / (t * t)) <= 2e-79) {
tmp = (x / y) * (x / y);
} else {
tmp = (z / t) * (z / t);
}
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 (((z * z) / (t * t)) <= 2d-79) then
tmp = (x / y) * (x / y)
else
tmp = (z / t) * (z / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((z * z) / (t * t)) <= 2e-79) {
tmp = (x / y) * (x / y);
} else {
tmp = (z / t) * (z / t);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((z * z) / (t * t)) <= 2e-79: tmp = (x / y) * (x / y) else: tmp = (z / t) * (z / t) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(Float64(z * z) / Float64(t * t)) <= 2e-79) tmp = Float64(Float64(x / y) * Float64(x / y)); else tmp = Float64(Float64(z / t) * Float64(z / t)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((z * z) / (t * t)) <= 2e-79) tmp = (x / y) * (x / y); else tmp = (z / t) * (z / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(N[(z * z), $MachinePrecision] / N[(t * t), $MachinePrecision]), $MachinePrecision], 2e-79], N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(z / t), $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{z \cdot z}{t \cdot t} \leq 2 \cdot 10^{-79}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{t} \cdot \frac{z}{t}\\
\end{array}
\end{array}
if (/.f64 (*.f64 z z) (*.f64 t t)) < 2e-79Initial program 68.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6495.2
Applied rewrites95.2%
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.f6425.7
Applied rewrites25.7%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-frac-negN/A
distribute-neg-frac2N/A
remove-double-negN/A
unpow2N/A
unpow2N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f6492.9
Applied rewrites92.9%
if 2e-79 < (/.f64 (*.f64 z z) (*.f64 t t)) Initial program 65.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-/.f6474.7
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-/.f6481.4
Applied rewrites81.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 66.6%
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-/.f6455.7
Applied rewrites55.7%
Applied rewrites53.9%
Final simplification53.9%
(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 2024320
(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))))