
(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 7 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
(let* ((t_0 (* b_m (/ (/ a_m y-scale_m) x-scale_m)))
(t_1 (* a_m (/ (/ b_m x-scale_m) y-scale_m)))
(t_2 (sqrt t_1)))
(if (<= a_m 8.5e+209) (* -4.0 (* t_2 (* t_1 t_2))) (* t_0 (* -4.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 / y_45_scale_m) / x_45_scale_m);
double t_1 = a_m * ((b_m / x_45_scale_m) / y_45_scale_m);
double t_2 = sqrt(t_1);
double tmp;
if (a_m <= 8.5e+209) {
tmp = -4.0 * (t_2 * (t_1 * t_2));
} else {
tmp = t_0 * (-4.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) :: t_2
real(8) :: tmp
t_0 = b_m * ((a_m / y_45scale_m) / x_45scale_m)
t_1 = a_m * ((b_m / x_45scale_m) / y_45scale_m)
t_2 = sqrt(t_1)
if (a_m <= 8.5d+209) then
tmp = (-4.0d0) * (t_2 * (t_1 * t_2))
else
tmp = t_0 * ((-4.0d0) * 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 = b_m * ((a_m / y_45_scale_m) / x_45_scale_m);
double t_1 = a_m * ((b_m / x_45_scale_m) / y_45_scale_m);
double t_2 = Math.sqrt(t_1);
double tmp;
if (a_m <= 8.5e+209) {
tmp = -4.0 * (t_2 * (t_1 * t_2));
} else {
tmp = t_0 * (-4.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 = b_m * ((a_m / y_45_scale_m) / x_45_scale_m) t_1 = a_m * ((b_m / x_45_scale_m) / y_45_scale_m) t_2 = math.sqrt(t_1) tmp = 0 if a_m <= 8.5e+209: tmp = -4.0 * (t_2 * (t_1 * t_2)) else: tmp = t_0 * (-4.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(b_m * Float64(Float64(a_m / y_45_scale_m) / x_45_scale_m)) t_1 = Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / y_45_scale_m)) t_2 = sqrt(t_1) tmp = 0.0 if (a_m <= 8.5e+209) tmp = Float64(-4.0 * Float64(t_2 * Float64(t_1 * t_2))); else tmp = Float64(t_0 * Float64(-4.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 = b_m * ((a_m / y_45_scale_m) / x_45_scale_m); t_1 = a_m * ((b_m / x_45_scale_m) / y_45_scale_m); t_2 = sqrt(t_1); tmp = 0.0; if (a_m <= 8.5e+209) tmp = -4.0 * (t_2 * (t_1 * t_2)); else tmp = t_0 * (-4.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[(b$95$m * N[(N[(a$95$m / y$45$scale$95$m), $MachinePrecision] / x$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[t$95$1], $MachinePrecision]}, If[LessEqual[a$95$m, 8.5e+209], N[(-4.0 * N[(t$95$2 * N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(-4.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 := b\_m \cdot \frac{\frac{a\_m}{y-scale\_m}}{x-scale\_m}\\
t_1 := a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{y-scale\_m}\\
t_2 := \sqrt{t\_1}\\
\mathbf{if}\;a\_m \leq 8.5 \cdot 10^{+209}:\\
\;\;\;\;-4 \cdot \left(t\_2 \cdot \left(t\_1 \cdot t\_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(-4 \cdot t\_0\right)\\
\end{array}
\end{array}
if a < 8.50000000000000062e209Initial program 24.9%
Simplified23.2%
Taylor expanded in angle around 0 47.1%
*-commutative47.1%
unpow247.1%
unpow247.1%
swap-sqr64.1%
unpow264.1%
*-commutative64.1%
unpow264.1%
unpow264.1%
swap-sqr76.5%
unpow276.5%
Simplified76.5%
unpow276.5%
Applied egg-rr76.5%
unpow276.5%
Applied egg-rr76.5%
frac-times92.3%
add-sqr-sqrt60.7%
associate-*r*60.7%
associate-/l*60.3%
associate-/r*59.3%
associate-/l*58.9%
associate-/r*58.9%
associate-/l*60.6%
associate-/r*63.9%
Applied egg-rr63.9%
if 8.50000000000000062e209 < a Initial program 0.0%
Simplified0.0%
Taylor expanded in angle around 0 37.7%
*-commutative37.7%
unpow237.7%
unpow237.7%
swap-sqr42.8%
unpow242.8%
*-commutative42.8%
unpow242.8%
unpow242.8%
swap-sqr55.3%
unpow255.3%
Simplified55.3%
add-log-exp54.4%
add-log-exp54.4%
exp-to-pow54.4%
Applied egg-rr54.4%
pow-exp54.4%
add-log-exp55.3%
pow255.3%
add-sqr-sqrt55.3%
sqrt-div55.3%
sqrt-pow121.8%
metadata-eval21.8%
pow121.8%
sqrt-prod13.1%
add-sqr-sqrt34.3%
sqrt-div34.3%
sqrt-pow134.4%
metadata-eval34.4%
pow134.4%
sqrt-prod49.7%
add-sqr-sqrt91.2%
Applied egg-rr91.2%
associate-*r*91.2%
associate-*r/87.4%
associate-/l*76.1%
associate-*r*76.1%
associate-/r*76.1%
Applied egg-rr76.1%
associate-/l*79.9%
associate-*l*79.9%
associate-/l/79.9%
*-commutative79.9%
associate-*r/91.2%
associate-*l/91.4%
*-commutative91.4%
*-lft-identity91.4%
associate-*l/91.4%
*-commutative91.4%
associate-/l/91.3%
*-rgt-identity91.3%
associate-*r/91.3%
associate-*l/91.3%
*-lft-identity91.3%
associate-*l/91.3%
associate-*l/91.2%
*-lft-identity91.2%
associate-*l/91.6%
*-commutative91.6%
Simplified99.4%
Final simplification67.2%
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 1.8e-231)
(*
-4.0
(*
(/ a_m x-scale_m)
(* (* a_m (/ (/ b_m x-scale_m) y-scale_m)) (/ b_m y-scale_m))))
(if (<= b_m 6.2e+259)
(*
-4.0
(*
(/ (* a_m b_m) (* x-scale_m y-scale_m))
(* b_m (/ a_m (* x-scale_m y-scale_m)))))
(*
-4.0
(*
a_m
(/
(/ b_m x-scale_m)
(* y-scale_m (* (/ x-scale_m a_m) (/ y-scale_m b_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) {
double tmp;
if (b_m <= 1.8e-231) {
tmp = -4.0 * ((a_m / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_m)));
} else if (b_m <= 6.2e+259) {
tmp = -4.0 * (((a_m * b_m) / (x_45_scale_m * y_45_scale_m)) * (b_m * (a_m / (x_45_scale_m * y_45_scale_m))));
} else {
tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m)))));
}
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 <= 1.8d-231) then
tmp = (-4.0d0) * ((a_m / x_45scale_m) * ((a_m * ((b_m / x_45scale_m) / y_45scale_m)) * (b_m / y_45scale_m)))
else if (b_m <= 6.2d+259) then
tmp = (-4.0d0) * (((a_m * b_m) / (x_45scale_m * y_45scale_m)) * (b_m * (a_m / (x_45scale_m * y_45scale_m))))
else
tmp = (-4.0d0) * (a_m * ((b_m / x_45scale_m) / (y_45scale_m * ((x_45scale_m / a_m) * (y_45scale_m / b_m)))))
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 <= 1.8e-231) {
tmp = -4.0 * ((a_m / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_m)));
} else if (b_m <= 6.2e+259) {
tmp = -4.0 * (((a_m * b_m) / (x_45_scale_m * y_45_scale_m)) * (b_m * (a_m / (x_45_scale_m * y_45_scale_m))));
} else {
tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m)))));
}
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 <= 1.8e-231: tmp = -4.0 * ((a_m / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_m))) elif b_m <= 6.2e+259: tmp = -4.0 * (((a_m * b_m) / (x_45_scale_m * y_45_scale_m)) * (b_m * (a_m / (x_45_scale_m * y_45_scale_m)))) else: tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m))))) 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 <= 1.8e-231) tmp = Float64(-4.0 * Float64(Float64(a_m / x_45_scale_m) * Float64(Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / y_45_scale_m)) * Float64(b_m / y_45_scale_m)))); elseif (b_m <= 6.2e+259) tmp = Float64(-4.0 * Float64(Float64(Float64(a_m * b_m) / Float64(x_45_scale_m * y_45_scale_m)) * Float64(b_m * Float64(a_m / Float64(x_45_scale_m * y_45_scale_m))))); else tmp = Float64(-4.0 * Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / Float64(y_45_scale_m * Float64(Float64(x_45_scale_m / a_m) * Float64(y_45_scale_m / b_m)))))); 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 <= 1.8e-231) tmp = -4.0 * ((a_m / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_m))); elseif (b_m <= 6.2e+259) tmp = -4.0 * (((a_m * b_m) / (x_45_scale_m * y_45_scale_m)) * (b_m * (a_m / (x_45_scale_m * y_45_scale_m)))); else tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m))))); 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, 1.8e-231], N[(-4.0 * N[(N[(a$95$m / x$45$scale$95$m), $MachinePrecision] * N[(N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / y$45$scale$95$m), $MachinePrecision]), $MachinePrecision] * N[(b$95$m / y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b$95$m, 6.2e+259], N[(-4.0 * N[(N[(N[(a$95$m * b$95$m), $MachinePrecision] / N[(x$45$scale$95$m * y$45$scale$95$m), $MachinePrecision]), $MachinePrecision] * N[(b$95$m * N[(a$95$m / N[(x$45$scale$95$m * y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-4.0 * N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / N[(y$45$scale$95$m * N[(N[(x$45$scale$95$m / a$95$m), $MachinePrecision] * N[(y$45$scale$95$m / b$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|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 1.8 \cdot 10^{-231}:\\
\;\;\;\;-4 \cdot \left(\frac{a\_m}{x-scale\_m} \cdot \left(\left(a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{y-scale\_m}\right) \cdot \frac{b\_m}{y-scale\_m}\right)\right)\\
\mathbf{elif}\;b\_m \leq 6.2 \cdot 10^{+259}:\\
\;\;\;\;-4 \cdot \left(\frac{a\_m \cdot b\_m}{x-scale\_m \cdot y-scale\_m} \cdot \left(b\_m \cdot \frac{a\_m}{x-scale\_m \cdot y-scale\_m}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \left(a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{y-scale\_m \cdot \left(\frac{x-scale\_m}{a\_m} \cdot \frac{y-scale\_m}{b\_m}\right)}\right)\\
\end{array}
\end{array}
if b < 1.79999999999999987e-231Initial program 23.8%
Simplified24.5%
Taylor expanded in angle around 0 47.9%
*-commutative47.9%
unpow247.9%
unpow247.9%
swap-sqr64.0%
unpow264.0%
*-commutative64.0%
unpow264.0%
unpow264.0%
swap-sqr72.1%
unpow272.1%
Simplified72.1%
unpow272.1%
Applied egg-rr72.1%
unpow272.1%
Applied egg-rr72.1%
frac-times91.5%
times-frac88.3%
associate-*l*87.6%
associate-/l*89.7%
associate-/r*93.1%
Applied egg-rr93.1%
if 1.79999999999999987e-231 < b < 6.2000000000000007e259Initial program 23.4%
Simplified18.3%
Taylor expanded in angle around 0 43.8%
*-commutative43.8%
unpow243.8%
unpow243.8%
swap-sqr59.2%
unpow259.2%
*-commutative59.2%
unpow259.2%
unpow259.2%
swap-sqr79.2%
unpow279.2%
Simplified79.2%
add-log-exp55.4%
add-log-exp52.4%
exp-to-pow52.4%
Applied egg-rr52.4%
pow-exp55.4%
add-log-exp79.2%
pow279.2%
add-sqr-sqrt79.1%
sqrt-div79.2%
sqrt-pow153.2%
metadata-eval53.2%
pow153.2%
sqrt-prod28.6%
add-sqr-sqrt57.2%
sqrt-div57.1%
sqrt-pow154.3%
metadata-eval54.3%
pow154.3%
sqrt-prod46.3%
add-sqr-sqrt95.4%
Applied egg-rr95.4%
*-commutative95.4%
associate-/l*95.4%
Applied egg-rr95.4%
if 6.2000000000000007e259 < b Initial program 0.0%
Simplified0.0%
Taylor expanded in angle around 0 45.5%
*-commutative45.5%
unpow245.5%
unpow245.5%
swap-sqr64.0%
unpow264.0%
*-commutative64.0%
unpow264.0%
unpow264.0%
swap-sqr64.0%
unpow264.0%
Simplified64.0%
div-inv64.0%
pow-flip64.0%
metadata-eval64.0%
Applied egg-rr64.0%
sqr-pow64.0%
metadata-eval64.0%
inv-pow64.0%
metadata-eval64.0%
inv-pow64.0%
Applied egg-rr64.0%
pow264.0%
swap-sqr73.7%
div-inv73.7%
div-inv73.7%
clear-num73.7%
frac-times73.7%
*-commutative73.7%
*-un-lft-identity73.7%
times-frac65.1%
Applied egg-rr65.1%
associate-/l*73.7%
*-commutative73.7%
associate-/l/73.7%
*-commutative73.7%
associate-/l/91.0%
associate-/l/91.1%
*-commutative91.1%
Simplified91.1%
Final simplification93.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 (/ (* a_m b_m) (* x-scale_m y-scale_m))))
(if (<= b_m 2e+259)
(* -4.0 (* t_0 t_0))
(*
-4.0
(*
a_m
(/
(/ b_m x-scale_m)
(* y-scale_m (* (/ x-scale_m a_m) (/ y-scale_m b_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) {
double t_0 = (a_m * b_m) / (x_45_scale_m * y_45_scale_m);
double tmp;
if (b_m <= 2e+259) {
tmp = -4.0 * (t_0 * t_0);
} else {
tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m)))));
}
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 = (a_m * b_m) / (x_45scale_m * y_45scale_m)
if (b_m <= 2d+259) then
tmp = (-4.0d0) * (t_0 * t_0)
else
tmp = (-4.0d0) * (a_m * ((b_m / x_45scale_m) / (y_45scale_m * ((x_45scale_m / a_m) * (y_45scale_m / b_m)))))
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 = (a_m * b_m) / (x_45_scale_m * y_45_scale_m);
double tmp;
if (b_m <= 2e+259) {
tmp = -4.0 * (t_0 * t_0);
} else {
tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m)))));
}
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 = (a_m * b_m) / (x_45_scale_m * y_45_scale_m) tmp = 0 if b_m <= 2e+259: tmp = -4.0 * (t_0 * t_0) else: tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m))))) 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(a_m * b_m) / Float64(x_45_scale_m * y_45_scale_m)) tmp = 0.0 if (b_m <= 2e+259) tmp = Float64(-4.0 * Float64(t_0 * t_0)); else tmp = Float64(-4.0 * Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / Float64(y_45_scale_m * Float64(Float64(x_45_scale_m / a_m) * Float64(y_45_scale_m / b_m)))))); 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 = (a_m * b_m) / (x_45_scale_m * y_45_scale_m); tmp = 0.0; if (b_m <= 2e+259) tmp = -4.0 * (t_0 * t_0); else tmp = -4.0 * (a_m * ((b_m / x_45_scale_m) / (y_45_scale_m * ((x_45_scale_m / a_m) * (y_45_scale_m / b_m))))); 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[(a$95$m * b$95$m), $MachinePrecision] / N[(x$45$scale$95$m * y$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b$95$m, 2e+259], N[(-4.0 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(-4.0 * N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / N[(y$45$scale$95$m * N[(N[(x$45$scale$95$m / a$95$m), $MachinePrecision] * N[(y$45$scale$95$m / b$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|
\\
\begin{array}{l}
t_0 := \frac{a\_m \cdot b\_m}{x-scale\_m \cdot y-scale\_m}\\
\mathbf{if}\;b\_m \leq 2 \cdot 10^{+259}:\\
\;\;\;\;-4 \cdot \left(t\_0 \cdot t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \left(a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{y-scale\_m \cdot \left(\frac{x-scale\_m}{a\_m} \cdot \frac{y-scale\_m}{b\_m}\right)}\right)\\
\end{array}
\end{array}
if b < 2e259Initial program 23.6%
Simplified22.0%
Taylor expanded in angle around 0 46.3%
*-commutative46.3%
unpow246.3%
unpow246.3%
swap-sqr62.0%
unpow262.0%
*-commutative62.0%
unpow262.0%
unpow262.0%
swap-sqr75.0%
unpow275.0%
Simplified75.0%
add-log-exp54.6%
add-log-exp49.3%
exp-to-pow49.3%
Applied egg-rr49.3%
pow-exp54.6%
add-log-exp75.0%
pow275.0%
add-sqr-sqrt74.9%
sqrt-div75.0%
sqrt-pow147.7%
metadata-eval47.7%
pow147.7%
sqrt-prod26.0%
add-sqr-sqrt55.5%
sqrt-div55.5%
sqrt-pow155.5%
metadata-eval55.5%
pow155.5%
sqrt-prod46.0%
add-sqr-sqrt93.0%
Applied egg-rr93.0%
if 2e259 < b Initial program 0.0%
Simplified0.0%
Taylor expanded in angle around 0 45.5%
*-commutative45.5%
unpow245.5%
unpow245.5%
swap-sqr64.0%
unpow264.0%
*-commutative64.0%
unpow264.0%
unpow264.0%
swap-sqr64.0%
unpow264.0%
Simplified64.0%
div-inv64.0%
pow-flip64.0%
metadata-eval64.0%
Applied egg-rr64.0%
sqr-pow64.0%
metadata-eval64.0%
inv-pow64.0%
metadata-eval64.0%
inv-pow64.0%
Applied egg-rr64.0%
pow264.0%
swap-sqr73.7%
div-inv73.7%
div-inv73.7%
clear-num73.7%
frac-times73.7%
*-commutative73.7%
*-un-lft-identity73.7%
times-frac65.1%
Applied egg-rr65.1%
associate-/l*73.7%
*-commutative73.7%
associate-/l/73.7%
*-commutative73.7%
associate-/l/91.0%
associate-/l/91.1%
*-commutative91.1%
Simplified91.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 (let* ((t_0 (* b_m (/ (/ a_m y-scale_m) x-scale_m)))) (* t_0 (* -4.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 / y_45_scale_m) / x_45_scale_m);
return t_0 * (-4.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 / y_45scale_m) / x_45scale_m)
code = t_0 * ((-4.0d0) * 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 / y_45_scale_m) / x_45_scale_m);
return t_0 * (-4.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 / y_45_scale_m) / x_45_scale_m) return t_0 * (-4.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(b_m * Float64(Float64(a_m / y_45_scale_m) / x_45_scale_m)) return Float64(t_0 * Float64(-4.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 / y_45_scale_m) / x_45_scale_m); tmp = t_0 * (-4.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[(b$95$m * N[(N[(a$95$m / y$45$scale$95$m), $MachinePrecision] / x$45$scale$95$m), $MachinePrecision]), $MachinePrecision]}, N[(t$95$0 * N[(-4.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 := b\_m \cdot \frac{\frac{a\_m}{y-scale\_m}}{x-scale\_m}\\
t\_0 \cdot \left(-4 \cdot t\_0\right)
\end{array}
\end{array}
Initial program 22.6%
Simplified21.0%
Taylor expanded in angle around 0 46.2%
*-commutative46.2%
unpow246.2%
unpow246.2%
swap-sqr62.1%
unpow262.1%
*-commutative62.1%
unpow262.1%
unpow262.1%
swap-sqr74.5%
unpow274.5%
Simplified74.5%
add-log-exp54.6%
add-log-exp49.1%
exp-to-pow49.1%
Applied egg-rr49.1%
pow-exp54.6%
add-log-exp74.5%
pow274.5%
add-sqr-sqrt74.5%
sqrt-div74.5%
sqrt-pow146.8%
metadata-eval46.8%
pow146.8%
sqrt-prod25.7%
add-sqr-sqrt54.3%
sqrt-div54.3%
sqrt-pow155.1%
metadata-eval55.1%
pow155.1%
sqrt-prod46.4%
add-sqr-sqrt92.2%
Applied egg-rr92.2%
associate-*r*92.2%
associate-*r/89.9%
associate-/l*87.5%
associate-*r*87.5%
associate-/r*85.9%
Applied egg-rr85.9%
associate-/l*88.1%
associate-*l*88.1%
associate-/l/89.9%
*-commutative89.9%
associate-*r/92.2%
associate-*l/90.9%
*-commutative90.9%
*-lft-identity90.9%
associate-*l/90.7%
*-commutative90.7%
associate-/l/90.7%
*-rgt-identity90.7%
associate-*r/90.6%
associate-*l/90.7%
*-lft-identity90.7%
associate-*l/89.0%
associate-*l/89.0%
*-lft-identity89.0%
associate-*l/90.9%
*-commutative90.9%
Simplified95.0%
Final simplification95.0%
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 x-scale_m) (* (* a_m (/ (/ b_m x-scale_m) y-scale_m)) (/ b_m y-scale_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 / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_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 / x_45scale_m) * ((a_m * ((b_m / x_45scale_m) / y_45scale_m)) * (b_m / y_45scale_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 / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_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 / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_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(Float64(a_m / x_45_scale_m) * Float64(Float64(a_m * Float64(Float64(b_m / x_45_scale_m) / y_45_scale_m)) * Float64(b_m / y_45_scale_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 / x_45_scale_m) * ((a_m * ((b_m / x_45_scale_m) / y_45_scale_m)) * (b_m / y_45_scale_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[(N[(a$95$m / x$45$scale$95$m), $MachinePrecision] * N[(N[(a$95$m * N[(N[(b$95$m / x$45$scale$95$m), $MachinePrecision] / y$45$scale$95$m), $MachinePrecision]), $MachinePrecision] * N[(b$95$m / y$45$scale$95$m), $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(\frac{a\_m}{x-scale\_m} \cdot \left(\left(a\_m \cdot \frac{\frac{b\_m}{x-scale\_m}}{y-scale\_m}\right) \cdot \frac{b\_m}{y-scale\_m}\right)\right)
\end{array}
Initial program 22.6%
Simplified21.0%
Taylor expanded in angle around 0 46.2%
*-commutative46.2%
unpow246.2%
unpow246.2%
swap-sqr62.1%
unpow262.1%
*-commutative62.1%
unpow262.1%
unpow262.1%
swap-sqr74.5%
unpow274.5%
Simplified74.5%
unpow274.5%
Applied egg-rr74.5%
unpow274.5%
Applied egg-rr74.5%
frac-times92.2%
times-frac85.3%
associate-*l*83.1%
associate-/l*84.6%
associate-/r*87.8%
Applied egg-rr87.8%
Final simplification87.8%
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 (* (/ x-scale_m a_m) (/ y-scale_m b_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 * ((x_45_scale_m / a_m) * (y_45_scale_m / b_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 * ((x_45scale_m / a_m) * (y_45scale_m / b_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 * ((x_45_scale_m / a_m) * (y_45_scale_m / b_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 * ((x_45_scale_m / a_m) * (y_45_scale_m / b_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(y_45_scale_m * Float64(Float64(x_45_scale_m / a_m) * Float64(y_45_scale_m / b_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 * ((x_45_scale_m / a_m) * (y_45_scale_m / b_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[(y$45$scale$95$m * N[(N[(x$45$scale$95$m / a$95$m), $MachinePrecision] * N[(y$45$scale$95$m / b$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}}{y-scale\_m \cdot \left(\frac{x-scale\_m}{a\_m} \cdot \frac{y-scale\_m}{b\_m}\right)}\right)
\end{array}
Initial program 22.6%
Simplified21.0%
Taylor expanded in angle around 0 46.2%
*-commutative46.2%
unpow246.2%
unpow246.2%
swap-sqr62.1%
unpow262.1%
*-commutative62.1%
unpow262.1%
unpow262.1%
swap-sqr74.5%
unpow274.5%
Simplified74.5%
div-inv74.1%
pow-flip74.3%
metadata-eval74.3%
Applied egg-rr74.3%
sqr-pow74.3%
metadata-eval74.3%
inv-pow74.3%
metadata-eval74.3%
inv-pow74.3%
Applied egg-rr74.3%
pow274.3%
swap-sqr91.8%
div-inv91.8%
div-inv92.2%
clear-num92.2%
frac-times89.9%
*-commutative89.9%
*-un-lft-identity89.9%
times-frac83.6%
Applied egg-rr83.6%
associate-/l*84.4%
*-commutative84.4%
associate-/l/85.4%
*-commutative85.4%
associate-/l/87.7%
associate-/l/86.2%
*-commutative86.2%
Simplified86.2%
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 22.6%
Simplified21.0%
Taylor expanded in b around 0 24.1%
distribute-rgt-out24.1%
metadata-eval24.1%
mul0-rgt34.5%
Simplified34.5%
herbie shell --seed 2024177
(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))))