
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (* i (+ (+ alpha beta) i)))
(t_1 (+ (+ alpha beta) (* 2.0 i)))
(t_2 (* t_1 t_1)))
(/ (/ (* t_0 (+ (* beta alpha) t_0)) t_2) (- t_2 1.0))))
double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
t_0 = i * ((alpha + beta) + i)
t_1 = (alpha + beta) + (2.0d0 * i)
t_2 = t_1 * t_1
code = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0d0)
end function
public static double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
def code(alpha, beta, i): t_0 = i * ((alpha + beta) + i) t_1 = (alpha + beta) + (2.0 * i) t_2 = t_1 * t_1 return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0)
function code(alpha, beta, i) t_0 = Float64(i * Float64(Float64(alpha + beta) + i)) t_1 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_2 = Float64(t_1 * t_1) return Float64(Float64(Float64(t_0 * Float64(Float64(beta * alpha) + t_0)) / t_2) / Float64(t_2 - 1.0)) end
function tmp = code(alpha, beta, i) t_0 = i * ((alpha + beta) + i); t_1 = (alpha + beta) + (2.0 * i); t_2 = t_1 * t_1; tmp = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0); end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * N[(N[(alpha + beta), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * t$95$1), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[(N[(beta * alpha), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(t$95$2 - 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i \cdot \left(\left(\alpha + \beta\right) + i\right)\\
t_1 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_2 := t\_1 \cdot t\_1\\
\frac{\frac{t\_0 \cdot \left(\beta \cdot \alpha + t\_0\right)}{t\_2}}{t\_2 - 1}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (* i (+ (+ alpha beta) i)))
(t_1 (+ (+ alpha beta) (* 2.0 i)))
(t_2 (* t_1 t_1)))
(/ (/ (* t_0 (+ (* beta alpha) t_0)) t_2) (- t_2 1.0))))
double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
t_0 = i * ((alpha + beta) + i)
t_1 = (alpha + beta) + (2.0d0 * i)
t_2 = t_1 * t_1
code = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0d0)
end function
public static double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
def code(alpha, beta, i): t_0 = i * ((alpha + beta) + i) t_1 = (alpha + beta) + (2.0 * i) t_2 = t_1 * t_1 return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0)
function code(alpha, beta, i) t_0 = Float64(i * Float64(Float64(alpha + beta) + i)) t_1 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_2 = Float64(t_1 * t_1) return Float64(Float64(Float64(t_0 * Float64(Float64(beta * alpha) + t_0)) / t_2) / Float64(t_2 - 1.0)) end
function tmp = code(alpha, beta, i) t_0 = i * ((alpha + beta) + i); t_1 = (alpha + beta) + (2.0 * i); t_2 = t_1 * t_1; tmp = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0); end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * N[(N[(alpha + beta), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * t$95$1), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[(N[(beta * alpha), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(t$95$2 - 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i \cdot \left(\left(\alpha + \beta\right) + i\right)\\
t_1 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_2 := t\_1 \cdot t\_1\\
\frac{\frac{t\_0 \cdot \left(\beta \cdot \alpha + t\_0\right)}{t\_2}}{t\_2 - 1}
\end{array}
\end{array}
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ beta (fma i 2.0 alpha))) (t_1 (+ i (+ beta alpha))))
(*
(/
(* i (/ t_1 (+ alpha (fma i 2.0 beta))))
(+ alpha (+ (fma i 2.0 beta) 1.0)))
(/
(fma (/ t_1 t_0) i (* (* beta alpha) (/ 1.0 t_0)))
(+ alpha (+ (fma i 2.0 beta) -1.0))))))
double code(double alpha, double beta, double i) {
double t_0 = beta + fma(i, 2.0, alpha);
double t_1 = i + (beta + alpha);
return ((i * (t_1 / (alpha + fma(i, 2.0, beta)))) / (alpha + (fma(i, 2.0, beta) + 1.0))) * (fma((t_1 / t_0), i, ((beta * alpha) * (1.0 / t_0))) / (alpha + (fma(i, 2.0, beta) + -1.0)));
}
function code(alpha, beta, i) t_0 = Float64(beta + fma(i, 2.0, alpha)) t_1 = Float64(i + Float64(beta + alpha)) return Float64(Float64(Float64(i * Float64(t_1 / Float64(alpha + fma(i, 2.0, beta)))) / Float64(alpha + Float64(fma(i, 2.0, beta) + 1.0))) * Float64(fma(Float64(t_1 / t_0), i, Float64(Float64(beta * alpha) * Float64(1.0 / t_0))) / Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(beta + N[(i * 2.0 + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i * N[(t$95$1 / N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(t$95$1 / t$95$0), $MachinePrecision] * i + N[(N[(beta * alpha), $MachinePrecision] * N[(1.0 / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \beta + \mathsf{fma}\left(i, 2, \alpha\right)\\
t_1 := i + \left(\beta + \alpha\right)\\
\frac{i \cdot \frac{t\_1}{\alpha + \mathsf{fma}\left(i, 2, \beta\right)}}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + 1\right)} \cdot \frac{\mathsf{fma}\left(\frac{t\_1}{t\_0}, i, \left(\beta \cdot \alpha\right) \cdot \frac{1}{t\_0}\right)}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6444.4
Applied egg-rr44.4%
div-invN/A
+-commutativeN/A
associate-+r+N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6444.3
Applied egg-rr44.3%
*-commutativeN/A
distribute-rgt-inN/A
div-invN/A
*-commutativeN/A
+-commutativeN/A
+-commutativeN/A
associate-+r+N/A
associate-*l/N/A
accelerator-lowering-fma.f64N/A
Applied egg-rr92.5%
Final simplification92.5%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ beta (fma i 2.0 alpha))) (t_1 (+ i (+ beta alpha))))
(*
(/
(* i (/ t_1 (+ alpha (fma i 2.0 beta))))
(+ alpha (+ (fma i 2.0 beta) 1.0)))
(/
(fma t_1 (/ i t_0) (* (* beta alpha) (/ 1.0 t_0)))
(+ alpha (+ (fma i 2.0 beta) -1.0))))))
double code(double alpha, double beta, double i) {
double t_0 = beta + fma(i, 2.0, alpha);
double t_1 = i + (beta + alpha);
return ((i * (t_1 / (alpha + fma(i, 2.0, beta)))) / (alpha + (fma(i, 2.0, beta) + 1.0))) * (fma(t_1, (i / t_0), ((beta * alpha) * (1.0 / t_0))) / (alpha + (fma(i, 2.0, beta) + -1.0)));
}
function code(alpha, beta, i) t_0 = Float64(beta + fma(i, 2.0, alpha)) t_1 = Float64(i + Float64(beta + alpha)) return Float64(Float64(Float64(i * Float64(t_1 / Float64(alpha + fma(i, 2.0, beta)))) / Float64(alpha + Float64(fma(i, 2.0, beta) + 1.0))) * Float64(fma(t_1, Float64(i / t_0), Float64(Float64(beta * alpha) * Float64(1.0 / t_0))) / Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(beta + N[(i * 2.0 + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i * N[(t$95$1 / N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 * N[(i / t$95$0), $MachinePrecision] + N[(N[(beta * alpha), $MachinePrecision] * N[(1.0 / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \beta + \mathsf{fma}\left(i, 2, \alpha\right)\\
t_1 := i + \left(\beta + \alpha\right)\\
\frac{i \cdot \frac{t\_1}{\alpha + \mathsf{fma}\left(i, 2, \beta\right)}}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + 1\right)} \cdot \frac{\mathsf{fma}\left(t\_1, \frac{i}{t\_0}, \left(\beta \cdot \alpha\right) \cdot \frac{1}{t\_0}\right)}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6444.4
Applied egg-rr44.4%
div-invN/A
+-commutativeN/A
associate-+r+N/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6444.3
Applied egg-rr44.3%
*-commutativeN/A
distribute-rgt-inN/A
div-invN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6492.5
Applied egg-rr92.5%
Final simplification92.5%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (fma i 2.0 beta))))
(*
(/ (* i (/ (+ i (+ beta alpha)) t_0)) (+ alpha (+ (fma i 2.0 beta) 1.0)))
(/
(/ (fma i (+ alpha (+ i beta)) (* beta alpha)) t_0)
(+ alpha (+ (fma i 2.0 beta) -1.0))))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + fma(i, 2.0, beta);
return ((i * ((i + (beta + alpha)) / t_0)) / (alpha + (fma(i, 2.0, beta) + 1.0))) * ((fma(i, (alpha + (i + beta)), (beta * alpha)) / t_0) / (alpha + (fma(i, 2.0, beta) + -1.0)));
}
function code(alpha, beta, i) t_0 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(Float64(i * Float64(Float64(i + Float64(beta + alpha)) / t_0)) / Float64(alpha + Float64(fma(i, 2.0, beta) + 1.0))) * Float64(Float64(fma(i, Float64(alpha + Float64(i + beta)), Float64(beta * alpha)) / t_0) / Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i * N[(N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(i * N[(alpha + N[(i + beta), $MachinePrecision]), $MachinePrecision] + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{i \cdot \frac{i + \left(\beta + \alpha\right)}{t\_0}}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + 1\right)} \cdot \frac{\frac{\mathsf{fma}\left(i, \alpha + \left(i + \beta\right), \beta \cdot \alpha\right)}{t\_0}}{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6444.4
Applied egg-rr44.4%
Final simplification44.4%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ beta (fma i 2.0 alpha))))
(/
1.0
(*
(* t_1 (/ (+ alpha (+ (fma i 2.0 beta) 1.0)) (* i t_0)))
(*
(+ alpha (+ (fma i 2.0 beta) -1.0))
(/ t_1 (fma i t_0 (* beta alpha))))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = beta + fma(i, 2.0, alpha);
return 1.0 / ((t_1 * ((alpha + (fma(i, 2.0, beta) + 1.0)) / (i * t_0))) * ((alpha + (fma(i, 2.0, beta) + -1.0)) * (t_1 / fma(i, t_0, (beta * alpha)))));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(beta + fma(i, 2.0, alpha)) return Float64(1.0 / Float64(Float64(t_1 * Float64(Float64(alpha + Float64(fma(i, 2.0, beta) + 1.0)) / Float64(i * t_0))) * Float64(Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)) * Float64(t_1 / fma(i, t_0, Float64(beta * alpha)))))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(beta + N[(i * 2.0 + alpha), $MachinePrecision]), $MachinePrecision]}, N[(1.0 / N[(N[(t$95$1 * N[(N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / N[(i * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \beta + \mathsf{fma}\left(i, 2, \alpha\right)\\
\frac{1}{\left(t\_1 \cdot \frac{\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + 1\right)}{i \cdot t\_0}\right) \cdot \left(\left(\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)\right) \cdot \frac{t\_1}{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6444.4
Applied egg-rr44.4%
Applied egg-rr44.0%
Final simplification44.0%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ alpha (fma i 2.0 beta))))
(/
1.0
(*
(* (+ t_1 1.0) (/ t_1 (* i t_0)))
(*
(+ alpha (+ (fma i 2.0 beta) -1.0))
(/ t_1 (fma i t_0 (* beta alpha))))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = alpha + fma(i, 2.0, beta);
return 1.0 / (((t_1 + 1.0) * (t_1 / (i * t_0))) * ((alpha + (fma(i, 2.0, beta) + -1.0)) * (t_1 / fma(i, t_0, (beta * alpha)))));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(1.0 / Float64(Float64(Float64(t_1 + 1.0) * Float64(t_1 / Float64(i * t_0))) * Float64(Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)) * Float64(t_1 / fma(i, t_0, Float64(beta * alpha)))))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(1.0 / N[(N[(N[(t$95$1 + 1.0), $MachinePrecision] * N[(t$95$1 / N[(i * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{1}{\left(\left(t\_1 + 1\right) \cdot \frac{t\_1}{i \cdot t\_0}\right) \cdot \left(\left(\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)\right) \cdot \frac{t\_1}{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
clear-numN/A
clear-numN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
Applied egg-rr44.0%
Final simplification44.0%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ alpha (fma i 2.0 beta))))
(/
(* t_0 (/ i t_1))
(*
(+ t_1 1.0)
(*
(+ alpha (+ (fma i 2.0 beta) -1.0))
(/ t_1 (fma i t_0 (* beta alpha))))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = alpha + fma(i, 2.0, beta);
return (t_0 * (i / t_1)) / ((t_1 + 1.0) * ((alpha + (fma(i, 2.0, beta) + -1.0)) * (t_1 / fma(i, t_0, (beta * alpha)))));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(t_0 * Float64(i / t_1)) / Float64(Float64(t_1 + 1.0) * Float64(Float64(alpha + Float64(fma(i, 2.0, beta) + -1.0)) * Float64(t_1 / fma(i, t_0, Float64(beta * alpha)))))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(t$95$0 * N[(i / t$95$1), $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$1 + 1.0), $MachinePrecision] * N[(N[(alpha + N[(N[(i * 2.0 + beta), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{t\_0 \cdot \frac{i}{t\_1}}{\left(t\_1 + 1\right) \cdot \left(\left(\alpha + \left(\mathsf{fma}\left(i, 2, \beta\right) + -1\right)\right) \cdot \frac{t\_1}{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
*-commutativeN/A
clear-numN/A
frac-timesN/A
clear-numN/A
div-invN/A
clear-numN/A
Applied egg-rr43.4%
Final simplification43.4%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ i beta))) (t_1 (+ alpha (fma i 2.0 beta))))
(/
(/ (* i t_0) (fma t_1 t_1 -1.0))
(/ (* t_1 t_1) (fma i t_0 (* beta alpha))))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + (i + beta);
double t_1 = alpha + fma(i, 2.0, beta);
return ((i * t_0) / fma(t_1, t_1, -1.0)) / ((t_1 * t_1) / fma(i, t_0, (beta * alpha)));
}
function code(alpha, beta, i) t_0 = Float64(alpha + Float64(i + beta)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(Float64(i * t_0) / fma(t_1, t_1, -1.0)) / Float64(Float64(t_1 * t_1) / fma(i, t_0, Float64(beta * alpha)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i * t$95$0), $MachinePrecision] / N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$1 * t$95$1), $MachinePrecision] / N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(i + \beta\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{\frac{i \cdot t\_0}{\mathsf{fma}\left(t\_1, t\_1, -1\right)}}{\frac{t\_1 \cdot t\_1}{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}}
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
times-fracN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
Applied egg-rr39.3%
Final simplification39.3%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ alpha (fma i 2.0 beta))))
(/
(* i (* t_0 (/ (fma i t_0 (* beta alpha)) (fma t_1 t_1 -1.0))))
(* t_1 t_1))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = alpha + fma(i, 2.0, beta);
return (i * (t_0 * (fma(i, t_0, (beta * alpha)) / fma(t_1, t_1, -1.0)))) / (t_1 * t_1);
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(i * Float64(t_0 * Float64(fma(i, t_0, Float64(beta * alpha)) / fma(t_1, t_1, -1.0)))) / Float64(t_1 * t_1)) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(i * N[(t$95$0 * N[(N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{i \cdot \left(t\_0 \cdot \frac{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}{\mathsf{fma}\left(t\_1, t\_1, -1\right)}\right)}{t\_1 \cdot t\_1}
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
Applied egg-rr16.9%
associate-/l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
Applied egg-rr39.3%
Final simplification39.3%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ i beta))) (t_1 (+ alpha (fma i 2.0 beta))))
(*
(/ (fma i t_0 (* beta alpha)) (fma t_1 t_1 -1.0))
(/ (* i t_0) (* t_1 t_1)))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + (i + beta);
double t_1 = alpha + fma(i, 2.0, beta);
return (fma(i, t_0, (beta * alpha)) / fma(t_1, t_1, -1.0)) * ((i * t_0) / (t_1 * t_1));
}
function code(alpha, beta, i) t_0 = Float64(alpha + Float64(i + beta)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(fma(i, t_0, Float64(beta * alpha)) / fma(t_1, t_1, -1.0)) * Float64(Float64(i * t_0) / Float64(t_1 * t_1))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(N[(i * t$95$0), $MachinePrecision] / N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(i + \beta\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\frac{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}{\mathsf{fma}\left(t\_1, t\_1, -1\right)} \cdot \frac{i \cdot t\_0}{t\_1 \cdot t\_1}
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr39.3%
Final simplification39.3%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (fma i 2.0 beta))) (t_1 (+ i (+ beta alpha))))
(*
(/ i (fma t_0 t_0 -1.0))
(* t_1 (/ (fma i t_1 (* beta alpha)) (* t_0 t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + fma(i, 2.0, beta);
double t_1 = i + (beta + alpha);
return (i / fma(t_0, t_0, -1.0)) * (t_1 * (fma(i, t_1, (beta * alpha)) / (t_0 * t_0)));
}
function code(alpha, beta, i) t_0 = Float64(alpha + fma(i, 2.0, beta)) t_1 = Float64(i + Float64(beta + alpha)) return Float64(Float64(i / fma(t_0, t_0, -1.0)) * Float64(t_1 * Float64(fma(i, t_1, Float64(beta * alpha)) / Float64(t_0 * t_0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(i / N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 * N[(N[(i * t$95$1 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
t_1 := i + \left(\beta + \alpha\right)\\
\frac{i}{\mathsf{fma}\left(t\_0, t\_0, -1\right)} \cdot \left(t\_1 \cdot \frac{\mathsf{fma}\left(i, t\_1, \beta \cdot \alpha\right)}{t\_0 \cdot t\_0}\right)
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
associate-*l*N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr26.0%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr39.2%
Final simplification39.2%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ alpha (fma i 2.0 beta))))
(*
i
(*
(/ (fma i t_0 (* beta alpha)) (* t_1 t_1))
(/ t_0 (fma t_1 t_1 -1.0))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = alpha + fma(i, 2.0, beta);
return i * ((fma(i, t_0, (beta * alpha)) / (t_1 * t_1)) * (t_0 / fma(t_1, t_1, -1.0)));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(i * Float64(Float64(fma(i, t_0, Float64(beta * alpha)) / Float64(t_1 * t_1)) * Float64(t_0 / fma(t_1, t_1, -1.0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(i * N[(N[(N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 / N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
i \cdot \left(\frac{\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)}{t\_1 \cdot t\_1} \cdot \frac{t\_0}{\mathsf{fma}\left(t\_1, t\_1, -1\right)}\right)
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
frac-timesN/A
frac-timesN/A
associate-+r+N/A
associate-+r+N/A
metadata-evalN/A
sub-negN/A
difference-of-sqr--1N/A
associate-/r*N/A
Applied egg-rr39.2%
Final simplification39.2%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (fma i 2.0 beta))))
(*
(fma (+ i beta) alpha (* i (+ i beta)))
(/ (* i (+ alpha (+ i beta))) (* (fma t_0 t_0 -1.0) (* t_0 t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + fma(i, 2.0, beta);
return fma((i + beta), alpha, (i * (i + beta))) * ((i * (alpha + (i + beta))) / (fma(t_0, t_0, -1.0) * (t_0 * t_0)));
}
function code(alpha, beta, i) t_0 = Float64(alpha + fma(i, 2.0, beta)) return Float64(fma(Float64(i + beta), alpha, Float64(i * Float64(i + beta))) * Float64(Float64(i * Float64(alpha + Float64(i + beta))) / Float64(fma(t_0, t_0, -1.0) * Float64(t_0 * t_0)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(i + beta), $MachinePrecision] * alpha + N[(i * N[(i + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(i * N[(alpha + N[(i + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\mathsf{fma}\left(i + \beta, \alpha, i \cdot \left(i + \beta\right)\right) \cdot \frac{i \cdot \left(\alpha + \left(i + \beta\right)\right)}{\mathsf{fma}\left(t\_0, t\_0, -1\right) \cdot \left(t\_0 \cdot t\_0\right)}
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr18.6%
+-commutativeN/A
distribute-rgt-inN/A
associate-+r+N/A
distribute-lft-inN/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f6418.6
Applied egg-rr18.6%
Final simplification18.6%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ i beta))) (t_1 (+ alpha (fma i 2.0 beta))))
(*
(fma i t_0 (* beta alpha))
(/ (* i t_0) (* (fma t_1 t_1 -1.0) (* t_1 t_1))))))
double code(double alpha, double beta, double i) {
double t_0 = alpha + (i + beta);
double t_1 = alpha + fma(i, 2.0, beta);
return fma(i, t_0, (beta * alpha)) * ((i * t_0) / (fma(t_1, t_1, -1.0) * (t_1 * t_1)));
}
function code(alpha, beta, i) t_0 = Float64(alpha + Float64(i + beta)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(fma(i, t_0, Float64(beta * alpha)) * Float64(Float64(i * t_0) / Float64(fma(t_1, t_1, -1.0) * Float64(t_1 * t_1)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(i + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] * N[(N[(i * t$95$0), $MachinePrecision] / N[(N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision] * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(i + \beta\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right) \cdot \frac{i \cdot t\_0}{\mathsf{fma}\left(t\_1, t\_1, -1\right) \cdot \left(t\_1 \cdot t\_1\right)}
\end{array}
\end{array}
Initial program 16.9%
associate-/l/N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr18.6%
Final simplification18.6%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ beta (fma i 2.0 alpha))))
(*
(/ t_0 (* t_1 (* t_1 (fma t_1 t_1 -1.0))))
(* i (fma i t_0 (* beta alpha))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = beta + fma(i, 2.0, alpha);
return (t_0 / (t_1 * (t_1 * fma(t_1, t_1, -1.0)))) * (i * fma(i, t_0, (beta * alpha)));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(beta + fma(i, 2.0, alpha)) return Float64(Float64(t_0 / Float64(t_1 * Float64(t_1 * fma(t_1, t_1, -1.0)))) * Float64(i * fma(i, t_0, Float64(beta * alpha)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(beta + N[(i * 2.0 + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(t$95$0 / N[(t$95$1 * N[(t$95$1 * N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(i * N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \beta + \mathsf{fma}\left(i, 2, \alpha\right)\\
\frac{t\_0}{t\_1 \cdot \left(t\_1 \cdot \mathsf{fma}\left(t\_1, t\_1, -1\right)\right)} \cdot \left(i \cdot \mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)\right)
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f6444.4
Applied egg-rr44.4%
Applied egg-rr16.1%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ i (+ beta alpha))) (t_1 (+ alpha (fma i 2.0 beta))))
(*
(* i (fma i t_0 (* beta alpha)))
(/ t_0 (* (fma t_1 t_1 -1.0) (* t_1 t_1))))))
double code(double alpha, double beta, double i) {
double t_0 = i + (beta + alpha);
double t_1 = alpha + fma(i, 2.0, beta);
return (i * fma(i, t_0, (beta * alpha))) * (t_0 / (fma(t_1, t_1, -1.0) * (t_1 * t_1)));
}
function code(alpha, beta, i) t_0 = Float64(i + Float64(beta + alpha)) t_1 = Float64(alpha + fma(i, 2.0, beta)) return Float64(Float64(i * fma(i, t_0, Float64(beta * alpha))) * Float64(t_0 / Float64(fma(t_1, t_1, -1.0) * Float64(t_1 * t_1)))) end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(i * 2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(i * N[(i * t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 / N[(N[(t$95$1 * t$95$1 + -1.0), $MachinePrecision] * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i + \left(\beta + \alpha\right)\\
t_1 := \alpha + \mathsf{fma}\left(i, 2, \beta\right)\\
\left(i \cdot \mathsf{fma}\left(i, t\_0, \beta \cdot \alpha\right)\right) \cdot \frac{t\_0}{\mathsf{fma}\left(t\_1, t\_1, -1\right) \cdot \left(t\_1 \cdot t\_1\right)}
\end{array}
\end{array}
Initial program 16.9%
times-fracN/A
difference-of-sqr-1N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr44.3%
frac-timesN/A
frac-timesN/A
associate-+r+N/A
associate-+r+N/A
metadata-evalN/A
sub-negN/A
difference-of-sqr--1N/A
associate-/r*N/A
Applied egg-rr16.1%
Final simplification16.1%
herbie shell --seed 2024208
(FPCore (alpha beta i)
:name "Octave 3.8, jcobi/4"
:precision binary64
:pre (and (and (> alpha -1.0) (> beta -1.0)) (> i 1.0))
(/ (/ (* (* i (+ (+ alpha beta) i)) (+ (* beta alpha) (* i (+ (+ alpha beta) i)))) (* (+ (+ alpha beta) (* 2.0 i)) (+ (+ alpha beta) (* 2.0 i)))) (- (* (+ (+ alpha beta) (* 2.0 i)) (+ (+ alpha beta) (* 2.0 i))) 1.0)))