
(FPCore (x y z t a b) :precision binary64 (- (* (* 2.0 (sqrt x)) (cos (- y (/ (* z t) 3.0)))) (/ a (* b 3.0))))
double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * sqrt(x)) * cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((2.0d0 * sqrt(x)) * cos((y - ((z * t) / 3.0d0)))) - (a / (b * 3.0d0))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * Math.sqrt(x)) * Math.cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0));
}
def code(x, y, z, t, a, b): return ((2.0 * math.sqrt(x)) * math.cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0))
function code(x, y, z, t, a, b) return Float64(Float64(Float64(2.0 * sqrt(x)) * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - Float64(a / Float64(b * 3.0))) end
function tmp = code(x, y, z, t, a, b) tmp = ((2.0 * sqrt(x)) * cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(a / N[(b * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(2 \cdot \sqrt{x}\right) \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - \frac{a}{b \cdot 3}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (- (* (* 2.0 (sqrt x)) (cos (- y (/ (* z t) 3.0)))) (/ a (* b 3.0))))
double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * sqrt(x)) * cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((2.0d0 * sqrt(x)) * cos((y - ((z * t) / 3.0d0)))) - (a / (b * 3.0d0))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * Math.sqrt(x)) * Math.cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0));
}
def code(x, y, z, t, a, b): return ((2.0 * math.sqrt(x)) * math.cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0))
function code(x, y, z, t, a, b) return Float64(Float64(Float64(2.0 * sqrt(x)) * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - Float64(a / Float64(b * 3.0))) end
function tmp = code(x, y, z, t, a, b) tmp = ((2.0 * sqrt(x)) * cos((y - ((z * t) / 3.0)))) - (a / (b * 3.0)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(a / N[(b * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(2 \cdot \sqrt{x}\right) \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - \frac{a}{b \cdot 3}
\end{array}
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ a (* 3.0 b))) (t_2 (* 2.0 (sqrt x))))
(if (<= (- (* t_2 (cos (- y (/ (* z t) 3.0)))) t_1) 2e+187)
(-
(*
t_2
(fma
(cos y)
(log (exp (cos (* t (* z -0.3333333333333333)))))
(* (sin y) (sin (* 0.3333333333333333 (* z t))))))
t_1)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * sqrt(x);
double tmp;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * fma(cos(y), log(exp(cos((t * (z * -0.3333333333333333))))), (sin(y) * sin((0.3333333333333333 * (z * t)))))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(a / Float64(3.0 * b)) t_2 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_2 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_1) <= 2e+187) tmp = Float64(Float64(t_2 * fma(cos(y), log(exp(cos(Float64(t * Float64(z * -0.3333333333333333))))), Float64(sin(y) * sin(Float64(0.3333333333333333 * Float64(z * t)))))) - t_1); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], 2e+187], N[(N[(t$95$2 * N[(N[Cos[y], $MachinePrecision] * N[Log[N[Exp[N[Cos[N[(t * N[(z * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + N[(N[Sin[y], $MachinePrecision] * N[Sin[N[(0.3333333333333333 * N[(z * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := \frac{a}{3 \cdot b}\\
t_2 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_2 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_1 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_2 \cdot \mathsf{fma}\left(\cos y, \log \left(e^{\cos \left(t \cdot \left(z \cdot -0.3333333333333333\right)\right)}\right), \sin y \cdot \sin \left(0.3333333333333333 \cdot \left(z \cdot t\right)\right)\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
*-un-lft-identity75.3%
add-cube-cbrt75.1%
times-frac74.9%
pow275.0%
Applied egg-rr75.0%
cos-diff76.0%
div-inv75.8%
associate-*r*75.9%
/-rgt-identity75.9%
unpow275.8%
add-cube-cbrt75.8%
associate-/r/76.0%
metadata-eval76.0%
*-commutative76.0%
div-inv75.8%
Applied egg-rr76.0%
fma-def76.0%
cos-neg76.0%
associate-*r*75.9%
*-commutative75.9%
*-commutative75.9%
*-commutative75.9%
distribute-rgt-neg-in75.9%
metadata-eval75.9%
associate-*r*76.1%
*-commutative76.1%
associate-*r*76.3%
*-commutative76.3%
*-commutative76.3%
Simplified76.3%
add-log-exp76.3%
Applied egg-rr76.3%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification75.2%
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ a (* 3.0 b))) (t_2 (* 2.0 (sqrt x))))
(if (<= (- (* t_2 (cos (- y (/ (* z t) 3.0)))) t_1) 2e+187)
(-
(*
t_2
(fma
(cos y)
(cos (* t (* z -0.3333333333333333)))
(* (sin y) (sin (* 0.3333333333333333 (* z t))))))
t_1)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * sqrt(x);
double tmp;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * fma(cos(y), cos((t * (z * -0.3333333333333333))), (sin(y) * sin((0.3333333333333333 * (z * t)))))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(a / Float64(3.0 * b)) t_2 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_2 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_1) <= 2e+187) tmp = Float64(Float64(t_2 * fma(cos(y), cos(Float64(t * Float64(z * -0.3333333333333333))), Float64(sin(y) * sin(Float64(0.3333333333333333 * Float64(z * t)))))) - t_1); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], 2e+187], N[(N[(t$95$2 * N[(N[Cos[y], $MachinePrecision] * N[Cos[N[(t * N[(z * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(N[Sin[y], $MachinePrecision] * N[Sin[N[(0.3333333333333333 * N[(z * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := \frac{a}{3 \cdot b}\\
t_2 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_2 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_1 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_2 \cdot \mathsf{fma}\left(\cos y, \cos \left(t \cdot \left(z \cdot -0.3333333333333333\right)\right), \sin y \cdot \sin \left(0.3333333333333333 \cdot \left(z \cdot t\right)\right)\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
*-un-lft-identity75.3%
add-cube-cbrt75.1%
times-frac74.9%
pow275.0%
Applied egg-rr75.0%
cos-diff76.0%
div-inv75.8%
associate-*r*75.9%
/-rgt-identity75.9%
unpow275.8%
add-cube-cbrt75.8%
associate-/r/76.0%
metadata-eval76.0%
*-commutative76.0%
div-inv75.8%
Applied egg-rr76.0%
fma-def76.0%
cos-neg76.0%
associate-*r*75.9%
*-commutative75.9%
*-commutative75.9%
*-commutative75.9%
distribute-rgt-neg-in75.9%
metadata-eval75.9%
associate-*r*76.1%
*-commutative76.1%
associate-*r*76.3%
*-commutative76.3%
*-commutative76.3%
Simplified76.3%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification75.2%
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* z (* t 0.3333333333333333)))
(t_2 (/ a (* 3.0 b)))
(t_3 (* 2.0 (sqrt x))))
(if (<= (- (* t_3 (cos (- y (/ (* z t) 3.0)))) t_2) 2e+187)
(- (* t_3 (+ (* (sin y) (sin t_1)) (* (cos y) (cos t_1)))) t_2)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (t * 0.3333333333333333);
double t_2 = a / (3.0 * b);
double t_3 = 2.0 * sqrt(x);
double tmp;
if (((t_3 * cos((y - ((z * t) / 3.0)))) - t_2) <= 2e+187) {
tmp = (t_3 * ((sin(y) * sin(t_1)) + (cos(y) * cos(t_1)))) - t_2;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = z * (t * 0.3333333333333333d0)
t_2 = a / (3.0d0 * b)
t_3 = 2.0d0 * sqrt(x)
if (((t_3 * cos((y - ((z * t) / 3.0d0)))) - t_2) <= 2d+187) then
tmp = (t_3 * ((sin(y) * sin(t_1)) + (cos(y) * cos(t_1)))) - t_2
else
tmp = (-(a / 3.0d0) / b) - (2.0d0 * (sqrt(x) * cos(y)))
end if
code = tmp
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z * (t * 0.3333333333333333);
double t_2 = a / (3.0 * b);
double t_3 = 2.0 * Math.sqrt(x);
double tmp;
if (((t_3 * Math.cos((y - ((z * t) / 3.0)))) - t_2) <= 2e+187) {
tmp = (t_3 * ((Math.sin(y) * Math.sin(t_1)) + (Math.cos(y) * Math.cos(t_1)))) - t_2;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (Math.sqrt(x) * Math.cos(y)));
}
return tmp;
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): t_1 = z * (t * 0.3333333333333333) t_2 = a / (3.0 * b) t_3 = 2.0 * math.sqrt(x) tmp = 0 if ((t_3 * math.cos((y - ((z * t) / 3.0)))) - t_2) <= 2e+187: tmp = (t_3 * ((math.sin(y) * math.sin(t_1)) + (math.cos(y) * math.cos(t_1)))) - t_2 else: tmp = (-(a / 3.0) / b) - (2.0 * (math.sqrt(x) * math.cos(y))) return tmp
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(z * Float64(t * 0.3333333333333333)) t_2 = Float64(a / Float64(3.0 * b)) t_3 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_3 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_2) <= 2e+187) tmp = Float64(Float64(t_3 * Float64(Float64(sin(y) * sin(t_1)) + Float64(cos(y) * cos(t_1)))) - t_2); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = z * (t * 0.3333333333333333);
t_2 = a / (3.0 * b);
t_3 = 2.0 * sqrt(x);
tmp = 0.0;
if (((t_3 * cos((y - ((z * t) / 3.0)))) - t_2) <= 2e+187)
tmp = (t_3 * ((sin(y) * sin(t_1)) + (cos(y) * cos(t_1)))) - t_2;
else
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
end
tmp_2 = tmp;
end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(t * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$3 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], 2e+187], N[(N[(t$95$3 * N[(N[(N[Sin[y], $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[y], $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := z \cdot \left(t \cdot 0.3333333333333333\right)\\
t_2 := \frac{a}{3 \cdot b}\\
t_3 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_3 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_2 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_3 \cdot \left(\sin y \cdot \sin t_1 + \cos y \cdot \cos t_1\right) - t_2\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
*-un-lft-identity75.3%
add-cube-cbrt75.1%
times-frac74.9%
pow275.0%
Applied egg-rr75.0%
cos-diff76.0%
+-commutative76.0%
div-inv75.8%
associate-*r*75.8%
/-rgt-identity75.8%
unpow275.8%
add-cube-cbrt75.7%
associate-/r/75.8%
metadata-eval75.8%
*-commutative75.8%
Applied egg-rr76.0%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification74.9%
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ a (* 3.0 b))) (t_2 (* 2.0 (sqrt x))))
(if (<= (- (* t_2 (cos (- y (/ (* z t) 3.0)))) t_1) 2e+187)
(-
(* t_2 (cos (- y (pow (cbrt (* t (* z -0.3333333333333333))) 3.0))))
t_1)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * sqrt(x);
double tmp;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * cos((y - pow(cbrt((t * (z * -0.3333333333333333))), 3.0)))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * Math.sqrt(x);
double tmp;
if (((t_2 * Math.cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * Math.cos((y - Math.pow(Math.cbrt((t * (z * -0.3333333333333333))), 3.0)))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (Math.sqrt(x) * Math.cos(y)));
}
return tmp;
}
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(a / Float64(3.0 * b)) t_2 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_2 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_1) <= 2e+187) tmp = Float64(Float64(t_2 * cos(Float64(y - (cbrt(Float64(t * Float64(z * -0.3333333333333333))) ^ 3.0)))) - t_1); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], 2e+187], N[(N[(t$95$2 * N[Cos[N[(y - N[Power[N[Power[N[(t * N[(z * -0.3333333333333333), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := \frac{a}{3 \cdot b}\\
t_2 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_2 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_1 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_2 \cdot \cos \left(y - {\left(\sqrt[3]{t \cdot \left(z \cdot -0.3333333333333333\right)}\right)}^{3}\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
add-cube-cbrt75.4%
pow375.3%
add-sqr-sqrt40.3%
sqrt-unprod65.9%
frac-times65.3%
metadata-eval65.3%
metadata-eval65.3%
frac-times65.9%
sqrt-unprod34.9%
add-sqr-sqrt75.4%
associate-/r/75.2%
*-commutative75.2%
div-inv75.6%
metadata-eval75.6%
*-commutative75.6%
Applied egg-rr75.6%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification74.6%
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ a (* 3.0 b))) (t_2 (* 2.0 (sqrt x))))
(if (<= (- (* t_2 (cos (- y (/ (* z t) 3.0)))) t_1) 2e+187)
(- (* t_2 (cos (- y (pow (/ (/ 3.0 t) z) -1.0)))) t_1)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * sqrt(x);
double tmp;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * cos((y - pow(((3.0 / t) / z), -1.0)))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a / (3.0d0 * b)
t_2 = 2.0d0 * sqrt(x)
if (((t_2 * cos((y - ((z * t) / 3.0d0)))) - t_1) <= 2d+187) then
tmp = (t_2 * cos((y - (((3.0d0 / t) / z) ** (-1.0d0))))) - t_1
else
tmp = (-(a / 3.0d0) / b) - (2.0d0 * (sqrt(x) * cos(y)))
end if
code = tmp
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * Math.sqrt(x);
double tmp;
if (((t_2 * Math.cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * Math.cos((y - Math.pow(((3.0 / t) / z), -1.0)))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (Math.sqrt(x) * Math.cos(y)));
}
return tmp;
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): t_1 = a / (3.0 * b) t_2 = 2.0 * math.sqrt(x) tmp = 0 if ((t_2 * math.cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187: tmp = (t_2 * math.cos((y - math.pow(((3.0 / t) / z), -1.0)))) - t_1 else: tmp = (-(a / 3.0) / b) - (2.0 * (math.sqrt(x) * math.cos(y))) return tmp
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(a / Float64(3.0 * b)) t_2 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_2 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_1) <= 2e+187) tmp = Float64(Float64(t_2 * cos(Float64(y - (Float64(Float64(3.0 / t) / z) ^ -1.0)))) - t_1); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = a / (3.0 * b);
t_2 = 2.0 * sqrt(x);
tmp = 0.0;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187)
tmp = (t_2 * cos((y - (((3.0 / t) / z) ^ -1.0)))) - t_1;
else
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
end
tmp_2 = tmp;
end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], 2e+187], N[(N[(t$95$2 * N[Cos[N[(y - N[Power[N[(N[(3.0 / t), $MachinePrecision] / z), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := \frac{a}{3 \cdot b}\\
t_2 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_2 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_1 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_2 \cdot \cos \left(y - {\left(\frac{\frac{3}{t}}{z}\right)}^{-1}\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
associate-/l*75.3%
clear-num75.4%
inv-pow75.4%
associate-/l/75.5%
Applied egg-rr75.5%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification74.5%
NOTE: z and t should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ a (* 3.0 b))) (t_2 (* 2.0 (sqrt x))))
(if (<= (- (* t_2 (cos (- y (/ (* z t) 3.0)))) t_1) 2e+187)
(- (* t_2 (cos (- y (* t (* z -0.3333333333333333))))) t_1)
(- (/ (- (/ a 3.0)) b) (* 2.0 (* (sqrt x) (cos y)))))))assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * sqrt(x);
double tmp;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * cos((y - (t * (z * -0.3333333333333333))))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
}
return tmp;
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a / (3.0d0 * b)
t_2 = 2.0d0 * sqrt(x)
if (((t_2 * cos((y - ((z * t) / 3.0d0)))) - t_1) <= 2d+187) then
tmp = (t_2 * cos((y - (t * (z * (-0.3333333333333333d0)))))) - t_1
else
tmp = (-(a / 3.0d0) / b) - (2.0d0 * (sqrt(x) * cos(y)))
end if
code = tmp
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a / (3.0 * b);
double t_2 = 2.0 * Math.sqrt(x);
double tmp;
if (((t_2 * Math.cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187) {
tmp = (t_2 * Math.cos((y - (t * (z * -0.3333333333333333))))) - t_1;
} else {
tmp = (-(a / 3.0) / b) - (2.0 * (Math.sqrt(x) * Math.cos(y)));
}
return tmp;
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): t_1 = a / (3.0 * b) t_2 = 2.0 * math.sqrt(x) tmp = 0 if ((t_2 * math.cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187: tmp = (t_2 * math.cos((y - (t * (z * -0.3333333333333333))))) - t_1 else: tmp = (-(a / 3.0) / b) - (2.0 * (math.sqrt(x) * math.cos(y))) return tmp
z, t = sort([z, t]) function code(x, y, z, t, a, b) t_1 = Float64(a / Float64(3.0 * b)) t_2 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (Float64(Float64(t_2 * cos(Float64(y - Float64(Float64(z * t) / 3.0)))) - t_1) <= 2e+187) tmp = Float64(Float64(t_2 * cos(Float64(y - Float64(t * Float64(z * -0.3333333333333333))))) - t_1); else tmp = Float64(Float64(Float64(-Float64(a / 3.0)) / b) - Float64(2.0 * Float64(sqrt(x) * cos(y)))); end return tmp end
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = a / (3.0 * b);
t_2 = 2.0 * sqrt(x);
tmp = 0.0;
if (((t_2 * cos((y - ((z * t) / 3.0)))) - t_1) <= 2e+187)
tmp = (t_2 * cos((y - (t * (z * -0.3333333333333333))))) - t_1;
else
tmp = (-(a / 3.0) / b) - (2.0 * (sqrt(x) * cos(y)));
end
tmp_2 = tmp;
end
NOTE: z and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 * N[Cos[N[(y - N[(N[(z * t), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], 2e+187], N[(N[(t$95$2 * N[Cos[N[(y - N[(t * N[(z * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-N[(a / 3.0), $MachinePrecision]) / b), $MachinePrecision] - N[(2.0 * N[(N[Sqrt[x], $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
t_1 := \frac{a}{3 \cdot b}\\
t_2 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;t_2 \cdot \cos \left(y - \frac{z \cdot t}{3}\right) - t_1 \leq 2 \cdot 10^{+187}:\\
\;\;\;\;t_2 \cdot \cos \left(y - t \cdot \left(z \cdot -0.3333333333333333\right)\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-\frac{a}{3}}{b} - 2 \cdot \left(\sqrt{x} \cdot \cos y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) < 1.99999999999999981e187Initial program 75.3%
*-commutative75.3%
*-commutative75.3%
associate-/l*75.3%
*-commutative75.3%
Simplified75.3%
add-sqr-sqrt40.0%
sqrt-unprod65.8%
frac-times65.1%
metadata-eval65.1%
metadata-eval65.1%
frac-times65.8%
sqrt-unprod35.0%
add-sqr-sqrt75.2%
associate-/r/75.2%
div-inv75.3%
metadata-eval75.3%
*-commutative75.3%
Applied egg-rr75.3%
if 1.99999999999999981e187 < (-.f64 (*.f64 (*.f64 2 (sqrt.f64 x)) (cos.f64 (-.f64 y (/.f64 (*.f64 z t) 3)))) (/.f64 a (*.f64 b 3))) Initial program 49.9%
*-commutative49.9%
*-commutative49.9%
associate-/l*49.9%
*-commutative49.9%
Simplified49.9%
Taylor expanded in z around 0 69.4%
associate-*r*69.4%
*-commutative69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
*-un-lft-identity69.4%
*-commutative69.4%
Applied egg-rr69.4%
*-rgt-identity69.4%
associate-*r*69.4%
associate-/r*69.5%
Simplified69.5%
associate-*r*69.5%
add-cube-cbrt69.5%
pow369.5%
Applied egg-rr69.5%
Taylor expanded in x around -inf 0.0%
pow-base-10.0%
*-lft-identity0.0%
unpow20.0%
rem-square-sqrt71.1%
Simplified71.1%
Final simplification74.4%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (- (* (* 2.0 (sqrt x)) (cos y)) (/ a (* 3.0 b))))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * sqrt(x)) * cos(y)) - (a / (3.0 * b));
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((2.0d0 * sqrt(x)) * cos(y)) - (a / (3.0d0 * b))
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
return ((2.0 * Math.sqrt(x)) * Math.cos(y)) - (a / (3.0 * b));
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): return ((2.0 * math.sqrt(x)) * math.cos(y)) - (a / (3.0 * b))
z, t = sort([z, t]) function code(x, y, z, t, a, b) return Float64(Float64(Float64(2.0 * sqrt(x)) * cos(y)) - Float64(a / Float64(3.0 * b))) end
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a, b)
tmp = ((2.0 * sqrt(x)) * cos(y)) - (a / (3.0 * b));
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * N[Cos[y], $MachinePrecision]), $MachinePrecision] - N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\left(2 \cdot \sqrt{x}\right) \cdot \cos y - \frac{a}{3 \cdot b}
\end{array}
Initial program 69.7%
*-commutative69.7%
*-commutative69.7%
associate-/l*69.7%
*-commutative69.7%
Simplified69.7%
Taylor expanded in z around 0 72.1%
associate-*r*72.1%
*-commutative72.1%
*-commutative72.1%
*-commutative72.1%
Simplified72.1%
Final simplification72.1%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (- (* 2.0 (sqrt x)) (/ a (* 3.0 b))))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
return (2.0 * sqrt(x)) - (a / (3.0 * b));
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (2.0d0 * sqrt(x)) - (a / (3.0d0 * b))
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
return (2.0 * Math.sqrt(x)) - (a / (3.0 * b));
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): return (2.0 * math.sqrt(x)) - (a / (3.0 * b))
z, t = sort([z, t]) function code(x, y, z, t, a, b) return Float64(Float64(2.0 * sqrt(x)) - Float64(a / Float64(3.0 * b))) end
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a, b)
tmp = (2.0 * sqrt(x)) - (a / (3.0 * b));
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] - N[(a / N[(3.0 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
2 \cdot \sqrt{x} - \frac{a}{3 \cdot b}
\end{array}
Initial program 69.7%
*-commutative69.7%
*-commutative69.7%
associate-/l*69.7%
*-commutative69.7%
Simplified69.7%
Taylor expanded in z around 0 72.1%
associate-*r*72.1%
*-commutative72.1%
*-commutative72.1%
*-commutative72.1%
Simplified72.1%
Taylor expanded in y around 0 63.8%
Final simplification63.8%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (if (or (<= a -6.5e-79) (not (<= a 6.1e-174))) (/ a (* b -3.0)) (* 2.0 (sqrt x))))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -6.5e-79) || !(a <= 6.1e-174)) {
tmp = a / (b * -3.0);
} else {
tmp = 2.0 * sqrt(x);
}
return tmp;
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((a <= (-6.5d-79)) .or. (.not. (a <= 6.1d-174))) then
tmp = a / (b * (-3.0d0))
else
tmp = 2.0d0 * sqrt(x)
end if
code = tmp
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -6.5e-79) || !(a <= 6.1e-174)) {
tmp = a / (b * -3.0);
} else {
tmp = 2.0 * Math.sqrt(x);
}
return tmp;
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): tmp = 0 if (a <= -6.5e-79) or not (a <= 6.1e-174): tmp = a / (b * -3.0) else: tmp = 2.0 * math.sqrt(x) return tmp
z, t = sort([z, t]) function code(x, y, z, t, a, b) tmp = 0.0 if ((a <= -6.5e-79) || !(a <= 6.1e-174)) tmp = Float64(a / Float64(b * -3.0)); else tmp = Float64(2.0 * sqrt(x)); end return tmp end
z, t = num2cell(sort([z, t])){:}
function tmp_2 = code(x, y, z, t, a, b)
tmp = 0.0;
if ((a <= -6.5e-79) || ~((a <= 6.1e-174)))
tmp = a / (b * -3.0);
else
tmp = 2.0 * sqrt(x);
end
tmp_2 = tmp;
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -6.5e-79], N[Not[LessEqual[a, 6.1e-174]], $MachinePrecision]], N[(a / N[(b * -3.0), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6.5 \cdot 10^{-79} \lor \neg \left(a \leq 6.1 \cdot 10^{-174}\right):\\
\;\;\;\;\frac{a}{b \cdot -3}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \sqrt{x}\\
\end{array}
\end{array}
if a < -6.5000000000000003e-79 or 6.09999999999999964e-174 < a Initial program 75.4%
fma-neg75.4%
*-commutative75.4%
associate-*r/75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
associate-/r/75.5%
neg-mul-175.5%
associate-/r*75.5%
metadata-eval75.5%
neg-mul-175.5%
associate-*r/75.5%
*-commutative75.5%
times-frac75.3%
metadata-eval75.3%
Simplified75.3%
Taylor expanded in x around 0 61.7%
*-commutative61.7%
associate-*l/61.8%
associate-/l*61.8%
div-inv61.9%
metadata-eval61.9%
Applied egg-rr61.9%
if -6.5000000000000003e-79 < a < 6.09999999999999964e-174Initial program 57.5%
associate-*l*57.5%
fma-neg57.5%
Simplified58.2%
Taylor expanded in t around 0 53.2%
Taylor expanded in a around 0 47.6%
Taylor expanded in y around 0 36.6%
Final simplification53.9%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (* -0.3333333333333333 (/ a b)))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
return -0.3333333333333333 * (a / b);
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (-0.3333333333333333d0) * (a / b)
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
return -0.3333333333333333 * (a / b);
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): return -0.3333333333333333 * (a / b)
z, t = sort([z, t]) function code(x, y, z, t, a, b) return Float64(-0.3333333333333333 * Float64(a / b)) end
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a, b)
tmp = -0.3333333333333333 * (a / b);
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(-0.3333333333333333 * N[(a / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
-0.3333333333333333 \cdot \frac{a}{b}
\end{array}
Initial program 69.7%
fma-neg69.7%
*-commutative69.7%
associate-*r/69.7%
cancel-sign-sub-inv69.7%
*-commutative69.7%
associate-/r/69.7%
neg-mul-169.7%
associate-/r*69.7%
metadata-eval69.7%
neg-mul-169.7%
associate-*r/69.7%
*-commutative69.7%
times-frac69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in x around 0 46.4%
Final simplification46.4%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (* a (/ -0.3333333333333333 b)))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
return a * (-0.3333333333333333 / b);
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a * ((-0.3333333333333333d0) / b)
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
return a * (-0.3333333333333333 / b);
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): return a * (-0.3333333333333333 / b)
z, t = sort([z, t]) function code(x, y, z, t, a, b) return Float64(a * Float64(-0.3333333333333333 / b)) end
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a, b)
tmp = a * (-0.3333333333333333 / b);
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(a * N[(-0.3333333333333333 / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
a \cdot \frac{-0.3333333333333333}{b}
\end{array}
Initial program 69.7%
fma-neg69.7%
*-commutative69.7%
associate-*r/69.7%
cancel-sign-sub-inv69.7%
*-commutative69.7%
associate-/r/69.7%
neg-mul-169.7%
associate-/r*69.7%
metadata-eval69.7%
neg-mul-169.7%
associate-*r/69.7%
*-commutative69.7%
times-frac69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in x around 0 46.4%
associate-*r/46.5%
*-commutative46.5%
associate-*r/46.5%
Simplified46.5%
Final simplification46.5%
NOTE: z and t should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (/ a (* b -3.0)))
assert(z < t);
double code(double x, double y, double z, double t, double a, double b) {
return a / (b * -3.0);
}
NOTE: z and t should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = a / (b * (-3.0d0))
end function
assert z < t;
public static double code(double x, double y, double z, double t, double a, double b) {
return a / (b * -3.0);
}
[z, t] = sort([z, t]) def code(x, y, z, t, a, b): return a / (b * -3.0)
z, t = sort([z, t]) function code(x, y, z, t, a, b) return Float64(a / Float64(b * -3.0)) end
z, t = num2cell(sort([z, t])){:}
function tmp = code(x, y, z, t, a, b)
tmp = a / (b * -3.0);
end
NOTE: z and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(a / N[(b * -3.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[z, t] = \mathsf{sort}([z, t])\\
\\
\frac{a}{b \cdot -3}
\end{array}
Initial program 69.7%
fma-neg69.7%
*-commutative69.7%
associate-*r/69.7%
cancel-sign-sub-inv69.7%
*-commutative69.7%
associate-/r/69.7%
neg-mul-169.7%
associate-/r*69.7%
metadata-eval69.7%
neg-mul-169.7%
associate-*r/69.7%
*-commutative69.7%
times-frac69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in x around 0 46.4%
*-commutative46.4%
associate-*l/46.5%
associate-/l*46.5%
div-inv46.6%
metadata-eval46.6%
Applied egg-rr46.6%
Final simplification46.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ 0.3333333333333333 z) t))
(t_2 (/ (/ a 3.0) b))
(t_3 (* 2.0 (sqrt x))))
(if (< z -1.3793337487235141e+129)
(- (* t_3 (cos (- (/ 1.0 y) t_1))) t_2)
(if (< z 3.516290613555987e+106)
(- (* (* (sqrt x) 2.0) (cos (- y (* (/ t 3.0) z)))) t_2)
(- (* (cos (- y t_1)) t_3) (/ (/ a b) 3.0))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (0.3333333333333333 / z) / t;
double t_2 = (a / 3.0) / b;
double t_3 = 2.0 * sqrt(x);
double tmp;
if (z < -1.3793337487235141e+129) {
tmp = (t_3 * cos(((1.0 / y) - t_1))) - t_2;
} else if (z < 3.516290613555987e+106) {
tmp = ((sqrt(x) * 2.0) * cos((y - ((t / 3.0) * z)))) - t_2;
} else {
tmp = (cos((y - t_1)) * t_3) - ((a / b) / 3.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = (0.3333333333333333d0 / z) / t
t_2 = (a / 3.0d0) / b
t_3 = 2.0d0 * sqrt(x)
if (z < (-1.3793337487235141d+129)) then
tmp = (t_3 * cos(((1.0d0 / y) - t_1))) - t_2
else if (z < 3.516290613555987d+106) then
tmp = ((sqrt(x) * 2.0d0) * cos((y - ((t / 3.0d0) * z)))) - t_2
else
tmp = (cos((y - t_1)) * t_3) - ((a / b) / 3.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (0.3333333333333333 / z) / t;
double t_2 = (a / 3.0) / b;
double t_3 = 2.0 * Math.sqrt(x);
double tmp;
if (z < -1.3793337487235141e+129) {
tmp = (t_3 * Math.cos(((1.0 / y) - t_1))) - t_2;
} else if (z < 3.516290613555987e+106) {
tmp = ((Math.sqrt(x) * 2.0) * Math.cos((y - ((t / 3.0) * z)))) - t_2;
} else {
tmp = (Math.cos((y - t_1)) * t_3) - ((a / b) / 3.0);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (0.3333333333333333 / z) / t t_2 = (a / 3.0) / b t_3 = 2.0 * math.sqrt(x) tmp = 0 if z < -1.3793337487235141e+129: tmp = (t_3 * math.cos(((1.0 / y) - t_1))) - t_2 elif z < 3.516290613555987e+106: tmp = ((math.sqrt(x) * 2.0) * math.cos((y - ((t / 3.0) * z)))) - t_2 else: tmp = (math.cos((y - t_1)) * t_3) - ((a / b) / 3.0) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(0.3333333333333333 / z) / t) t_2 = Float64(Float64(a / 3.0) / b) t_3 = Float64(2.0 * sqrt(x)) tmp = 0.0 if (z < -1.3793337487235141e+129) tmp = Float64(Float64(t_3 * cos(Float64(Float64(1.0 / y) - t_1))) - t_2); elseif (z < 3.516290613555987e+106) tmp = Float64(Float64(Float64(sqrt(x) * 2.0) * cos(Float64(y - Float64(Float64(t / 3.0) * z)))) - t_2); else tmp = Float64(Float64(cos(Float64(y - t_1)) * t_3) - Float64(Float64(a / b) / 3.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (0.3333333333333333 / z) / t; t_2 = (a / 3.0) / b; t_3 = 2.0 * sqrt(x); tmp = 0.0; if (z < -1.3793337487235141e+129) tmp = (t_3 * cos(((1.0 / y) - t_1))) - t_2; elseif (z < 3.516290613555987e+106) tmp = ((sqrt(x) * 2.0) * cos((y - ((t / 3.0) * z)))) - t_2; else tmp = (cos((y - t_1)) * t_3) - ((a / b) / 3.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(0.3333333333333333 / z), $MachinePrecision] / t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(a / 3.0), $MachinePrecision] / b), $MachinePrecision]}, Block[{t$95$3 = N[(2.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, If[Less[z, -1.3793337487235141e+129], N[(N[(t$95$3 * N[Cos[N[(N[(1.0 / y), $MachinePrecision] - t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], If[Less[z, 3.516290613555987e+106], N[(N[(N[(N[Sqrt[x], $MachinePrecision] * 2.0), $MachinePrecision] * N[Cos[N[(y - N[(N[(t / 3.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], N[(N[(N[Cos[N[(y - t$95$1), $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision] - N[(N[(a / b), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{0.3333333333333333}{z}}{t}\\
t_2 := \frac{\frac{a}{3}}{b}\\
t_3 := 2 \cdot \sqrt{x}\\
\mathbf{if}\;z < -1.3793337487235141 \cdot 10^{+129}:\\
\;\;\;\;t_3 \cdot \cos \left(\frac{1}{y} - t_1\right) - t_2\\
\mathbf{elif}\;z < 3.516290613555987 \cdot 10^{+106}:\\
\;\;\;\;\left(\sqrt{x} \cdot 2\right) \cdot \cos \left(y - \frac{t}{3} \cdot z\right) - t_2\\
\mathbf{else}:\\
\;\;\;\;\cos \left(y - t_1\right) \cdot t_3 - \frac{\frac{a}{b}}{3}\\
\end{array}
\end{array}
herbie shell --seed 2023301
(FPCore (x y z t a b)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, K"
:precision binary64
:herbie-target
(if (< z -1.3793337487235141e+129) (- (* (* 2.0 (sqrt x)) (cos (- (/ 1.0 y) (/ (/ 0.3333333333333333 z) t)))) (/ (/ a 3.0) b)) (if (< z 3.516290613555987e+106) (- (* (* (sqrt x) 2.0) (cos (- y (* (/ t 3.0) z)))) (/ (/ a 3.0) b)) (- (* (cos (- y (/ (/ 0.3333333333333333 z) t))) (* 2.0 (sqrt x))) (/ (/ a b) 3.0))))
(- (* (* 2.0 (sqrt x)) (cos (- y (/ (* z t) 3.0)))) (/ a (* b 3.0))))