
(FPCore (x y) :precision binary64 (* (cos x) (/ (sinh y) y)))
double code(double x, double y) {
return cos(x) * (sinh(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = cos(x) * (sinh(y) / y)
end function
public static double code(double x, double y) {
return Math.cos(x) * (Math.sinh(y) / y);
}
def code(x, y): return math.cos(x) * (math.sinh(y) / y)
function code(x, y) return Float64(cos(x) * Float64(sinh(y) / y)) end
function tmp = code(x, y) tmp = cos(x) * (sinh(y) / y); end
code[x_, y_] := N[(N[Cos[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos x \cdot \frac{\sinh y}{y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (* (cos x) (/ (sinh y) y)))
double code(double x, double y) {
return cos(x) * (sinh(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = cos(x) * (sinh(y) / y)
end function
public static double code(double x, double y) {
return Math.cos(x) * (Math.sinh(y) / y);
}
def code(x, y): return math.cos(x) * (math.sinh(y) / y)
function code(x, y) return Float64(cos(x) * Float64(sinh(y) / y)) end
function tmp = code(x, y) tmp = cos(x) * (sinh(y) / y); end
code[x_, y_] := N[(N[Cos[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos x \cdot \frac{\sinh y}{y}
\end{array}
(FPCore (x y) :precision binary64 (* (cos x) (/ (sinh y) y)))
double code(double x, double y) {
return cos(x) * (sinh(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = cos(x) * (sinh(y) / y)
end function
public static double code(double x, double y) {
return Math.cos(x) * (Math.sinh(y) / y);
}
def code(x, y): return math.cos(x) * (math.sinh(y) / y)
function code(x, y) return Float64(cos(x) * Float64(sinh(y) / y)) end
function tmp = code(x, y) tmp = cos(x) * (sinh(y) / y); end
code[x_, y_] := N[(N[Cos[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos x \cdot \frac{\sinh y}{y}
\end{array}
Initial program 100.0%
(FPCore (x y)
:precision binary64
(if (<= y 0.26)
(/
(cos x)
(+
1.0
(*
y
(*
y
(+
-0.16666666666666666
(*
(* y y)
(+ 0.019444444444444445 (* (* y y) -0.00205026455026455))))))))
(if (<= y 3.8e+77)
(/ (sinh y) y)
(*
(cos x)
(+
1.0
(*
(* y y)
(+ 0.16666666666666666 (* (* y y) 0.008333333333333333))))))))
double code(double x, double y) {
double tmp;
if (y <= 0.26) {
tmp = cos(x) / (1.0 + (y * (y * (-0.16666666666666666 + ((y * y) * (0.019444444444444445 + ((y * y) * -0.00205026455026455)))))));
} else if (y <= 3.8e+77) {
tmp = sinh(y) / y;
} else {
tmp = cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 0.26d0) then
tmp = cos(x) / (1.0d0 + (y * (y * ((-0.16666666666666666d0) + ((y * y) * (0.019444444444444445d0 + ((y * y) * (-0.00205026455026455d0))))))))
else if (y <= 3.8d+77) then
tmp = sinh(y) / y
else
tmp = cos(x) * (1.0d0 + ((y * y) * (0.16666666666666666d0 + ((y * y) * 0.008333333333333333d0))))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 0.26) {
tmp = Math.cos(x) / (1.0 + (y * (y * (-0.16666666666666666 + ((y * y) * (0.019444444444444445 + ((y * y) * -0.00205026455026455)))))));
} else if (y <= 3.8e+77) {
tmp = Math.sinh(y) / y;
} else {
tmp = Math.cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 0.26: tmp = math.cos(x) / (1.0 + (y * (y * (-0.16666666666666666 + ((y * y) * (0.019444444444444445 + ((y * y) * -0.00205026455026455))))))) elif y <= 3.8e+77: tmp = math.sinh(y) / y else: tmp = math.cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333)))) return tmp
function code(x, y) tmp = 0.0 if (y <= 0.26) tmp = Float64(cos(x) / Float64(1.0 + Float64(y * Float64(y * Float64(-0.16666666666666666 + Float64(Float64(y * y) * Float64(0.019444444444444445 + Float64(Float64(y * y) * -0.00205026455026455)))))))); elseif (y <= 3.8e+77) tmp = Float64(sinh(y) / y); else tmp = Float64(cos(x) * Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + Float64(Float64(y * y) * 0.008333333333333333))))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 0.26) tmp = cos(x) / (1.0 + (y * (y * (-0.16666666666666666 + ((y * y) * (0.019444444444444445 + ((y * y) * -0.00205026455026455))))))); elseif (y <= 3.8e+77) tmp = sinh(y) / y; else tmp = cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333)))); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 0.26], N[(N[Cos[x], $MachinePrecision] / N[(1.0 + N[(y * N[(y * N[(-0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * N[(0.019444444444444445 + N[(N[(y * y), $MachinePrecision] * -0.00205026455026455), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e+77], N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision], N[(N[Cos[x], $MachinePrecision] * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * 0.008333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 0.26:\\
\;\;\;\;\frac{\cos x}{1 + y \cdot \left(y \cdot \left(-0.16666666666666666 + \left(y \cdot y\right) \cdot \left(0.019444444444444445 + \left(y \cdot y\right) \cdot -0.00205026455026455\right)\right)\right)}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{+77}:\\
\;\;\;\;\frac{\sinh y}{y}\\
\mathbf{else}:\\
\;\;\;\;\cos x \cdot \left(1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + \left(y \cdot y\right) \cdot 0.008333333333333333\right)\right)\\
\end{array}
\end{array}
if y < 0.26000000000000001Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in y around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.1%
Simplified70.1%
if 0.26000000000000001 < y < 3.8000000000000001e77Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified81.8%
clear-numN/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f6481.8%
Applied egg-rr81.8%
if 3.8000000000000001e77 < y Initial program 100.0%
Taylor expanded in y around 0
distribute-rgt-inN/A
*-rgt-identityN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-outN/A
+-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
Simplified100.0%
(FPCore (x y)
:precision binary64
(let* ((t_0
(*
(cos x)
(+
1.0
(*
(* y y)
(+ 0.16666666666666666 (* (* y y) 0.008333333333333333)))))))
(if (<= y 0.39) t_0 (if (<= y 3.8e+77) (/ (sinh y) y) t_0))))
double code(double x, double y) {
double t_0 = cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
double tmp;
if (y <= 0.39) {
tmp = t_0;
} else if (y <= 3.8e+77) {
tmp = sinh(y) / y;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = cos(x) * (1.0d0 + ((y * y) * (0.16666666666666666d0 + ((y * y) * 0.008333333333333333d0))))
if (y <= 0.39d0) then
tmp = t_0
else if (y <= 3.8d+77) then
tmp = sinh(y) / y
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
double tmp;
if (y <= 0.39) {
tmp = t_0;
} else if (y <= 3.8e+77) {
tmp = Math.sinh(y) / y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333)))) tmp = 0 if y <= 0.39: tmp = t_0 elif y <= 3.8e+77: tmp = math.sinh(y) / y else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(cos(x) * Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + Float64(Float64(y * y) * 0.008333333333333333))))) tmp = 0.0 if (y <= 0.39) tmp = t_0; elseif (y <= 3.8e+77) tmp = Float64(sinh(y) / y); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = cos(x) * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * 0.008333333333333333)))); tmp = 0.0; if (y <= 0.39) tmp = t_0; elseif (y <= 3.8e+77) tmp = sinh(y) / y; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Cos[x], $MachinePrecision] * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * 0.008333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, 0.39], t$95$0, If[LessEqual[y, 3.8e+77], N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos x \cdot \left(1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + \left(y \cdot y\right) \cdot 0.008333333333333333\right)\right)\\
\mathbf{if}\;y \leq 0.39:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{+77}:\\
\;\;\;\;\frac{\sinh y}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < 0.39000000000000001 or 3.8000000000000001e77 < y Initial program 100.0%
Taylor expanded in y around 0
distribute-rgt-inN/A
*-rgt-identityN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-outN/A
+-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
Simplified96.1%
if 0.39000000000000001 < y < 3.8000000000000001e77Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified81.8%
clear-numN/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f6481.8%
Applied egg-rr81.8%
(FPCore (x y) :precision binary64 (let* ((t_0 (* (cos x) (+ 1.0 (* (* y y) 0.16666666666666666))))) (if (<= y 0.054) t_0 (if (<= y 1.32e+154) (/ (sinh y) y) t_0))))
double code(double x, double y) {
double t_0 = cos(x) * (1.0 + ((y * y) * 0.16666666666666666));
double tmp;
if (y <= 0.054) {
tmp = t_0;
} else if (y <= 1.32e+154) {
tmp = sinh(y) / y;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = cos(x) * (1.0d0 + ((y * y) * 0.16666666666666666d0))
if (y <= 0.054d0) then
tmp = t_0
else if (y <= 1.32d+154) then
tmp = sinh(y) / y
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.cos(x) * (1.0 + ((y * y) * 0.16666666666666666));
double tmp;
if (y <= 0.054) {
tmp = t_0;
} else if (y <= 1.32e+154) {
tmp = Math.sinh(y) / y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.cos(x) * (1.0 + ((y * y) * 0.16666666666666666)) tmp = 0 if y <= 0.054: tmp = t_0 elif y <= 1.32e+154: tmp = math.sinh(y) / y else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(cos(x) * Float64(1.0 + Float64(Float64(y * y) * 0.16666666666666666))) tmp = 0.0 if (y <= 0.054) tmp = t_0; elseif (y <= 1.32e+154) tmp = Float64(sinh(y) / y); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = cos(x) * (1.0 + ((y * y) * 0.16666666666666666)); tmp = 0.0; if (y <= 0.054) tmp = t_0; elseif (y <= 1.32e+154) tmp = sinh(y) / y; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Cos[x], $MachinePrecision] * N[(1.0 + N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, 0.054], t$95$0, If[LessEqual[y, 1.32e+154], N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos x \cdot \left(1 + \left(y \cdot y\right) \cdot 0.16666666666666666\right)\\
\mathbf{if}\;y \leq 0.054:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 1.32 \cdot 10^{+154}:\\
\;\;\;\;\frac{\sinh y}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < 0.0539999999999999994 or 1.31999999999999998e154 < y Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6490.8%
Simplified90.8%
if 0.0539999999999999994 < y < 1.31999999999999998e154Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified84.0%
clear-numN/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f6484.0%
Applied egg-rr84.0%
Final simplification90.1%
(FPCore (x y) :precision binary64 (if (<= y 0.00096) (cos x) (/ (sinh y) y)))
double code(double x, double y) {
double tmp;
if (y <= 0.00096) {
tmp = cos(x);
} else {
tmp = sinh(y) / y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 0.00096d0) then
tmp = cos(x)
else
tmp = sinh(y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 0.00096) {
tmp = Math.cos(x);
} else {
tmp = Math.sinh(y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 0.00096: tmp = math.cos(x) else: tmp = math.sinh(y) / y return tmp
function code(x, y) tmp = 0.0 if (y <= 0.00096) tmp = cos(x); else tmp = Float64(sinh(y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 0.00096) tmp = cos(x); else tmp = sinh(y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 0.00096], N[Cos[x], $MachinePrecision], N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 0.00096:\\
\;\;\;\;\cos x\\
\mathbf{else}:\\
\;\;\;\;\frac{\sinh y}{y}\\
\end{array}
\end{array}
if y < 9.60000000000000024e-4Initial program 100.0%
Taylor expanded in y around 0
cos-lowering-cos.f6469.7%
Simplified69.7%
if 9.60000000000000024e-4 < y Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified80.0%
clear-numN/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f6480.0%
Applied egg-rr80.0%
(FPCore (x y)
:precision binary64
(let* ((t_0
(*
(* y y)
(+ 0.008333333333333333 (* (* y y) 0.0001984126984126984)))))
(if (<= y 0.00096)
(cos x)
(if (<= y 2.8e+39)
(+
1.0
(/
(* (* y y) (+ 0.004629629629629629 (* t_0 (* t_0 t_0))))
(+ 0.027777777777777776 (* t_0 (- t_0 0.16666666666666666)))))
(/ 1.0 (/ y (* y (+ 1.0 (* (* y y) (+ 0.16666666666666666 t_0))))))))))
double code(double x, double y) {
double t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984));
double tmp;
if (y <= 0.00096) {
tmp = cos(x);
} else if (y <= 2.8e+39) {
tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666))));
} else {
tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0)))));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = (y * y) * (0.008333333333333333d0 + ((y * y) * 0.0001984126984126984d0))
if (y <= 0.00096d0) then
tmp = cos(x)
else if (y <= 2.8d+39) then
tmp = 1.0d0 + (((y * y) * (0.004629629629629629d0 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776d0 + (t_0 * (t_0 - 0.16666666666666666d0))))
else
tmp = 1.0d0 / (y / (y * (1.0d0 + ((y * y) * (0.16666666666666666d0 + t_0)))))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984));
double tmp;
if (y <= 0.00096) {
tmp = Math.cos(x);
} else if (y <= 2.8e+39) {
tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666))));
} else {
tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0)))));
}
return tmp;
}
def code(x, y): t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)) tmp = 0 if y <= 0.00096: tmp = math.cos(x) elif y <= 2.8e+39: tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666)))) else: tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0))))) return tmp
function code(x, y) t_0 = Float64(Float64(y * y) * Float64(0.008333333333333333 + Float64(Float64(y * y) * 0.0001984126984126984))) tmp = 0.0 if (y <= 0.00096) tmp = cos(x); elseif (y <= 2.8e+39) tmp = Float64(1.0 + Float64(Float64(Float64(y * y) * Float64(0.004629629629629629 + Float64(t_0 * Float64(t_0 * t_0)))) / Float64(0.027777777777777776 + Float64(t_0 * Float64(t_0 - 0.16666666666666666))))); else tmp = Float64(1.0 / Float64(y / Float64(y * Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + t_0)))))); end return tmp end
function tmp_2 = code(x, y) t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)); tmp = 0.0; if (y <= 0.00096) tmp = cos(x); elseif (y <= 2.8e+39) tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666)))); else tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0))))); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[(y * y), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, 0.00096], N[Cos[x], $MachinePrecision], If[LessEqual[y, 2.8e+39], N[(1.0 + N[(N[(N[(y * y), $MachinePrecision] * N[(0.004629629629629629 + N[(t$95$0 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.027777777777777776 + N[(t$95$0 * N[(t$95$0 - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(y / N[(y * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y \cdot y\right) \cdot \left(0.008333333333333333 + \left(y \cdot y\right) \cdot 0.0001984126984126984\right)\\
\mathbf{if}\;y \leq 0.00096:\\
\;\;\;\;\cos x\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{+39}:\\
\;\;\;\;1 + \frac{\left(y \cdot y\right) \cdot \left(0.004629629629629629 + t\_0 \cdot \left(t\_0 \cdot t\_0\right)\right)}{0.027777777777777776 + t\_0 \cdot \left(t\_0 - 0.16666666666666666\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{y}{y \cdot \left(1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + t\_0\right)\right)}}\\
\end{array}
\end{array}
if y < 9.60000000000000024e-4Initial program 100.0%
Taylor expanded in y around 0
cos-lowering-cos.f6469.7%
Simplified69.7%
if 9.60000000000000024e-4 < y < 2.80000000000000001e39Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified100.0%
Taylor expanded in y around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f644.4%
Simplified4.4%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr61.4%
if 2.80000000000000001e39 < y Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified78.0%
Taylor expanded in y around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6478.0%
Simplified78.0%
Final simplification71.2%
(FPCore (x y)
:precision binary64
(let* ((t_0
(*
(* y y)
(+ 0.008333333333333333 (* (* y y) 0.0001984126984126984)))))
(if (<= y 2.8e+39)
(+
1.0
(/
(* (* y y) (+ 0.004629629629629629 (* t_0 (* t_0 t_0))))
(+ 0.027777777777777776 (* t_0 (- t_0 0.16666666666666666)))))
(/ 1.0 (/ y (* y (+ 1.0 (* (* y y) (+ 0.16666666666666666 t_0)))))))))
double code(double x, double y) {
double t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984));
double tmp;
if (y <= 2.8e+39) {
tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666))));
} else {
tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0)))));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = (y * y) * (0.008333333333333333d0 + ((y * y) * 0.0001984126984126984d0))
if (y <= 2.8d+39) then
tmp = 1.0d0 + (((y * y) * (0.004629629629629629d0 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776d0 + (t_0 * (t_0 - 0.16666666666666666d0))))
else
tmp = 1.0d0 / (y / (y * (1.0d0 + ((y * y) * (0.16666666666666666d0 + t_0)))))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984));
double tmp;
if (y <= 2.8e+39) {
tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666))));
} else {
tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0)))));
}
return tmp;
}
def code(x, y): t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)) tmp = 0 if y <= 2.8e+39: tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666)))) else: tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0))))) return tmp
function code(x, y) t_0 = Float64(Float64(y * y) * Float64(0.008333333333333333 + Float64(Float64(y * y) * 0.0001984126984126984))) tmp = 0.0 if (y <= 2.8e+39) tmp = Float64(1.0 + Float64(Float64(Float64(y * y) * Float64(0.004629629629629629 + Float64(t_0 * Float64(t_0 * t_0)))) / Float64(0.027777777777777776 + Float64(t_0 * Float64(t_0 - 0.16666666666666666))))); else tmp = Float64(1.0 / Float64(y / Float64(y * Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + t_0)))))); end return tmp end
function tmp_2 = code(x, y) t_0 = (y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)); tmp = 0.0; if (y <= 2.8e+39) tmp = 1.0 + (((y * y) * (0.004629629629629629 + (t_0 * (t_0 * t_0)))) / (0.027777777777777776 + (t_0 * (t_0 - 0.16666666666666666)))); else tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + t_0))))); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[(y * y), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, 2.8e+39], N[(1.0 + N[(N[(N[(y * y), $MachinePrecision] * N[(0.004629629629629629 + N[(t$95$0 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(0.027777777777777776 + N[(t$95$0 * N[(t$95$0 - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(y / N[(y * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y \cdot y\right) \cdot \left(0.008333333333333333 + \left(y \cdot y\right) \cdot 0.0001984126984126984\right)\\
\mathbf{if}\;y \leq 2.8 \cdot 10^{+39}:\\
\;\;\;\;1 + \frac{\left(y \cdot y\right) \cdot \left(0.004629629629629629 + t\_0 \cdot \left(t\_0 \cdot t\_0\right)\right)}{0.027777777777777776 + t\_0 \cdot \left(t\_0 - 0.16666666666666666\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{y}{y \cdot \left(1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + t\_0\right)\right)}}\\
\end{array}
\end{array}
if y < 2.80000000000000001e39Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified67.5%
Taylor expanded in y around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6463.3%
Simplified63.3%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr43.2%
if 2.80000000000000001e39 < y Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified78.0%
Taylor expanded in y around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6478.0%
Simplified78.0%
Final simplification50.0%
(FPCore (x y)
:precision binary64
(/
1.0
(/
y
(*
y
(+
1.0
(*
(* y y)
(+
0.16666666666666666
(*
(* y y)
(+ 0.008333333333333333 (* (* y y) 0.0001984126984126984))))))))))
double code(double x, double y) {
return 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984))))))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 / (y / (y * (1.0d0 + ((y * y) * (0.16666666666666666d0 + ((y * y) * (0.008333333333333333d0 + ((y * y) * 0.0001984126984126984d0))))))))
end function
public static double code(double x, double y) {
return 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984))))))));
}
def code(x, y): return 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984))))))))
function code(x, y) return Float64(1.0 / Float64(y / Float64(y * Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + Float64(Float64(y * y) * Float64(0.008333333333333333 + Float64(Float64(y * y) * 0.0001984126984126984))))))))) end
function tmp = code(x, y) tmp = 1.0 / (y / (y * (1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)))))))); end
code[x_, y_] := N[(1.0 / N[(y / N[(y * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\frac{y}{y \cdot \left(1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + \left(y \cdot y\right) \cdot \left(0.008333333333333333 + \left(y \cdot y\right) \cdot 0.0001984126984126984\right)\right)\right)}}
\end{array}
Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified69.5%
Taylor expanded in y around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.5%
Simplified66.5%
(FPCore (x y)
:precision binary64
(if (<= y 8e+27)
(+ 1.0 (* (* y y) 0.16666666666666666))
(if (<= y 1.65e+154)
(* (* (* y y) 0.006944444444444444) (* (* x x) (* x x)))
(+ 1.0 (* y (* y 0.16666666666666666))))))
double code(double x, double y) {
double tmp;
if (y <= 8e+27) {
tmp = 1.0 + ((y * y) * 0.16666666666666666);
} else if (y <= 1.65e+154) {
tmp = ((y * y) * 0.006944444444444444) * ((x * x) * (x * x));
} else {
tmp = 1.0 + (y * (y * 0.16666666666666666));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 8d+27) then
tmp = 1.0d0 + ((y * y) * 0.16666666666666666d0)
else if (y <= 1.65d+154) then
tmp = ((y * y) * 0.006944444444444444d0) * ((x * x) * (x * x))
else
tmp = 1.0d0 + (y * (y * 0.16666666666666666d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 8e+27) {
tmp = 1.0 + ((y * y) * 0.16666666666666666);
} else if (y <= 1.65e+154) {
tmp = ((y * y) * 0.006944444444444444) * ((x * x) * (x * x));
} else {
tmp = 1.0 + (y * (y * 0.16666666666666666));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 8e+27: tmp = 1.0 + ((y * y) * 0.16666666666666666) elif y <= 1.65e+154: tmp = ((y * y) * 0.006944444444444444) * ((x * x) * (x * x)) else: tmp = 1.0 + (y * (y * 0.16666666666666666)) return tmp
function code(x, y) tmp = 0.0 if (y <= 8e+27) tmp = Float64(1.0 + Float64(Float64(y * y) * 0.16666666666666666)); elseif (y <= 1.65e+154) tmp = Float64(Float64(Float64(y * y) * 0.006944444444444444) * Float64(Float64(x * x) * Float64(x * x))); else tmp = Float64(1.0 + Float64(y * Float64(y * 0.16666666666666666))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 8e+27) tmp = 1.0 + ((y * y) * 0.16666666666666666); elseif (y <= 1.65e+154) tmp = ((y * y) * 0.006944444444444444) * ((x * x) * (x * x)); else tmp = 1.0 + (y * (y * 0.16666666666666666)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 8e+27], N[(1.0 + N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.65e+154], N[(N[(N[(y * y), $MachinePrecision] * 0.006944444444444444), $MachinePrecision] * N[(N[(x * x), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(y * N[(y * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 8 \cdot 10^{+27}:\\
\;\;\;\;1 + \left(y \cdot y\right) \cdot 0.16666666666666666\\
\mathbf{elif}\;y \leq 1.65 \cdot 10^{+154}:\\
\;\;\;\;\left(\left(y \cdot y\right) \cdot 0.006944444444444444\right) \cdot \left(\left(x \cdot x\right) \cdot \left(x \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;1 + y \cdot \left(y \cdot 0.16666666666666666\right)\\
\end{array}
\end{array}
if y < 8.0000000000000001e27Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6487.7%
Simplified87.7%
/-rgt-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f6487.6%
Applied egg-rr87.6%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6458.0%
Simplified58.0%
if 8.0000000000000001e27 < y < 1.65e154Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f646.0%
Simplified6.0%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6436.1%
Simplified36.1%
Taylor expanded in x around inf
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
metadata-evalN/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.6%
Simplified34.6%
Taylor expanded in y around inf
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.6%
Simplified34.6%
if 1.65e154 < y Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6476.7%
Simplified76.7%
Final simplification58.3%
(FPCore (x y)
:precision binary64
(+
1.0
(*
(* y y)
(+
0.16666666666666666
(* (* y y) (+ 0.008333333333333333 (* (* y y) 0.0001984126984126984)))))))
double code(double x, double y) {
return 1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + ((y * y) * (0.16666666666666666d0 + ((y * y) * (0.008333333333333333d0 + ((y * y) * 0.0001984126984126984d0)))))
end function
public static double code(double x, double y) {
return 1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)))));
}
def code(x, y): return 1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984)))))
function code(x, y) return Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + Float64(Float64(y * y) * Float64(0.008333333333333333 + Float64(Float64(y * y) * 0.0001984126984126984)))))) end
function tmp = code(x, y) tmp = 1.0 + ((y * y) * (0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * 0.0001984126984126984))))); end
code[x_, y_] := N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + \left(y \cdot y\right) \cdot \left(0.008333333333333333 + \left(y \cdot y\right) \cdot 0.0001984126984126984\right)\right)
\end{array}
Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified69.5%
Taylor expanded in y around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.2%
Simplified66.2%
(FPCore (x y) :precision binary64 (+ 1.0 (* (* y y) (+ 0.16666666666666666 (* y (* y (* (* y y) 0.0001984126984126984)))))))
double code(double x, double y) {
return 1.0 + ((y * y) * (0.16666666666666666 + (y * (y * ((y * y) * 0.0001984126984126984)))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + ((y * y) * (0.16666666666666666d0 + (y * (y * ((y * y) * 0.0001984126984126984d0)))))
end function
public static double code(double x, double y) {
return 1.0 + ((y * y) * (0.16666666666666666 + (y * (y * ((y * y) * 0.0001984126984126984)))));
}
def code(x, y): return 1.0 + ((y * y) * (0.16666666666666666 + (y * (y * ((y * y) * 0.0001984126984126984)))))
function code(x, y) return Float64(1.0 + Float64(Float64(y * y) * Float64(0.16666666666666666 + Float64(y * Float64(y * Float64(Float64(y * y) * 0.0001984126984126984)))))) end
function tmp = code(x, y) tmp = 1.0 + ((y * y) * (0.16666666666666666 + (y * (y * ((y * y) * 0.0001984126984126984))))); end
code[x_, y_] := N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(0.16666666666666666 + N[(y * N[(y * N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(y \cdot y\right) \cdot \left(0.16666666666666666 + y \cdot \left(y \cdot \left(\left(y \cdot y\right) \cdot 0.0001984126984126984\right)\right)\right)
\end{array}
Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified69.5%
Taylor expanded in y around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.2%
Simplified66.2%
Taylor expanded in y around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.1%
Simplified66.1%
(FPCore (x y) :precision binary64 (+ 1.0 (* (* y y) (* y (* y (* (* y y) 0.0001984126984126984))))))
double code(double x, double y) {
return 1.0 + ((y * y) * (y * (y * ((y * y) * 0.0001984126984126984))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + ((y * y) * (y * (y * ((y * y) * 0.0001984126984126984d0))))
end function
public static double code(double x, double y) {
return 1.0 + ((y * y) * (y * (y * ((y * y) * 0.0001984126984126984))));
}
def code(x, y): return 1.0 + ((y * y) * (y * (y * ((y * y) * 0.0001984126984126984))))
function code(x, y) return Float64(1.0 + Float64(Float64(y * y) * Float64(y * Float64(y * Float64(Float64(y * y) * 0.0001984126984126984))))) end
function tmp = code(x, y) tmp = 1.0 + ((y * y) * (y * (y * ((y * y) * 0.0001984126984126984)))); end
code[x_, y_] := N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(y * N[(y * N[(N[(y * y), $MachinePrecision] * 0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(y \cdot y\right) \cdot \left(y \cdot \left(y \cdot \left(\left(y \cdot y\right) \cdot 0.0001984126984126984\right)\right)\right)
\end{array}
Initial program 100.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
sinh-lowering-sinh.f64100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0
Simplified69.5%
Taylor expanded in y around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.2%
Simplified66.2%
Taylor expanded in y around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.0%
Simplified66.0%
(FPCore (x y) :precision binary64 (if (<= x 4.5e+130) (+ 1.0 (* (* y y) 0.16666666666666666)) (* (* (* x x) (* x x)) 0.041666666666666664)))
double code(double x, double y) {
double tmp;
if (x <= 4.5e+130) {
tmp = 1.0 + ((y * y) * 0.16666666666666666);
} else {
tmp = ((x * x) * (x * x)) * 0.041666666666666664;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= 4.5d+130) then
tmp = 1.0d0 + ((y * y) * 0.16666666666666666d0)
else
tmp = ((x * x) * (x * x)) * 0.041666666666666664d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= 4.5e+130) {
tmp = 1.0 + ((y * y) * 0.16666666666666666);
} else {
tmp = ((x * x) * (x * x)) * 0.041666666666666664;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= 4.5e+130: tmp = 1.0 + ((y * y) * 0.16666666666666666) else: tmp = ((x * x) * (x * x)) * 0.041666666666666664 return tmp
function code(x, y) tmp = 0.0 if (x <= 4.5e+130) tmp = Float64(1.0 + Float64(Float64(y * y) * 0.16666666666666666)); else tmp = Float64(Float64(Float64(x * x) * Float64(x * x)) * 0.041666666666666664); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= 4.5e+130) tmp = 1.0 + ((y * y) * 0.16666666666666666); else tmp = ((x * x) * (x * x)) * 0.041666666666666664; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, 4.5e+130], N[(1.0 + N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * x), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * 0.041666666666666664), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 4.5 \cdot 10^{+130}:\\
\;\;\;\;1 + \left(y \cdot y\right) \cdot 0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\left(\left(x \cdot x\right) \cdot \left(x \cdot x\right)\right) \cdot 0.041666666666666664\\
\end{array}
\end{array}
if x < 4.50000000000000039e130Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6482.9%
Simplified82.9%
/-rgt-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f6482.9%
Applied egg-rr82.9%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6462.0%
Simplified62.0%
if 4.50000000000000039e130 < x Initial program 100.0%
Taylor expanded in y around 0
cos-lowering-cos.f6458.1%
Simplified58.1%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.3%
Simplified28.3%
Taylor expanded in x around inf
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.3%
Simplified28.3%
Final simplification57.1%
(FPCore (x y) :precision binary64 (+ 1.0 (* y (* y (+ 0.16666666666666666 (* (* y y) 0.008333333333333333))))))
double code(double x, double y) {
return 1.0 + (y * (y * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (y * (y * (0.16666666666666666d0 + ((y * y) * 0.008333333333333333d0))))
end function
public static double code(double x, double y) {
return 1.0 + (y * (y * (0.16666666666666666 + ((y * y) * 0.008333333333333333))));
}
def code(x, y): return 1.0 + (y * (y * (0.16666666666666666 + ((y * y) * 0.008333333333333333))))
function code(x, y) return Float64(1.0 + Float64(y * Float64(y * Float64(0.16666666666666666 + Float64(Float64(y * y) * 0.008333333333333333))))) end
function tmp = code(x, y) tmp = 1.0 + (y * (y * (0.16666666666666666 + ((y * y) * 0.008333333333333333)))); end
code[x_, y_] := N[(1.0 + N[(y * N[(y * N[(0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * 0.008333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + y \cdot \left(y \cdot \left(0.16666666666666666 + \left(y \cdot y\right) \cdot 0.008333333333333333\right)\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
distribute-rgt-inN/A
*-rgt-identityN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-outN/A
+-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
Simplified92.2%
Taylor expanded in x around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6463.6%
Simplified63.6%
(FPCore (x y) :precision binary64 (if (<= y 0.007) 1.0 (* (* y y) 0.16666666666666666)))
double code(double x, double y) {
double tmp;
if (y <= 0.007) {
tmp = 1.0;
} else {
tmp = (y * y) * 0.16666666666666666;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 0.007d0) then
tmp = 1.0d0
else
tmp = (y * y) * 0.16666666666666666d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 0.007) {
tmp = 1.0;
} else {
tmp = (y * y) * 0.16666666666666666;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 0.007: tmp = 1.0 else: tmp = (y * y) * 0.16666666666666666 return tmp
function code(x, y) tmp = 0.0 if (y <= 0.007) tmp = 1.0; else tmp = Float64(Float64(y * y) * 0.16666666666666666); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 0.007) tmp = 1.0; else tmp = (y * y) * 0.16666666666666666; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 0.007], 1.0, N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 0.007:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot y\right) \cdot 0.16666666666666666\\
\end{array}
\end{array}
if y < 0.00700000000000000015Initial program 100.0%
Taylor expanded in y around 0
cos-lowering-cos.f6469.7%
Simplified69.7%
Taylor expanded in x around 0
Simplified42.3%
if 0.00700000000000000015 < y Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6457.1%
Simplified57.1%
/-rgt-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f6457.1%
Applied egg-rr57.1%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6443.9%
Simplified43.9%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6443.9%
Simplified43.9%
Final simplification42.7%
(FPCore (x y) :precision binary64 (+ 1.0 (* y (* y 0.16666666666666666))))
double code(double x, double y) {
return 1.0 + (y * (y * 0.16666666666666666));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (y * (y * 0.16666666666666666d0))
end function
public static double code(double x, double y) {
return 1.0 + (y * (y * 0.16666666666666666));
}
def code(x, y): return 1.0 + (y * (y * 0.16666666666666666))
function code(x, y) return Float64(1.0 + Float64(y * Float64(y * 0.16666666666666666))) end
function tmp = code(x, y) tmp = 1.0 + (y * (y * 0.16666666666666666)); end
code[x_, y_] := N[(1.0 + N[(y * N[(y * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + y \cdot \left(y \cdot 0.16666666666666666\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6482.5%
Simplified82.5%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6455.8%
Simplified55.8%
(FPCore (x y) :precision binary64 (+ 1.0 (* (* y y) 0.16666666666666666)))
double code(double x, double y) {
return 1.0 + ((y * y) * 0.16666666666666666);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + ((y * y) * 0.16666666666666666d0)
end function
public static double code(double x, double y) {
return 1.0 + ((y * y) * 0.16666666666666666);
}
def code(x, y): return 1.0 + ((y * y) * 0.16666666666666666)
function code(x, y) return Float64(1.0 + Float64(Float64(y * y) * 0.16666666666666666)) end
function tmp = code(x, y) tmp = 1.0 + ((y * y) * 0.16666666666666666); end
code[x_, y_] := N[(1.0 + N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(y \cdot y\right) \cdot 0.16666666666666666
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6482.5%
Simplified82.5%
/-rgt-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f6482.4%
Applied egg-rr82.4%
Taylor expanded in x around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6455.8%
Simplified55.8%
Final simplification55.8%
(FPCore (x y) :precision binary64 1.0)
double code(double x, double y) {
return 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0
end function
public static double code(double x, double y) {
return 1.0;
}
def code(x, y): return 1.0
function code(x, y) return 1.0 end
function tmp = code(x, y) tmp = 1.0; end
code[x_, y_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
cos-lowering-cos.f6455.4%
Simplified55.4%
Taylor expanded in x around 0
Simplified33.8%
herbie shell --seed 2024161
(FPCore (x y)
:name "Linear.Quaternion:$csin from linear-1.19.1.3"
:precision binary64
(* (cos x) (/ (sinh y) y)))