
(FPCore (a b angle x-scale y-scale)
:precision binary64
(let* ((t_0 (* (/ angle 180.0) PI))
(t_1 (sin t_0))
(t_2 (cos t_0))
(t_3
(/
(/ (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) t_1) t_2) x-scale)
y-scale)))
(-
(* t_3 t_3)
(*
(*
4.0
(/ (/ (+ (pow (* a t_1) 2.0) (pow (* b t_2) 2.0)) x-scale) x-scale))
(/ (/ (+ (pow (* a t_2) 2.0) (pow (* b t_1) 2.0)) y-scale) y-scale)))))
double code(double a, double b, double angle, double x_45_scale, double y_45_scale) {
double t_0 = (angle / 180.0) * ((double) M_PI);
double t_1 = sin(t_0);
double t_2 = cos(t_0);
double t_3 = ((((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale;
return (t_3 * t_3) - ((4.0 * (((pow((a * t_1), 2.0) + pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((pow((a * t_2), 2.0) + pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale));
}
public static double code(double a, double b, double angle, double x_45_scale, double y_45_scale) {
double t_0 = (angle / 180.0) * Math.PI;
double t_1 = Math.sin(t_0);
double t_2 = Math.cos(t_0);
double t_3 = ((((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale;
return (t_3 * t_3) - ((4.0 * (((Math.pow((a * t_1), 2.0) + Math.pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((Math.pow((a * t_2), 2.0) + Math.pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale));
}
def code(a, b, angle, x_45_scale, y_45_scale): t_0 = (angle / 180.0) * math.pi t_1 = math.sin(t_0) t_2 = math.cos(t_0) t_3 = ((((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale return (t_3 * t_3) - ((4.0 * (((math.pow((a * t_1), 2.0) + math.pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((math.pow((a * t_2), 2.0) + math.pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale))
function code(a, b, angle, x_45_scale, y_45_scale) t_0 = Float64(Float64(angle / 180.0) * pi) t_1 = sin(t_0) t_2 = cos(t_0) t_3 = Float64(Float64(Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale) return Float64(Float64(t_3 * t_3) - Float64(Float64(4.0 * Float64(Float64(Float64((Float64(a * t_1) ^ 2.0) + (Float64(b * t_2) ^ 2.0)) / x_45_scale) / x_45_scale)) * Float64(Float64(Float64((Float64(a * t_2) ^ 2.0) + (Float64(b * t_1) ^ 2.0)) / y_45_scale) / y_45_scale))) end
function tmp = code(a, b, angle, x_45_scale, y_45_scale) t_0 = (angle / 180.0) * pi; t_1 = sin(t_0); t_2 = cos(t_0); t_3 = ((((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale; tmp = (t_3 * t_3) - ((4.0 * (((((a * t_1) ^ 2.0) + ((b * t_2) ^ 2.0)) / x_45_scale) / x_45_scale)) * (((((a * t_2) ^ 2.0) + ((b * t_1) ^ 2.0)) / y_45_scale) / y_45_scale)); end
code[a_, b_, angle_, x$45$scale_, y$45$scale_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, Block[{t$95$1 = N[Sin[t$95$0], $MachinePrecision]}, Block[{t$95$2 = N[Cos[t$95$0], $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$2), $MachinePrecision] / x$45$scale), $MachinePrecision] / y$45$scale), $MachinePrecision]}, N[(N[(t$95$3 * t$95$3), $MachinePrecision] - N[(N[(4.0 * N[(N[(N[(N[Power[N[(a * t$95$1), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / x$45$scale), $MachinePrecision] / x$45$scale), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Power[N[(a * t$95$2), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * t$95$1), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / y$45$scale), $MachinePrecision] / y$45$scale), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
t_1 := \sin t\_0\\
t_2 := \cos t\_0\\
t_3 := \frac{\frac{\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot t\_1\right) \cdot t\_2}{x-scale}}{y-scale}\\
t\_3 \cdot t\_3 - \left(4 \cdot \frac{\frac{{\left(a \cdot t\_1\right)}^{2} + {\left(b \cdot t\_2\right)}^{2}}{x-scale}}{x-scale}\right) \cdot \frac{\frac{{\left(a \cdot t\_2\right)}^{2} + {\left(b \cdot t\_1\right)}^{2}}{y-scale}}{y-scale}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 6 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle x-scale y-scale)
:precision binary64
(let* ((t_0 (* (/ angle 180.0) PI))
(t_1 (sin t_0))
(t_2 (cos t_0))
(t_3
(/
(/ (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) t_1) t_2) x-scale)
y-scale)))
(-
(* t_3 t_3)
(*
(*
4.0
(/ (/ (+ (pow (* a t_1) 2.0) (pow (* b t_2) 2.0)) x-scale) x-scale))
(/ (/ (+ (pow (* a t_2) 2.0) (pow (* b t_1) 2.0)) y-scale) y-scale)))))
double code(double a, double b, double angle, double x_45_scale, double y_45_scale) {
double t_0 = (angle / 180.0) * ((double) M_PI);
double t_1 = sin(t_0);
double t_2 = cos(t_0);
double t_3 = ((((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale;
return (t_3 * t_3) - ((4.0 * (((pow((a * t_1), 2.0) + pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((pow((a * t_2), 2.0) + pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale));
}
public static double code(double a, double b, double angle, double x_45_scale, double y_45_scale) {
double t_0 = (angle / 180.0) * Math.PI;
double t_1 = Math.sin(t_0);
double t_2 = Math.cos(t_0);
double t_3 = ((((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale;
return (t_3 * t_3) - ((4.0 * (((Math.pow((a * t_1), 2.0) + Math.pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((Math.pow((a * t_2), 2.0) + Math.pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale));
}
def code(a, b, angle, x_45_scale, y_45_scale): t_0 = (angle / 180.0) * math.pi t_1 = math.sin(t_0) t_2 = math.cos(t_0) t_3 = ((((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale return (t_3 * t_3) - ((4.0 * (((math.pow((a * t_1), 2.0) + math.pow((b * t_2), 2.0)) / x_45_scale) / x_45_scale)) * (((math.pow((a * t_2), 2.0) + math.pow((b * t_1), 2.0)) / y_45_scale) / y_45_scale))
function code(a, b, angle, x_45_scale, y_45_scale) t_0 = Float64(Float64(angle / 180.0) * pi) t_1 = sin(t_0) t_2 = cos(t_0) t_3 = Float64(Float64(Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale) return Float64(Float64(t_3 * t_3) - Float64(Float64(4.0 * Float64(Float64(Float64((Float64(a * t_1) ^ 2.0) + (Float64(b * t_2) ^ 2.0)) / x_45_scale) / x_45_scale)) * Float64(Float64(Float64((Float64(a * t_2) ^ 2.0) + (Float64(b * t_1) ^ 2.0)) / y_45_scale) / y_45_scale))) end
function tmp = code(a, b, angle, x_45_scale, y_45_scale) t_0 = (angle / 180.0) * pi; t_1 = sin(t_0); t_2 = cos(t_0); t_3 = ((((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * t_1) * t_2) / x_45_scale) / y_45_scale; tmp = (t_3 * t_3) - ((4.0 * (((((a * t_1) ^ 2.0) + ((b * t_2) ^ 2.0)) / x_45_scale) / x_45_scale)) * (((((a * t_2) ^ 2.0) + ((b * t_1) ^ 2.0)) / y_45_scale) / y_45_scale)); end
code[a_, b_, angle_, x$45$scale_, y$45$scale_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, Block[{t$95$1 = N[Sin[t$95$0], $MachinePrecision]}, Block[{t$95$2 = N[Cos[t$95$0], $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$2), $MachinePrecision] / x$45$scale), $MachinePrecision] / y$45$scale), $MachinePrecision]}, N[(N[(t$95$3 * t$95$3), $MachinePrecision] - N[(N[(4.0 * N[(N[(N[(N[Power[N[(a * t$95$1), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / x$45$scale), $MachinePrecision] / x$45$scale), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Power[N[(a * t$95$2), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * t$95$1), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / y$45$scale), $MachinePrecision] / y$45$scale), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
t_1 := \sin t\_0\\
t_2 := \cos t\_0\\
t_3 := \frac{\frac{\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot t\_1\right) \cdot t\_2}{x-scale}}{y-scale}\\
t\_3 \cdot t\_3 - \left(4 \cdot \frac{\frac{{\left(a \cdot t\_1\right)}^{2} + {\left(b \cdot t\_2\right)}^{2}}{x-scale}}{x-scale}\right) \cdot \frac{\frac{{\left(a \cdot t\_2\right)}^{2} + {\left(b \cdot t\_1\right)}^{2}}{y-scale}}{y-scale}
\end{array}
\end{array}
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
x-scale_m = (fabs.f64 x-scale)
y-scale_m = (fabs.f64 y-scale)
(FPCore (a_m b_m angle x-scale_m y-scale_m)
:precision binary64
(if (<= b_m 8.5e-151)
(* -4.0 (pow (/ (* a_m (/ b_m x-scale_m)) y-scale_m) 2.0))
(*
-4.0
(pow (pow (sqrt (* (/ b_m y-scale_m) (/ a_m x-scale_m))) 2.0) 2.0))))a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double tmp;
if (b_m <= 8.5e-151) {
tmp = -4.0 * pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0);
} else {
tmp = -4.0 * pow(pow(sqrt(((b_m / y_45_scale_m) * (a_m / x_45_scale_m))), 2.0), 2.0);
}
return tmp;
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
real(8) :: tmp
if (b_m <= 8.5d-151) then
tmp = (-4.0d0) * (((a_m * (b_m / x_45scale_m)) / y_45scale_m) ** 2.0d0)
else
tmp = (-4.0d0) * ((sqrt(((b_m / y_45scale_m) * (a_m / x_45scale_m))) ** 2.0d0) ** 2.0d0)
end if
code = tmp
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double tmp;
if (b_m <= 8.5e-151) {
tmp = -4.0 * Math.pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0);
} else {
tmp = -4.0 * Math.pow(Math.pow(Math.sqrt(((b_m / y_45_scale_m) * (a_m / x_45_scale_m))), 2.0), 2.0);
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): tmp = 0 if b_m <= 8.5e-151: tmp = -4.0 * math.pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0) else: tmp = -4.0 * math.pow(math.pow(math.sqrt(((b_m / y_45_scale_m) * (a_m / x_45_scale_m))), 2.0), 2.0) return tmp
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) tmp = 0.0 if (b_m <= 8.5e-151) tmp = Float64(-4.0 * (Float64(Float64(a_m * Float64(b_m / x_45_scale_m)) / y_45_scale_m) ^ 2.0)); else tmp = Float64(-4.0 * ((sqrt(Float64(Float64(b_m / y_45_scale_m) * Float64(a_m / x_45_scale_m))) ^ 2.0) ^ 2.0)); end return tmp end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp_2 = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) tmp = 0.0; if (b_m <= 8.5e-151) tmp = -4.0 * (((a_m * (b_m / x_45_scale_m)) / y_45_scale_m) ^ 2.0); else tmp = -4.0 * ((sqrt(((b_m / y_45_scale_m) * (a_m / x_45_scale_m))) ^ 2.0) ^ 2.0); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] x-scale_m = N[Abs[x$45$scale], $MachinePrecision] y-scale_m = N[Abs[y$45$scale], $MachinePrecision] code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := If[LessEqual[b$95$m, 8.5e-151], N[(-4.0 * N[Power[N[(N[(a$95$m * N[(b$95$m / x$45$scale$95$m), $MachinePrecision]), $MachinePrecision] / y$45$scale$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(-4.0 * N[Power[N[Power[N[Sqrt[N[(N[(b$95$m / y$45$scale$95$m), $MachinePrecision] * N[(a$95$m / x$45$scale$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 8.5 \cdot 10^{-151}:\\
\;\;\;\;-4 \cdot {\left(\frac{a\_m \cdot \frac{b\_m}{x-scale\_m}}{y-scale\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot {\left({\left(\sqrt{\frac{b\_m}{y-scale\_m} \cdot \frac{a\_m}{x-scale\_m}}\right)}^{2}\right)}^{2}\\
\end{array}
\end{array}
if b < 8.49999999999999999e-151Initial program 30.2%
Simplified26.3%
Taylor expanded in angle around 0 41.8%
*-commutative41.8%
unpow241.8%
unpow241.8%
swap-sqr59.8%
unpow259.8%
*-commutative59.8%
unpow259.8%
unpow259.8%
swap-sqr77.0%
unpow277.0%
Simplified77.0%
pow177.0%
div-inv77.0%
*-commutative77.0%
pow-flip77.0%
*-commutative77.0%
metadata-eval77.0%
Applied egg-rr77.0%
unpow177.0%
Simplified77.0%
Taylor expanded in a around 0 41.8%
times-frac42.9%
times-frac41.8%
unpow241.8%
unpow241.8%
swap-sqr59.8%
unpow259.8%
unpow259.8%
swap-sqr77.0%
times-frac93.5%
unpow293.5%
associate-/r*95.9%
associate-/l*93.9%
Simplified93.9%
if 8.49999999999999999e-151 < b Initial program 12.6%
Simplified18.3%
Taylor expanded in angle around 0 49.8%
*-commutative49.8%
unpow249.8%
unpow249.8%
swap-sqr62.4%
unpow262.4%
*-commutative62.4%
unpow262.4%
unpow262.4%
swap-sqr83.4%
unpow283.4%
Simplified83.4%
add-sqr-sqrt83.3%
pow283.3%
div-inv83.3%
*-commutative83.3%
pow-flip83.6%
*-commutative83.6%
metadata-eval83.6%
Applied egg-rr83.6%
add-sqr-sqrt83.5%
pow283.5%
metadata-eval83.5%
pow-flip83.2%
div-inv83.3%
sqrt-div83.3%
sqrt-pow150.7%
metadata-eval50.7%
pow150.7%
sqrt-pow153.9%
metadata-eval53.9%
pow153.9%
Applied egg-rr53.9%
times-frac55.9%
*-commutative55.9%
Applied egg-rr55.9%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
x-scale_m = (fabs.f64 x-scale)
y-scale_m = (fabs.f64 y-scale)
(FPCore (a_m b_m angle x-scale_m y-scale_m)
:precision binary64
(let* ((t_0 (* (/ x-scale_m a_m) (/ y-scale_m b_m))))
(if (<= b_m 3.4e-150)
(* -4.0 (pow (/ (* a_m (/ b_m x-scale_m)) y-scale_m) 2.0))
(* -4.0 (/ 1.0 (* t_0 t_0))))))a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m);
double tmp;
if (b_m <= 3.4e-150) {
tmp = -4.0 * pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0);
} else {
tmp = -4.0 * (1.0 / (t_0 * t_0));
}
return tmp;
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
real(8) :: t_0
real(8) :: tmp
t_0 = (x_45scale_m / a_m) * (y_45scale_m / b_m)
if (b_m <= 3.4d-150) then
tmp = (-4.0d0) * (((a_m * (b_m / x_45scale_m)) / y_45scale_m) ** 2.0d0)
else
tmp = (-4.0d0) * (1.0d0 / (t_0 * t_0))
end if
code = tmp
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m);
double tmp;
if (b_m <= 3.4e-150) {
tmp = -4.0 * Math.pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0);
} else {
tmp = -4.0 * (1.0 / (t_0 * t_0));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m) tmp = 0 if b_m <= 3.4e-150: tmp = -4.0 * math.pow(((a_m * (b_m / x_45_scale_m)) / y_45_scale_m), 2.0) else: tmp = -4.0 * (1.0 / (t_0 * t_0)) return tmp
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = Float64(Float64(x_45_scale_m / a_m) * Float64(y_45_scale_m / b_m)) tmp = 0.0 if (b_m <= 3.4e-150) tmp = Float64(-4.0 * (Float64(Float64(a_m * Float64(b_m / x_45_scale_m)) / y_45_scale_m) ^ 2.0)); else tmp = Float64(-4.0 * Float64(1.0 / Float64(t_0 * t_0))); end return tmp end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp_2 = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m); tmp = 0.0; if (b_m <= 3.4e-150) tmp = -4.0 * (((a_m * (b_m / x_45_scale_m)) / y_45_scale_m) ^ 2.0); else tmp = -4.0 * (1.0 / (t_0 * t_0)); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
x-scale_m = N[Abs[x$45$scale], $MachinePrecision]
y-scale_m = N[Abs[y$45$scale], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := Block[{t$95$0 = N[(N[(x$45$scale$95$m / a$95$m), $MachinePrecision] * N[(y$45$scale$95$m / b$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b$95$m, 3.4e-150], N[(-4.0 * N[Power[N[(N[(a$95$m * N[(b$95$m / x$45$scale$95$m), $MachinePrecision]), $MachinePrecision] / y$45$scale$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(-4.0 * N[(1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
\begin{array}{l}
t_0 := \frac{x-scale\_m}{a\_m} \cdot \frac{y-scale\_m}{b\_m}\\
\mathbf{if}\;b\_m \leq 3.4 \cdot 10^{-150}:\\
\;\;\;\;-4 \cdot {\left(\frac{a\_m \cdot \frac{b\_m}{x-scale\_m}}{y-scale\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \frac{1}{t\_0 \cdot t\_0}\\
\end{array}
\end{array}
if b < 3.39999999999999999e-150Initial program 30.2%
Simplified26.3%
Taylor expanded in angle around 0 41.8%
*-commutative41.8%
unpow241.8%
unpow241.8%
swap-sqr59.8%
unpow259.8%
*-commutative59.8%
unpow259.8%
unpow259.8%
swap-sqr77.0%
unpow277.0%
Simplified77.0%
pow177.0%
div-inv77.0%
*-commutative77.0%
pow-flip77.0%
*-commutative77.0%
metadata-eval77.0%
Applied egg-rr77.0%
unpow177.0%
Simplified77.0%
Taylor expanded in a around 0 41.8%
times-frac42.9%
times-frac41.8%
unpow241.8%
unpow241.8%
swap-sqr59.8%
unpow259.8%
unpow259.8%
swap-sqr77.0%
times-frac93.5%
unpow293.5%
associate-/r*95.9%
associate-/l*93.9%
Simplified93.9%
if 3.39999999999999999e-150 < b Initial program 12.6%
Simplified18.3%
Taylor expanded in angle around 0 49.8%
*-commutative49.8%
unpow249.8%
unpow249.8%
swap-sqr62.4%
unpow262.4%
*-commutative62.4%
unpow262.4%
unpow262.4%
swap-sqr83.4%
unpow283.4%
Simplified83.4%
clear-num83.3%
inv-pow83.3%
Applied egg-rr83.3%
unpow-183.3%
Simplified83.3%
pow283.3%
pow283.3%
times-frac95.3%
times-frac93.1%
times-frac97.4%
Applied egg-rr97.4%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
x-scale_m = (fabs.f64 x-scale)
y-scale_m = (fabs.f64 y-scale)
(FPCore (a_m b_m angle x-scale_m y-scale_m)
:precision binary64
(let* ((t_0 (* (/ x-scale_m a_m) (/ y-scale_m b_m)))
(t_1 (/ (* b_m a_m) (* x-scale_m y-scale_m))))
(if (<= x-scale_m 2.8e-202)
(* -4.0 (* t_1 t_1))
(* -4.0 (/ 1.0 (* t_0 t_0))))))a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m);
double t_1 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m);
double tmp;
if (x_45_scale_m <= 2.8e-202) {
tmp = -4.0 * (t_1 * t_1);
} else {
tmp = -4.0 * (1.0 / (t_0 * t_0));
}
return tmp;
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (x_45scale_m / a_m) * (y_45scale_m / b_m)
t_1 = (b_m * a_m) / (x_45scale_m * y_45scale_m)
if (x_45scale_m <= 2.8d-202) then
tmp = (-4.0d0) * (t_1 * t_1)
else
tmp = (-4.0d0) * (1.0d0 / (t_0 * t_0))
end if
code = tmp
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m);
double t_1 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m);
double tmp;
if (x_45_scale_m <= 2.8e-202) {
tmp = -4.0 * (t_1 * t_1);
} else {
tmp = -4.0 * (1.0 / (t_0 * t_0));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m) t_1 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m) tmp = 0 if x_45_scale_m <= 2.8e-202: tmp = -4.0 * (t_1 * t_1) else: tmp = -4.0 * (1.0 / (t_0 * t_0)) return tmp
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = Float64(Float64(x_45_scale_m / a_m) * Float64(y_45_scale_m / b_m)) t_1 = Float64(Float64(b_m * a_m) / Float64(x_45_scale_m * y_45_scale_m)) tmp = 0.0 if (x_45_scale_m <= 2.8e-202) tmp = Float64(-4.0 * Float64(t_1 * t_1)); else tmp = Float64(-4.0 * Float64(1.0 / Float64(t_0 * t_0))); end return tmp end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp_2 = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = (x_45_scale_m / a_m) * (y_45_scale_m / b_m); t_1 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m); tmp = 0.0; if (x_45_scale_m <= 2.8e-202) tmp = -4.0 * (t_1 * t_1); else tmp = -4.0 * (1.0 / (t_0 * t_0)); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
x-scale_m = N[Abs[x$45$scale], $MachinePrecision]
y-scale_m = N[Abs[y$45$scale], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := Block[{t$95$0 = N[(N[(x$45$scale$95$m / a$95$m), $MachinePrecision] * N[(y$45$scale$95$m / b$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(b$95$m * a$95$m), $MachinePrecision] / N[(x$45$scale$95$m * y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x$45$scale$95$m, 2.8e-202], N[(-4.0 * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision], N[(-4.0 * N[(1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
\begin{array}{l}
t_0 := \frac{x-scale\_m}{a\_m} \cdot \frac{y-scale\_m}{b\_m}\\
t_1 := \frac{b\_m \cdot a\_m}{x-scale\_m \cdot y-scale\_m}\\
\mathbf{if}\;x-scale\_m \leq 2.8 \cdot 10^{-202}:\\
\;\;\;\;-4 \cdot \left(t\_1 \cdot t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \frac{1}{t\_0 \cdot t\_0}\\
\end{array}
\end{array}
if x-scale < 2.8000000000000001e-202Initial program 25.5%
Simplified23.5%
Taylor expanded in angle around 0 47.1%
*-commutative47.1%
unpow247.1%
unpow247.1%
swap-sqr64.0%
unpow264.0%
*-commutative64.0%
unpow264.0%
unpow264.0%
swap-sqr82.8%
unpow282.8%
Simplified82.8%
add-sqr-sqrt82.8%
pow282.8%
div-inv82.7%
*-commutative82.7%
pow-flip82.9%
*-commutative82.9%
metadata-eval82.9%
Applied egg-rr82.9%
unpow282.9%
add-sqr-sqrt83.0%
metadata-eval83.0%
pow-flip82.8%
div-inv82.8%
add-sqr-sqrt82.8%
sqrt-div82.8%
sqrt-pow150.7%
metadata-eval50.7%
pow150.7%
sqrt-pow151.9%
metadata-eval51.9%
pow151.9%
sqrt-div51.9%
sqrt-pow162.4%
metadata-eval62.4%
pow162.4%
sqrt-pow196.1%
metadata-eval96.1%
pow196.1%
Applied egg-rr96.1%
if 2.8000000000000001e-202 < x-scale Initial program 21.5%
Simplified23.5%
Taylor expanded in angle around 0 40.3%
*-commutative40.3%
unpow240.3%
unpow240.3%
swap-sqr55.1%
unpow255.1%
*-commutative55.1%
unpow255.1%
unpow255.1%
swap-sqr73.2%
unpow273.2%
Simplified73.2%
clear-num73.2%
inv-pow73.2%
Applied egg-rr73.2%
unpow-173.2%
Simplified73.2%
pow273.2%
pow273.2%
times-frac90.6%
times-frac87.7%
times-frac96.6%
Applied egg-rr96.6%
Final simplification96.3%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) x-scale_m = (fabs.f64 x-scale) y-scale_m = (fabs.f64 y-scale) (FPCore (a_m b_m angle x-scale_m y-scale_m) :precision binary64 (let* ((t_0 (/ (* b_m a_m) (* x-scale_m y-scale_m)))) (* -4.0 (* t_0 t_0))))
a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m);
return -4.0 * (t_0 * t_0);
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
real(8) :: t_0
t_0 = (b_m * a_m) / (x_45scale_m * y_45scale_m)
code = (-4.0d0) * (t_0 * t_0)
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
double t_0 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m);
return -4.0 * (t_0 * t_0);
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): t_0 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m) return -4.0 * (t_0 * t_0)
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = Float64(Float64(b_m * a_m) / Float64(x_45_scale_m * y_45_scale_m)) return Float64(-4.0 * Float64(t_0 * t_0)) end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) t_0 = (b_m * a_m) / (x_45_scale_m * y_45_scale_m); tmp = -4.0 * (t_0 * t_0); end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
x-scale_m = N[Abs[x$45$scale], $MachinePrecision]
y-scale_m = N[Abs[y$45$scale], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := Block[{t$95$0 = N[(N[(b$95$m * a$95$m), $MachinePrecision] / N[(x$45$scale$95$m * y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, N[(-4.0 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
\begin{array}{l}
t_0 := \frac{b\_m \cdot a\_m}{x-scale\_m \cdot y-scale\_m}\\
-4 \cdot \left(t\_0 \cdot t\_0\right)
\end{array}
\end{array}
Initial program 24.0%
Simplified23.5%
Taylor expanded in angle around 0 44.6%
*-commutative44.6%
unpow244.6%
unpow244.6%
swap-sqr60.7%
unpow260.7%
*-commutative60.7%
unpow260.7%
unpow260.7%
swap-sqr79.2%
unpow279.2%
Simplified79.2%
add-sqr-sqrt79.2%
pow279.2%
div-inv79.2%
*-commutative79.2%
pow-flip79.3%
*-commutative79.3%
metadata-eval79.3%
Applied egg-rr79.3%
unpow279.3%
add-sqr-sqrt79.3%
metadata-eval79.3%
pow-flip79.2%
div-inv79.2%
add-sqr-sqrt79.2%
sqrt-div79.2%
sqrt-pow150.8%
metadata-eval50.8%
pow150.8%
sqrt-pow150.5%
metadata-eval50.5%
pow150.5%
sqrt-div50.5%
sqrt-pow159.8%
metadata-eval59.8%
pow159.8%
sqrt-pow194.1%
metadata-eval94.1%
pow194.1%
Applied egg-rr94.1%
Final simplification94.1%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
x-scale_m = (fabs.f64 x-scale)
y-scale_m = (fabs.f64 y-scale)
(FPCore (a_m b_m angle x-scale_m y-scale_m)
:precision binary64
(*
-4.0
(*
a_m
(/
(/ b_m x-scale_m)
(* (/ y-scale_m b_m) (* y-scale_m (/ x-scale_m a_m)))))))a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
return -4.0 * (a_m * ((b_m / x_45_scale_m) / ((y_45_scale_m / b_m) * (y_45_scale_m * (x_45_scale_m / a_m)))));
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
code = (-4.0d0) * (a_m * ((b_m / x_45scale_m) / ((y_45scale_m / b_m) * (y_45scale_m * (x_45scale_m / a_m)))))
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
return -4.0 * (a_m * ((b_m / x_45_scale_m) / ((y_45_scale_m / b_m) * (y_45_scale_m * (x_45_scale_m / a_m)))));
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): return -4.0 * (a_m * ((b_m / x_45_scale_m) / ((y_45_scale_m / b_m) * (y_45_scale_m * (x_45_scale_m / a_m)))))
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) return Float64(-4.0 * Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / Float64(Float64(y_45_scale_m / b_m) * Float64(y_45_scale_m * Float64(x_45_scale_m / a_m)))))) end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / ((y_45_scale_m / b_m) * (y_45_scale_m * (x_45_scale_m / a_m))))); end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] x-scale_m = N[Abs[x$45$scale], $MachinePrecision] y-scale_m = N[Abs[y$45$scale], $MachinePrecision] code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := N[(-4.0 * N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / N[(N[(y$45$scale$95$m / b$95$m), $MachinePrecision] * N[(y$45$scale$95$m * N[(x$45$scale$95$m / a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
-4 \cdot \left(a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{\frac{y-scale\_m}{b\_m} \cdot \left(y-scale\_m \cdot \frac{x-scale\_m}{a\_m}\right)}\right)
\end{array}
Initial program 24.0%
Simplified23.5%
Taylor expanded in angle around 0 44.6%
*-commutative44.6%
unpow244.6%
unpow244.6%
swap-sqr60.7%
unpow260.7%
*-commutative60.7%
unpow260.7%
unpow260.7%
swap-sqr79.2%
unpow279.2%
Simplified79.2%
add-sqr-sqrt79.2%
pow279.2%
div-inv79.2%
*-commutative79.2%
pow-flip79.3%
*-commutative79.3%
metadata-eval79.3%
Applied egg-rr79.3%
add-sqr-sqrt79.2%
pow279.2%
metadata-eval79.2%
pow-flip79.1%
div-inv79.1%
sqrt-div79.1%
sqrt-pow152.9%
metadata-eval52.9%
pow152.9%
sqrt-pow153.2%
metadata-eval53.2%
pow153.2%
Applied egg-rr53.2%
add-sqr-sqrt53.2%
pow-pow53.2%
sqrt-pow153.2%
metadata-eval53.2%
metadata-eval53.2%
unpow253.2%
add-sqr-sqrt53.2%
unpow253.2%
add-sqr-sqrt58.3%
pow258.3%
frac-times50.5%
pow250.5%
clear-num50.5%
sqrt-div50.5%
Applied egg-rr85.2%
associate-*l*85.1%
associate-/r*87.5%
associate-*r/85.4%
*-commutative85.4%
associate-/l*85.0%
*-commutative85.0%
associate-*r*83.4%
Simplified83.4%
Final simplification83.4%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) x-scale_m = (fabs.f64 x-scale) y-scale_m = (fabs.f64 y-scale) (FPCore (a_m b_m angle x-scale_m y-scale_m) :precision binary64 0.0)
a_m = fabs(a);
b_m = fabs(b);
x-scale_m = fabs(x_45_scale);
y-scale_m = fabs(y_45_scale);
double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
return 0.0;
}
a_m = abs(a)
b_m = abs(b)
x-scale_m = abs(x_45scale)
y-scale_m = abs(y_45scale)
real(8) function code(a_m, b_m, angle, x_45scale_m, y_45scale_m)
real(8), intent (in) :: a_m
real(8), intent (in) :: b_m
real(8), intent (in) :: angle
real(8), intent (in) :: x_45scale_m
real(8), intent (in) :: y_45scale_m
code = 0.0d0
end function
a_m = Math.abs(a);
b_m = Math.abs(b);
x-scale_m = Math.abs(x_45_scale);
y-scale_m = Math.abs(y_45_scale);
public static double code(double a_m, double b_m, double angle, double x_45_scale_m, double y_45_scale_m) {
return 0.0;
}
a_m = math.fabs(a) b_m = math.fabs(b) x-scale_m = math.fabs(x_45_scale) y-scale_m = math.fabs(y_45_scale) def code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m): return 0.0
a_m = abs(a) b_m = abs(b) x-scale_m = abs(x_45_scale) y-scale_m = abs(y_45_scale) function code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) return 0.0 end
a_m = abs(a); b_m = abs(b); x-scale_m = abs(x_45_scale); y-scale_m = abs(y_45_scale); function tmp = code(a_m, b_m, angle, x_45_scale_m, y_45_scale_m) tmp = 0.0; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] x-scale_m = N[Abs[x$45$scale], $MachinePrecision] y-scale_m = N[Abs[y$45$scale], $MachinePrecision] code[a$95$m_, b$95$m_, angle_, x$45$scale$95$m_, y$45$scale$95$m_] := 0.0
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
x-scale_m = \left|x-scale\right|
\\
y-scale_m = \left|y-scale\right|
\\
0
\end{array}
Initial program 24.0%
Simplified23.5%
Taylor expanded in b around 0 21.8%
distribute-rgt-out21.8%
metadata-eval21.8%
mul0-rgt34.6%
Simplified34.6%
herbie shell --seed 2024157
(FPCore (a b angle x-scale y-scale)
:name "Simplification of discriminant from scale-rotated-ellipse"
:precision binary64
(- (* (/ (/ (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin (* (/ angle 180.0) PI))) (cos (* (/ angle 180.0) PI))) x-scale) y-scale) (/ (/ (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin (* (/ angle 180.0) PI))) (cos (* (/ angle 180.0) PI))) x-scale) y-scale)) (* (* 4.0 (/ (/ (+ (pow (* a (sin (* (/ angle 180.0) PI))) 2.0) (pow (* b (cos (* (/ angle 180.0) PI))) 2.0)) x-scale) x-scale)) (/ (/ (+ (pow (* a (cos (* (/ angle 180.0) PI))) 2.0) (pow (* b (sin (* (/ angle 180.0) PI))) 2.0)) y-scale) y-scale))))