
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
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
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- y z) (- a z)) (- t x) x))
(t_2 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_2 -1e-304)
t_1
(if (<= t_2 0.0) (fma 1.0 (* (/ (- t x) z) (- a y)) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((y - z) / (a - z)), (t - x), x);
double t_2 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if (t_2 <= -1e-304) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = fma(1.0, (((t - x) / z) * (a - y)), t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x) t_2 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if (t_2 <= -1e-304) tmp = t_1; elseif (t_2 <= 0.0) tmp = fma(1.0, Float64(Float64(Float64(t - x) / z) * Float64(a - y)), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-304], t$95$1, If[LessEqual[t$95$2, 0.0], N[(1.0 * N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
t_2 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-304}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{t - x}{z} \cdot \left(a - y\right), t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.99999999999999971e-305 or 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 91.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.3
Applied rewrites95.3%
if -9.99999999999999971e-305 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.3%
Taylor expanded in z around inf
associate--l+N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in a around 0
Applied rewrites99.8%
Final simplification95.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- y z) (- a z)) (- t x) x))
(t_2 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_2 -1e-304)
t_1
(if (<= t_2 0.0) (fma (- a y) (/ (- x) z) t) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((y - z) / (a - z)), (t - x), x);
double t_2 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if (t_2 <= -1e-304) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = fma((a - y), (-x / z), t);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x) t_2 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if (t_2 <= -1e-304) tmp = t_1; elseif (t_2 <= 0.0) tmp = fma(Float64(a - y), Float64(Float64(-x) / z), t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-304], t$95$1, If[LessEqual[t$95$2, 0.0], N[(N[(a - y), $MachinePrecision] * N[((-x) / z), $MachinePrecision] + t), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
t_2 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-304}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(a - y, \frac{-x}{z}, t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.99999999999999971e-305 or 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 91.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.3
Applied rewrites95.3%
if -9.99999999999999971e-305 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f643.3
Applied rewrites3.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites99.6%
Taylor expanded in t around 0
Applied rewrites99.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- a y) (/ (- x) z) t)))
(if (<= z -4.8e+91)
t_1
(if (<= z -7.2e-48)
(+ t (/ (* y (- x t)) z))
(if (<= z 0.00068) (fma (/ y a) (- t x) x) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((a - y), (-x / z), t);
double tmp;
if (z <= -4.8e+91) {
tmp = t_1;
} else if (z <= -7.2e-48) {
tmp = t + ((y * (x - t)) / z);
} else if (z <= 0.00068) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(a - y), Float64(Float64(-x) / z), t) tmp = 0.0 if (z <= -4.8e+91) tmp = t_1; elseif (z <= -7.2e-48) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (z <= 0.00068) tmp = fma(Float64(y / a), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a - y), $MachinePrecision] * N[((-x) / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -4.8e+91], t$95$1, If[LessEqual[z, -7.2e-48], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.00068], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a - y, \frac{-x}{z}, t\right)\\
\mathbf{if}\;z \leq -4.8 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -7.2 \cdot 10^{-48}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;z \leq 0.00068:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -4.79999999999999966e91 or 6.8e-4 < z Initial program 67.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.1
Applied rewrites73.1%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites77.6%
Taylor expanded in t around 0
Applied rewrites74.5%
if -4.79999999999999966e91 < z < -7.2000000000000003e-48Initial program 86.6%
Taylor expanded in z around inf
associate--l+N/A
+-commutativeN/A
Applied rewrites61.8%
Taylor expanded in a around 0
Applied rewrites63.0%
if -7.2000000000000003e-48 < z < 6.8e-4Initial program 94.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.8
Applied rewrites95.8%
Taylor expanded in z around 0
lower-/.f6479.4
Applied rewrites79.4%
Final simplification75.2%
(FPCore (x y z t a)
:precision binary64
(if (<= a -2.3e+15)
(fma (/ y a) (- t x) x)
(if (<= a 1.85e-19)
(+ t (/ (* y (- x t)) z))
(if (<= a 4e+51) (* (- y z) (/ t (- a z))) (fma (- y z) (/ t a) x)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e+15) {
tmp = fma((y / a), (t - x), x);
} else if (a <= 1.85e-19) {
tmp = t + ((y * (x - t)) / z);
} else if (a <= 4e+51) {
tmp = (y - z) * (t / (a - z));
} else {
tmp = fma((y - z), (t / a), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.3e+15) tmp = fma(Float64(y / a), Float64(t - x), x); elseif (a <= 1.85e-19) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); elseif (a <= 4e+51) tmp = Float64(Float64(y - z) * Float64(t / Float64(a - z))); else tmp = fma(Float64(y - z), Float64(t / a), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.3e+15], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, 1.85e-19], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4e+51], N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.3 \cdot 10^{+15}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{elif}\;a \leq 1.85 \cdot 10^{-19}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{elif}\;a \leq 4 \cdot 10^{+51}:\\
\;\;\;\;\left(y - z\right) \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t}{a}, x\right)\\
\end{array}
\end{array}
if a < -2.3e15Initial program 93.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in z around 0
lower-/.f6470.9
Applied rewrites70.9%
if -2.3e15 < a < 1.85000000000000003e-19Initial program 74.6%
Taylor expanded in z around inf
associate--l+N/A
+-commutativeN/A
Applied rewrites78.4%
Taylor expanded in a around 0
Applied rewrites74.7%
if 1.85000000000000003e-19 < a < 4e51Initial program 86.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6486.8
Applied rewrites86.8%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6465.0
Applied rewrites65.0%
Applied rewrites73.5%
if 4e51 < a Initial program 85.2%
Taylor expanded in a around inf
lower-/.f64N/A
lower--.f6479.9
Applied rewrites79.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6479.9
Applied rewrites79.9%
Taylor expanded in t around inf
Applied rewrites72.1%
Final simplification73.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ z (- z a)))))
(if (<= z -5.1e-64)
t_1
(if (<= z -1.9e-191)
(/ (* (- y z) t) a)
(if (<= z 2.05e-7) (* t (/ y (- a z))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -5.1e-64) {
tmp = t_1;
} else if (z <= -1.9e-191) {
tmp = ((y - z) * t) / a;
} else if (z <= 2.05e-7) {
tmp = t * (y / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = t * (z / (z - a))
if (z <= (-5.1d-64)) then
tmp = t_1
else if (z <= (-1.9d-191)) then
tmp = ((y - z) * t) / a
else if (z <= 2.05d-7) then
tmp = t * (y / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -5.1e-64) {
tmp = t_1;
} else if (z <= -1.9e-191) {
tmp = ((y - z) * t) / a;
} else if (z <= 2.05e-7) {
tmp = t * (y / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (z / (z - a)) tmp = 0 if z <= -5.1e-64: tmp = t_1 elif z <= -1.9e-191: tmp = ((y - z) * t) / a elif z <= 2.05e-7: tmp = t * (y / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(z / Float64(z - a))) tmp = 0.0 if (z <= -5.1e-64) tmp = t_1; elseif (z <= -1.9e-191) tmp = Float64(Float64(Float64(y - z) * t) / a); elseif (z <= 2.05e-7) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (z / (z - a)); tmp = 0.0; if (z <= -5.1e-64) tmp = t_1; elseif (z <= -1.9e-191) tmp = ((y - z) * t) / a; elseif (z <= 2.05e-7) tmp = t * (y / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.1e-64], t$95$1, If[LessEqual[z, -1.9e-191], N[(N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[z, 2.05e-7], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{z}{z - a}\\
\mathbf{if}\;z \leq -5.1 \cdot 10^{-64}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{-191}:\\
\;\;\;\;\frac{\left(y - z\right) \cdot t}{a}\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{-7}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.09999999999999984e-64 or 2.05e-7 < z Initial program 72.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6477.5
Applied rewrites77.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6441.6
Applied rewrites41.6%
Taylor expanded in y around 0
Applied rewrites49.6%
Applied rewrites49.6%
if -5.09999999999999984e-64 < z < -1.8999999999999999e-191Initial program 96.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.4
Applied rewrites96.4%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6445.6
Applied rewrites45.6%
Taylor expanded in a around inf
Applied rewrites42.3%
if -1.8999999999999999e-191 < z < 2.05e-7Initial program 94.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6440.8
Applied rewrites40.8%
Taylor expanded in y around inf
Applied rewrites37.7%
Final simplification44.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- t x) (/ (- a y) z) t)))
(if (<= z -5.2e+62)
t_1
(if (<= z 0.0007) (fma (/ y (- a z)) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((t - x), ((a - y) / z), t);
double tmp;
if (z <= -5.2e+62) {
tmp = t_1;
} else if (z <= 0.0007) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(t - x), Float64(Float64(a - y) / z), t) tmp = 0.0 if (z <= -5.2e+62) tmp = t_1; elseif (z <= 0.0007) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -5.2e+62], t$95$1, If[LessEqual[z, 0.0007], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t - x, \frac{a - y}{z}, t\right)\\
\mathbf{if}\;z \leq -5.2 \cdot 10^{+62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 0.0007:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.19999999999999968e62 or 6.99999999999999993e-4 < z Initial program 67.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.3
Applied rewrites73.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites77.6%
Applied rewrites78.5%
if -5.19999999999999968e62 < z < 6.99999999999999993e-4Initial program 94.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.3
Applied rewrites95.3%
Taylor expanded in y around inf
lower-/.f64N/A
lower--.f6484.8
Applied rewrites84.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- t x) (/ (- a y) z) t)))
(if (<= z -7.2e-48)
t_1
(if (<= z 0.0007) (fma (- y z) (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((t - x), ((a - y) / z), t);
double tmp;
if (z <= -7.2e-48) {
tmp = t_1;
} else if (z <= 0.0007) {
tmp = fma((y - z), ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(t - x), Float64(Float64(a - y) / z), t) tmp = 0.0 if (z <= -7.2e-48) tmp = t_1; elseif (z <= 0.0007) tmp = fma(Float64(y - z), Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -7.2e-48], t$95$1, If[LessEqual[z, 0.0007], N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t - x, \frac{a - y}{z}, t\right)\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{-48}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 0.0007:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -7.2000000000000003e-48 or 6.99999999999999993e-4 < z Initial program 72.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6477.3
Applied rewrites77.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites74.3%
Applied rewrites75.1%
if -7.2000000000000003e-48 < z < 6.99999999999999993e-4Initial program 94.7%
Taylor expanded in a around inf
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6483.4
Applied rewrites83.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- a y) (/ (- t x) z) t)))
(if (<= z -7.2e-48)
t_1
(if (<= z 0.0007) (fma (- y z) (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((a - y), ((t - x) / z), t);
double tmp;
if (z <= -7.2e-48) {
tmp = t_1;
} else if (z <= 0.0007) {
tmp = fma((y - z), ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(a - y), Float64(Float64(t - x) / z), t) tmp = 0.0 if (z <= -7.2e-48) tmp = t_1; elseif (z <= 0.0007) tmp = fma(Float64(y - z), Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a - y), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -7.2e-48], t$95$1, If[LessEqual[z, 0.0007], N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a - y, \frac{t - x}{z}, t\right)\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{-48}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 0.0007:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -7.2000000000000003e-48 or 6.99999999999999993e-4 < z Initial program 72.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6477.3
Applied rewrites77.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites74.3%
if -7.2000000000000003e-48 < z < 6.99999999999999993e-4Initial program 94.7%
Taylor expanded in a around inf
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6483.4
Applied rewrites83.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (- a y) (/ (- x) z) t)))
(if (<= z -2e+62)
t_1
(if (<= z 0.0007) (fma (- y z) (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((a - y), (-x / z), t);
double tmp;
if (z <= -2e+62) {
tmp = t_1;
} else if (z <= 0.0007) {
tmp = fma((y - z), ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(a - y), Float64(Float64(-x) / z), t) tmp = 0.0 if (z <= -2e+62) tmp = t_1; elseif (z <= 0.0007) tmp = fma(Float64(y - z), Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(a - y), $MachinePrecision] * N[((-x) / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -2e+62], t$95$1, If[LessEqual[z, 0.0007], N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a - y, \frac{-x}{z}, t\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{+62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 0.0007:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.00000000000000007e62 or 6.99999999999999993e-4 < z Initial program 67.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.3
Applied rewrites73.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites77.6%
Taylor expanded in t around 0
Applied rewrites73.9%
if -2.00000000000000007e62 < z < 6.99999999999999993e-4Initial program 94.4%
Taylor expanded in a around inf
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6477.4
Applied rewrites77.4%
(FPCore (x y z t a) :precision binary64 (if (<= a -2.3e+15) (fma (/ y a) (- t x) x) (if (<= a 5.4e-34) (+ t (/ (* y (- x t)) z)) (fma (- y z) (/ t a) x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -2.3e+15) {
tmp = fma((y / a), (t - x), x);
} else if (a <= 5.4e-34) {
tmp = t + ((y * (x - t)) / z);
} else {
tmp = fma((y - z), (t / a), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (a <= -2.3e+15) tmp = fma(Float64(y / a), Float64(t - x), x); elseif (a <= 5.4e-34) tmp = Float64(t + Float64(Float64(y * Float64(x - t)) / z)); else tmp = fma(Float64(y - z), Float64(t / a), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.3e+15], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, 5.4e-34], N[(t + N[(N[(y * N[(x - t), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(N[(y - z), $MachinePrecision] * N[(t / a), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.3 \cdot 10^{+15}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{elif}\;a \leq 5.4 \cdot 10^{-34}:\\
\;\;\;\;t + \frac{y \cdot \left(x - t\right)}{z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t}{a}, x\right)\\
\end{array}
\end{array}
if a < -2.3e15Initial program 93.6%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in z around 0
lower-/.f6470.9
Applied rewrites70.9%
if -2.3e15 < a < 5.40000000000000034e-34Initial program 74.5%
Taylor expanded in z around inf
associate--l+N/A
+-commutativeN/A
Applied rewrites79.7%
Taylor expanded in a around 0
Applied rewrites74.8%
if 5.40000000000000034e-34 < a Initial program 85.4%
Taylor expanded in a around inf
lower-/.f64N/A
lower--.f6473.5
Applied rewrites73.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6473.5
Applied rewrites73.5%
Taylor expanded in t around inf
Applied rewrites66.9%
Final simplification71.1%
(FPCore (x y z t a) :precision binary64 (if (<= z -8e+89) (fma a (/ (- t x) z) t) (if (<= z 1.05e-5) (fma (/ y a) (- t x) x) (* t (/ z (- z a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8e+89) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 1.05e-5) {
tmp = fma((y / a), (t - x), x);
} else {
tmp = t * (z / (z - a));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8e+89) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 1.05e-5) tmp = fma(Float64(y / a), Float64(t - x), x); else tmp = Float64(t * Float64(z / Float64(z - a))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8e+89], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 1.05e-5], N[(N[(y / a), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8 \cdot 10^{+89}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-5}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{z}{z - a}\\
\end{array}
\end{array}
if z < -7.99999999999999996e89Initial program 56.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6466.6
Applied rewrites66.6%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites79.5%
Taylor expanded in y around 0
Applied rewrites62.9%
if -7.99999999999999996e89 < z < 1.04999999999999994e-5Initial program 92.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6494.2
Applied rewrites94.2%
Taylor expanded in z around 0
lower-/.f6471.9
Applied rewrites71.9%
if 1.04999999999999994e-5 < z Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6437.3
Applied rewrites37.3%
Taylor expanded in y around 0
Applied rewrites56.5%
Applied rewrites56.5%
Final simplification66.9%
(FPCore (x y z t a) :precision binary64 (if (<= z -5.2e+62) (fma a (/ (- t x) z) t) (if (<= z 1.05e-5) (fma y (/ (- t x) a) x) (* t (/ z (- z a))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5.2e+62) {
tmp = fma(a, ((t - x) / z), t);
} else if (z <= 1.05e-5) {
tmp = fma(y, ((t - x) / a), x);
} else {
tmp = t * (z / (z - a));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -5.2e+62) tmp = fma(a, Float64(Float64(t - x) / z), t); elseif (z <= 1.05e-5) tmp = fma(y, Float64(Float64(t - x) / a), x); else tmp = Float64(t * Float64(z / Float64(z - a))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.2e+62], N[(a * N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 1.05e-5], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.2 \cdot 10^{+62}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t - x}{z}, t\right)\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-5}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{z}{z - a}\\
\end{array}
\end{array}
if z < -5.19999999999999968e62Initial program 56.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6467.4
Applied rewrites67.4%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
associate-*r/N/A
distribute-lft-out--N/A
cancel-sign-sub-invN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
Applied rewrites78.7%
Taylor expanded in y around 0
Applied rewrites59.6%
if -5.19999999999999968e62 < z < 1.04999999999999994e-5Initial program 94.4%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6472.2
Applied rewrites72.2%
if 1.04999999999999994e-5 < z Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6437.3
Applied rewrites37.3%
Taylor expanded in y around 0
Applied rewrites56.5%
Applied rewrites56.5%
Final simplification66.2%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (* t (/ z (- z a))))) (if (<= z -5.2e+62) t_1 (if (<= z 1.05e-5) (fma y (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -5.2e+62) {
tmp = t_1;
} else if (z <= 1.05e-5) {
tmp = fma(y, ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(t * Float64(z / Float64(z - a))) tmp = 0.0 if (z <= -5.2e+62) tmp = t_1; elseif (z <= 1.05e-5) tmp = fma(y, Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.2e+62], t$95$1, If[LessEqual[z, 1.05e-5], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{z}{z - a}\\
\mathbf{if}\;z \leq -5.2 \cdot 10^{+62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-5}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.19999999999999968e62 or 1.04999999999999994e-5 < z Initial program 67.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.3
Applied rewrites73.3%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6440.0
Applied rewrites40.0%
Taylor expanded in y around 0
Applied rewrites57.5%
Applied rewrites57.5%
if -5.19999999999999968e62 < z < 1.04999999999999994e-5Initial program 94.4%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6472.2
Applied rewrites72.2%
Final simplification66.0%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (* t (/ z (- z a))))) (if (<= z -5e+62) t_1 (if (<= z 4.7e-6) (+ x (/ (* y t) a)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -5e+62) {
tmp = t_1;
} else if (z <= 4.7e-6) {
tmp = x + ((y * t) / a);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = t * (z / (z - a))
if (z <= (-5d+62)) then
tmp = t_1
else if (z <= 4.7d-6) then
tmp = x + ((y * t) / a)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -5e+62) {
tmp = t_1;
} else if (z <= 4.7e-6) {
tmp = x + ((y * t) / a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (z / (z - a)) tmp = 0 if z <= -5e+62: tmp = t_1 elif z <= 4.7e-6: tmp = x + ((y * t) / a) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(z / Float64(z - a))) tmp = 0.0 if (z <= -5e+62) tmp = t_1; elseif (z <= 4.7e-6) tmp = Float64(x + Float64(Float64(y * t) / a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (z / (z - a)); tmp = 0.0; if (z <= -5e+62) tmp = t_1; elseif (z <= 4.7e-6) tmp = x + ((y * t) / a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e+62], t$95$1, If[LessEqual[z, 4.7e-6], N[(x + N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{z}{z - a}\\
\mathbf{if}\;z \leq -5 \cdot 10^{+62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 4.7 \cdot 10^{-6}:\\
\;\;\;\;x + \frac{y \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.00000000000000029e62 or 4.69999999999999989e-6 < z Initial program 67.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.3
Applied rewrites73.3%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6440.0
Applied rewrites40.0%
Taylor expanded in y around 0
Applied rewrites57.5%
Applied rewrites57.5%
if -5.00000000000000029e62 < z < 4.69999999999999989e-6Initial program 94.4%
Taylor expanded in z around 0
lower-/.f64N/A
lower-*.f64N/A
lower--.f6468.7
Applied rewrites68.7%
Taylor expanded in t around inf
Applied rewrites56.9%
Final simplification57.2%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (* t (/ z (- z a))))) (if (<= z -7.2e+60) t_1 (if (<= z 2.05e-7) (* t (/ y (- a z))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -7.2e+60) {
tmp = t_1;
} else if (z <= 2.05e-7) {
tmp = t * (y / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: t_1
real(8) :: tmp
t_1 = t * (z / (z - a))
if (z <= (-7.2d+60)) then
tmp = t_1
else if (z <= 2.05d-7) then
tmp = t * (y / (a - z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (z / (z - a));
double tmp;
if (z <= -7.2e+60) {
tmp = t_1;
} else if (z <= 2.05e-7) {
tmp = t * (y / (a - z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t * (z / (z - a)) tmp = 0 if z <= -7.2e+60: tmp = t_1 elif z <= 2.05e-7: tmp = t * (y / (a - z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(t * Float64(z / Float64(z - a))) tmp = 0.0 if (z <= -7.2e+60) tmp = t_1; elseif (z <= 2.05e-7) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t * (z / (z - a)); tmp = 0.0; if (z <= -7.2e+60) tmp = t_1; elseif (z <= 2.05e-7) tmp = t * (y / (a - z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.2e+60], t$95$1, If[LessEqual[z, 2.05e-7], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \frac{z}{z - a}\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{+60}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{-7}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -7.19999999999999935e60 or 2.05e-7 < z Initial program 67.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6473.3
Applied rewrites73.3%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6440.0
Applied rewrites40.0%
Taylor expanded in y around 0
Applied rewrites57.5%
Applied rewrites57.5%
if -7.19999999999999935e60 < z < 2.05e-7Initial program 94.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.3
Applied rewrites95.3%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6443.2
Applied rewrites43.2%
Taylor expanded in y around inf
Applied rewrites32.2%
Final simplification43.0%
(FPCore (x y z t a) :precision binary64 (if (<= z -8e+61) (fma a (/ t z) t) (if (<= z 9.6e-6) (* t (/ y (- a z))) (* t (+ 1.0 (/ a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8e+61) {
tmp = fma(a, (t / z), t);
} else if (z <= 9.6e-6) {
tmp = t * (y / (a - z));
} else {
tmp = t * (1.0 + (a / z));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8e+61) tmp = fma(a, Float64(t / z), t); elseif (z <= 9.6e-6) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = Float64(t * Float64(1.0 + Float64(a / z))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8e+61], N[(a * N[(t / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 9.6e-6], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(1.0 + N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8 \cdot 10^{+61}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t}{z}, t\right)\\
\mathbf{elif}\;z \leq 9.6 \cdot 10^{-6}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(1 + \frac{a}{z}\right)\\
\end{array}
\end{array}
if z < -7.9999999999999996e61Initial program 56.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6467.4
Applied rewrites67.4%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6442.8
Applied rewrites42.8%
Taylor expanded in y around 0
Applied rewrites58.6%
Taylor expanded in z around inf
Applied rewrites49.8%
if -7.9999999999999996e61 < z < 9.5999999999999996e-6Initial program 94.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6495.3
Applied rewrites95.3%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6443.2
Applied rewrites43.2%
Taylor expanded in y around inf
Applied rewrites32.2%
if 9.5999999999999996e-6 < z Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6437.3
Applied rewrites37.3%
Taylor expanded in y around 0
Applied rewrites56.5%
Taylor expanded in z around inf
Applied rewrites48.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -3.9e-64) (fma a (/ t z) t) (if (<= z 4.2e-6) (* y (/ t a)) (* t (+ 1.0 (/ a z))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.9e-64) {
tmp = fma(a, (t / z), t);
} else if (z <= 4.2e-6) {
tmp = y * (t / a);
} else {
tmp = t * (1.0 + (a / z));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.9e-64) tmp = fma(a, Float64(t / z), t); elseif (z <= 4.2e-6) tmp = Float64(y * Float64(t / a)); else tmp = Float64(t * Float64(1.0 + Float64(a / z))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.9e-64], N[(a * N[(t / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 4.2e-6], N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision], N[(t * N[(1.0 + N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.9 \cdot 10^{-64}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t}{z}, t\right)\\
\mathbf{elif}\;z \leq 4.2 \cdot 10^{-6}:\\
\;\;\;\;y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(1 + \frac{a}{z}\right)\\
\end{array}
\end{array}
if z < -3.8999999999999997e-64Initial program 70.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6476.5
Applied rewrites76.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6444.4
Applied rewrites44.4%
Taylor expanded in y around 0
Applied rewrites45.2%
Taylor expanded in z around inf
Applied rewrites37.6%
if -3.8999999999999997e-64 < z < 4.1999999999999996e-6Initial program 95.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6442.0
Applied rewrites42.0%
Taylor expanded in z around 0
Applied rewrites28.7%
Applied rewrites30.3%
if 4.1999999999999996e-6 < z Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6437.3
Applied rewrites37.3%
Taylor expanded in y around 0
Applied rewrites56.5%
Taylor expanded in z around inf
Applied rewrites48.3%
Final simplification36.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -3.9e-64) (fma a (/ t z) t) (if (<= z 4.2e-6) (* y (/ t a)) (* t 1.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.9e-64) {
tmp = fma(a, (t / z), t);
} else if (z <= 4.2e-6) {
tmp = y * (t / a);
} else {
tmp = t * 1.0;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.9e-64) tmp = fma(a, Float64(t / z), t); elseif (z <= 4.2e-6) tmp = Float64(y * Float64(t / a)); else tmp = Float64(t * 1.0); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.9e-64], N[(a * N[(t / z), $MachinePrecision] + t), $MachinePrecision], If[LessEqual[z, 4.2e-6], N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision], N[(t * 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.9 \cdot 10^{-64}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{t}{z}, t\right)\\
\mathbf{elif}\;z \leq 4.2 \cdot 10^{-6}:\\
\;\;\;\;y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot 1\\
\end{array}
\end{array}
if z < -3.8999999999999997e-64Initial program 70.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6476.5
Applied rewrites76.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6444.4
Applied rewrites44.4%
Taylor expanded in y around 0
Applied rewrites45.2%
Taylor expanded in z around inf
Applied rewrites37.6%
if -3.8999999999999997e-64 < z < 4.1999999999999996e-6Initial program 95.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6442.0
Applied rewrites42.0%
Taylor expanded in z around 0
Applied rewrites28.7%
Applied rewrites30.3%
if 4.1999999999999996e-6 < z Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6437.3
Applied rewrites37.3%
Taylor expanded in y around 0
Applied rewrites56.5%
Taylor expanded in z around inf
Applied rewrites48.3%
Final simplification36.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -9.5e-54) (* t 1.0) (if (<= z 4.2e-6) (* y (/ t a)) (* t 1.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.5e-54) {
tmp = t * 1.0;
} else if (z <= 4.2e-6) {
tmp = y * (t / a);
} else {
tmp = t * 1.0;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (z <= (-9.5d-54)) then
tmp = t * 1.0d0
else if (z <= 4.2d-6) then
tmp = y * (t / a)
else
tmp = t * 1.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.5e-54) {
tmp = t * 1.0;
} else if (z <= 4.2e-6) {
tmp = y * (t / a);
} else {
tmp = t * 1.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9.5e-54: tmp = t * 1.0 elif z <= 4.2e-6: tmp = y * (t / a) else: tmp = t * 1.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9.5e-54) tmp = Float64(t * 1.0); elseif (z <= 4.2e-6) tmp = Float64(y * Float64(t / a)); else tmp = Float64(t * 1.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -9.5e-54) tmp = t * 1.0; elseif (z <= 4.2e-6) tmp = y * (t / a); else tmp = t * 1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9.5e-54], N[(t * 1.0), $MachinePrecision], If[LessEqual[z, 4.2e-6], N[(y * N[(t / a), $MachinePrecision]), $MachinePrecision], N[(t * 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.5 \cdot 10^{-54}:\\
\;\;\;\;t \cdot 1\\
\mathbf{elif}\;z \leq 4.2 \cdot 10^{-6}:\\
\;\;\;\;y \cdot \frac{t}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot 1\\
\end{array}
\end{array}
if z < -9.4999999999999994e-54 or 4.1999999999999996e-6 < z Initial program 72.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6477.1
Applied rewrites77.1%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6442.2
Applied rewrites42.2%
Taylor expanded in y around 0
Applied rewrites50.3%
Taylor expanded in z around inf
Applied rewrites42.2%
if -9.4999999999999994e-54 < z < 4.1999999999999996e-6Initial program 95.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6441.3
Applied rewrites41.3%
Taylor expanded in z around 0
Applied rewrites28.3%
Applied rewrites29.8%
Final simplification36.6%
(FPCore (x y z t a) :precision binary64 (if (<= z -9.5e-54) (* t 1.0) (if (<= z 4.2e-6) (* t (/ y a)) (* t 1.0))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.5e-54) {
tmp = t * 1.0;
} else if (z <= 4.2e-6) {
tmp = t * (y / a);
} else {
tmp = t * 1.0;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (z <= (-9.5d-54)) then
tmp = t * 1.0d0
else if (z <= 4.2d-6) then
tmp = t * (y / a)
else
tmp = t * 1.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.5e-54) {
tmp = t * 1.0;
} else if (z <= 4.2e-6) {
tmp = t * (y / a);
} else {
tmp = t * 1.0;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9.5e-54: tmp = t * 1.0 elif z <= 4.2e-6: tmp = t * (y / a) else: tmp = t * 1.0 return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9.5e-54) tmp = Float64(t * 1.0); elseif (z <= 4.2e-6) tmp = Float64(t * Float64(y / a)); else tmp = Float64(t * 1.0); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -9.5e-54) tmp = t * 1.0; elseif (z <= 4.2e-6) tmp = t * (y / a); else tmp = t * 1.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9.5e-54], N[(t * 1.0), $MachinePrecision], If[LessEqual[z, 4.2e-6], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], N[(t * 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.5 \cdot 10^{-54}:\\
\;\;\;\;t \cdot 1\\
\mathbf{elif}\;z \leq 4.2 \cdot 10^{-6}:\\
\;\;\;\;t \cdot \frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;t \cdot 1\\
\end{array}
\end{array}
if z < -9.4999999999999994e-54 or 4.1999999999999996e-6 < z Initial program 72.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6477.1
Applied rewrites77.1%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6442.2
Applied rewrites42.2%
Taylor expanded in y around 0
Applied rewrites50.3%
Taylor expanded in z around inf
Applied rewrites42.2%
if -9.4999999999999994e-54 < z < 4.1999999999999996e-6Initial program 95.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6496.5
Applied rewrites96.5%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6441.3
Applied rewrites41.3%
Taylor expanded in z around 0
Applied rewrites28.3%
Applied rewrites29.0%
(FPCore (x y z t a) :precision binary64 (* t 1.0))
double code(double x, double y, double z, double t, double a) {
return t * 1.0;
}
real(8) function code(x, y, z, t, a)
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
code = t * 1.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return t * 1.0;
}
def code(x, y, z, t, a): return t * 1.0
function code(x, y, z, t, a) return Float64(t * 1.0) end
function tmp = code(x, y, z, t, a) tmp = t * 1.0; end
code[x_, y_, z_, t_, a_] := N[(t * 1.0), $MachinePrecision]
\begin{array}{l}
\\
t \cdot 1
\end{array}
Initial program 82.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lift--.f64N/A
flip--N/A
clear-numN/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-fma.f64N/A
lower-/.f6485.9
Applied rewrites85.9%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6441.8
Applied rewrites41.8%
Taylor expanded in y around 0
Applied rewrites31.8%
Taylor expanded in z around inf
Applied rewrites25.2%
herbie shell --seed 2024221
(FPCore (x y z t a)
:name "Numeric.Signal:interpolate from hsignal-0.2.7.1"
:precision binary64
(+ x (* (- y z) (/ (- t x) (- a z)))))