
(FPCore (a b) :precision binary64 (- (* a a) (* b b)))
double code(double a, double b) {
return (a * a) - (b * b);
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (a * a) - (b * b)
end function
public static double code(double a, double b) {
return (a * a) - (b * b);
}
def code(a, b): return (a * a) - (b * b)
function code(a, b) return Float64(Float64(a * a) - Float64(b * b)) end
function tmp = code(a, b) tmp = (a * a) - (b * b); end
code[a_, b_] := N[(N[(a * a), $MachinePrecision] - N[(b * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a - b \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 3 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b) :precision binary64 (- (* a a) (* b b)))
double code(double a, double b) {
return (a * a) - (b * b);
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (a * a) - (b * b)
end function
public static double code(double a, double b) {
return (a * a) - (b * b);
}
def code(a, b): return (a * a) - (b * b)
function code(a, b) return Float64(Float64(a * a) - Float64(b * b)) end
function tmp = code(a, b) tmp = (a * a) - (b * b); end
code[a_, b_] := N[(N[(a * a), $MachinePrecision] - N[(b * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a - b \cdot b
\end{array}
(FPCore (a b) :precision binary64 (fma a a (* b (- b))))
double code(double a, double b) {
return fma(a, a, (b * -b));
}
function code(a, b) return fma(a, a, Float64(b * Float64(-b))) end
code[a_, b_] := N[(a * a + N[(b * (-b)), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(a, a, b \cdot \left(-b\right)\right)
\end{array}
Initial program 92.2%
sqr-neg92.2%
cancel-sign-sub92.2%
fma-def95.3%
Simplified95.3%
Final simplification95.3%
(FPCore (a b) :precision binary64 (* a (+ a (* b -2.0))))
double code(double a, double b) {
return a * (a + (b * -2.0));
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a * (a + (b * (-2.0d0)))
end function
public static double code(double a, double b) {
return a * (a + (b * -2.0));
}
def code(a, b): return a * (a + (b * -2.0))
function code(a, b) return Float64(a * Float64(a + Float64(b * -2.0))) end
function tmp = code(a, b) tmp = a * (a + (b * -2.0)); end
code[a_, b_] := N[(a * N[(a + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(a + b \cdot -2\right)
\end{array}
Initial program 92.2%
difference-of-squares100.0%
add-sqr-sqrt48.7%
sqrt-prod74.6%
sqr-neg74.6%
sqrt-unprod27.7%
add-sqr-sqrt52.8%
sub-neg52.8%
pow152.8%
pow152.8%
pow-prod-up52.8%
add-sqr-sqrt30.5%
add-sqr-sqrt13.3%
difference-of-squares13.3%
metadata-eval13.3%
unpow-prod-down13.3%
Applied egg-rr13.3%
unpow213.3%
unpow213.3%
unswap-sqr13.3%
difference-of-squares13.3%
unpow1/213.3%
unpow1/213.3%
pow-sqr13.4%
metadata-eval13.4%
unpow113.4%
unpow1/213.4%
unpow1/213.4%
pow-sqr13.4%
metadata-eval13.4%
unpow113.4%
difference-of-squares13.4%
unpow1/213.4%
unpow1/213.4%
pow-sqr25.1%
metadata-eval25.1%
unpow125.1%
Simplified52.8%
Taylor expanded in a around inf 51.5%
*-commutative51.5%
associate-*l*51.5%
unpow251.5%
distribute-lft-out57.0%
Simplified57.0%
Final simplification57.0%
(FPCore (a b) :precision binary64 (* -2.0 (* a b)))
double code(double a, double b) {
return -2.0 * (a * b);
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (-2.0d0) * (a * b)
end function
public static double code(double a, double b) {
return -2.0 * (a * b);
}
def code(a, b): return -2.0 * (a * b)
function code(a, b) return Float64(-2.0 * Float64(a * b)) end
function tmp = code(a, b) tmp = -2.0 * (a * b); end
code[a_, b_] := N[(-2.0 * N[(a * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-2 \cdot \left(a \cdot b\right)
\end{array}
Initial program 92.2%
difference-of-squares100.0%
add-sqr-sqrt48.7%
sqrt-prod74.6%
sqr-neg74.6%
sqrt-unprod27.7%
add-sqr-sqrt52.8%
sub-neg52.8%
pow152.8%
pow152.8%
pow-prod-up52.8%
add-sqr-sqrt30.5%
add-sqr-sqrt13.3%
difference-of-squares13.3%
metadata-eval13.3%
unpow-prod-down13.3%
Applied egg-rr13.3%
unpow213.3%
unpow213.3%
unswap-sqr13.3%
difference-of-squares13.3%
unpow1/213.3%
unpow1/213.3%
pow-sqr13.4%
metadata-eval13.4%
unpow113.4%
unpow1/213.4%
unpow1/213.4%
pow-sqr13.4%
metadata-eval13.4%
unpow113.4%
difference-of-squares13.4%
unpow1/213.4%
unpow1/213.4%
pow-sqr25.1%
metadata-eval25.1%
unpow125.1%
Simplified52.8%
Taylor expanded in a around inf 51.5%
*-commutative51.5%
associate-*l*51.5%
unpow251.5%
distribute-lft-out57.0%
Simplified57.0%
Taylor expanded in a around 0 17.8%
Final simplification17.8%
(FPCore (a b) :precision binary64 (* (+ a b) (- a b)))
double code(double a, double b) {
return (a + b) * (a - b);
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (a + b) * (a - b)
end function
public static double code(double a, double b) {
return (a + b) * (a - b);
}
def code(a, b): return (a + b) * (a - b)
function code(a, b) return Float64(Float64(a + b) * Float64(a - b)) end
function tmp = code(a, b) tmp = (a + b) * (a - b); end
code[a_, b_] := N[(N[(a + b), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a + b\right) \cdot \left(a - b\right)
\end{array}
herbie shell --seed 2024033
(FPCore (a b)
:name "Difference of squares"
:precision binary64
:herbie-target
(* (+ a b) (- a b))
(- (* a a) (* b b)))