
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
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 - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (/ (* (- y x) (- z t)) (- a t))))
double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
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 - x) * (z - t)) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (((y - x) * (z - t)) / (a - t));
}
def code(x, y, z, t, a): return x + (((y - x) * (z - t)) / (a - t))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(Float64(y - x) * Float64(z - t)) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = x + (((y - x) * (z - t)) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t}
\end{array}
(FPCore (x y z t a)
:precision binary64
(if (or (<= x -3.85e+31) (not (<= x 5.4e-10)))
(*
x
(+
(- 1.0 (/ t (- t a)))
(- (/ z (- t a)) (* y (/ (/ (- z t) x) (- t a))))))
(fma (- y x) (/ (- t z) (- t a)) x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x <= -3.85e+31) || !(x <= 5.4e-10)) {
tmp = x * ((1.0 - (t / (t - a))) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a)))));
} else {
tmp = fma((y - x), ((t - z) / (t - a)), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if ((x <= -3.85e+31) || !(x <= 5.4e-10)) tmp = Float64(x * Float64(Float64(1.0 - Float64(t / Float64(t - a))) + Float64(Float64(z / Float64(t - a)) - Float64(y * Float64(Float64(Float64(z - t) / x) / Float64(t - a)))))); else tmp = fma(Float64(y - x), Float64(Float64(t - z) / Float64(t - a)), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[x, -3.85e+31], N[Not[LessEqual[x, 5.4e-10]], $MachinePrecision]], N[(x * N[(N[(1.0 - N[(t / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision] - N[(y * N[(N[(N[(z - t), $MachinePrecision] / x), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y - x), $MachinePrecision] * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.85 \cdot 10^{+31} \lor \neg \left(x \leq 5.4 \cdot 10^{-10}\right):\\
\;\;\;\;x \cdot \left(\left(1 - \frac{t}{t - a}\right) + \left(\frac{z}{t - a} - y \cdot \frac{\frac{z - t}{x}}{t - a}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y - x, \frac{t - z}{t - a}, x\right)\\
\end{array}
\end{array}
if x < -3.84999999999999984e31 or 5.4e-10 < x Initial program 56.5%
+-commutative56.5%
associate-/l*77.6%
fma-define77.6%
Simplified77.6%
Taylor expanded in x around -inf 75.3%
mul-1-neg75.3%
distribute-rgt-neg-in75.3%
+-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
associate-/r*77.4%
associate-/l*87.7%
*-lft-identity87.7%
times-frac90.7%
/-rgt-identity90.7%
+-commutative90.7%
Simplified90.7%
if -3.84999999999999984e31 < x < 5.4e-10Initial program 81.8%
+-commutative81.8%
associate-/l*93.7%
fma-define93.6%
Simplified93.6%
Final simplification92.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* (- z t) (/ 1.0 (/ (- t a) (- y x))))))
(t_2 (+ x (/ (* (- y x) (- t z)) (- t a)))))
(if (<= t_2 (- INFINITY))
t_1
(if (<= t_2 -5e-259)
t_2
(if (<= t_2 0.0)
(- y (/ (* (- y x) (- z a)) t))
(if (<= t_2 1e+305) t_2 t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((z - t) * (1.0 / ((t - a) / (y - x))));
double t_2 = x + (((y - x) * (t - z)) / (t - a));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_1;
} else if (t_2 <= -5e-259) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - (((y - x) * (z - a)) / t);
} else if (t_2 <= 1e+305) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((z - t) * (1.0 / ((t - a) / (y - x))));
double t_2 = x + (((y - x) * (t - z)) / (t - a));
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = t_1;
} else if (t_2 <= -5e-259) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - (((y - x) * (z - a)) / t);
} else if (t_2 <= 1e+305) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - ((z - t) * (1.0 / ((t - a) / (y - x)))) t_2 = x + (((y - x) * (t - z)) / (t - a)) tmp = 0 if t_2 <= -math.inf: tmp = t_1 elif t_2 <= -5e-259: tmp = t_2 elif t_2 <= 0.0: tmp = y - (((y - x) * (z - a)) / t) elif t_2 <= 1e+305: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(z - t) * Float64(1.0 / Float64(Float64(t - a) / Float64(y - x))))) t_2 = Float64(x + Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(t - a))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_1; elseif (t_2 <= -5e-259) tmp = t_2; elseif (t_2 <= 0.0) tmp = Float64(y - Float64(Float64(Float64(y - x) * Float64(z - a)) / t)); elseif (t_2 <= 1e+305) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - ((z - t) * (1.0 / ((t - a) / (y - x)))); t_2 = x + (((y - x) * (t - z)) / (t - a)); tmp = 0.0; if (t_2 <= -Inf) tmp = t_1; elseif (t_2 <= -5e-259) tmp = t_2; elseif (t_2 <= 0.0) tmp = y - (((y - x) * (z - a)) / t); elseif (t_2 <= 1e+305) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(z - t), $MachinePrecision] * N[(1.0 / N[(N[(t - a), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$1, If[LessEqual[t$95$2, -5e-259], t$95$2, If[LessEqual[t$95$2, 0.0], N[(y - N[(N[(N[(y - x), $MachinePrecision] * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+305], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \left(z - t\right) \cdot \frac{1}{\frac{t - a}{y - x}}\\
t_2 := x + \frac{\left(y - x\right) \cdot \left(t - z\right)}{t - a}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{-259}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;y - \frac{\left(y - x\right) \cdot \left(z - a\right)}{t}\\
\mathbf{elif}\;t\_2 \leq 10^{+305}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0 or 9.9999999999999994e304 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 40.8%
+-commutative40.8%
associate-/l*86.0%
fma-define86.0%
Simplified86.0%
fma-undefine86.0%
associate-/l*40.8%
*-commutative40.8%
associate-/l*86.1%
Applied egg-rr86.1%
clear-num86.2%
inv-pow86.2%
Applied egg-rr86.2%
unpow-186.2%
Simplified86.2%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -4.99999999999999977e-259 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 9.9999999999999994e304Initial program 95.1%
if -4.99999999999999977e-259 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 3.3%
+-commutative3.3%
associate-/l*3.3%
fma-define3.3%
Simplified3.3%
Taylor expanded in t around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
associate-*r/99.7%
mul-1-neg99.7%
div-sub99.7%
mul-1-neg99.7%
distribute-lft-out--99.7%
associate-*r/99.7%
mul-1-neg99.7%
unsub-neg99.7%
distribute-rgt-out--99.7%
Simplified99.7%
Final simplification91.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (* (- z t) (/ (- y x) (- t a)))))
(t_2 (+ x (/ (* (- y x) (- t z)) (- t a)))))
(if (<= t_2 (- INFINITY))
t_1
(if (<= t_2 -5e-259)
t_2
(if (<= t_2 0.0)
(- y (/ (* (- y x) (- z a)) t))
(if (<= t_2 1e+305) t_2 t_1))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((z - t) * ((y - x) / (t - a)));
double t_2 = x + (((y - x) * (t - z)) / (t - a));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_1;
} else if (t_2 <= -5e-259) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - (((y - x) * (z - a)) / t);
} else if (t_2 <= 1e+305) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((z - t) * ((y - x) / (t - a)));
double t_2 = x + (((y - x) * (t - z)) / (t - a));
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = t_1;
} else if (t_2 <= -5e-259) {
tmp = t_2;
} else if (t_2 <= 0.0) {
tmp = y - (((y - x) * (z - a)) / t);
} else if (t_2 <= 1e+305) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - ((z - t) * ((y - x) / (t - a))) t_2 = x + (((y - x) * (t - z)) / (t - a)) tmp = 0 if t_2 <= -math.inf: tmp = t_1 elif t_2 <= -5e-259: tmp = t_2 elif t_2 <= 0.0: tmp = y - (((y - x) * (z - a)) / t) elif t_2 <= 1e+305: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(z - t) * Float64(Float64(y - x) / Float64(t - a)))) t_2 = Float64(x + Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(t - a))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_1; elseif (t_2 <= -5e-259) tmp = t_2; elseif (t_2 <= 0.0) tmp = Float64(y - Float64(Float64(Float64(y - x) * Float64(z - a)) / t)); elseif (t_2 <= 1e+305) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - ((z - t) * ((y - x) / (t - a))); t_2 = x + (((y - x) * (t - z)) / (t - a)); tmp = 0.0; if (t_2 <= -Inf) tmp = t_1; elseif (t_2 <= -5e-259) tmp = t_2; elseif (t_2 <= 0.0) tmp = y - (((y - x) * (z - a)) / t); elseif (t_2 <= 1e+305) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$1, If[LessEqual[t$95$2, -5e-259], t$95$2, If[LessEqual[t$95$2, 0.0], N[(y - N[(N[(N[(y - x), $MachinePrecision] * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+305], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \left(z - t\right) \cdot \frac{y - x}{t - a}\\
t_2 := x + \frac{\left(y - x\right) \cdot \left(t - z\right)}{t - a}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{-259}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;y - \frac{\left(y - x\right) \cdot \left(z - a\right)}{t}\\
\mathbf{elif}\;t\_2 \leq 10^{+305}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -inf.0 or 9.9999999999999994e304 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) Initial program 40.8%
+-commutative40.8%
associate-/l*86.0%
fma-define86.0%
Simplified86.0%
fma-undefine86.0%
associate-/l*40.8%
*-commutative40.8%
associate-/l*86.1%
Applied egg-rr86.1%
if -inf.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -4.99999999999999977e-259 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 9.9999999999999994e304Initial program 95.1%
if -4.99999999999999977e-259 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0Initial program 3.3%
+-commutative3.3%
associate-/l*3.3%
fma-define3.3%
Simplified3.3%
Taylor expanded in t around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
associate-*r/99.7%
mul-1-neg99.7%
div-sub99.7%
mul-1-neg99.7%
distribute-lft-out--99.7%
associate-*r/99.7%
mul-1-neg99.7%
unsub-neg99.7%
distribute-rgt-out--99.7%
Simplified99.7%
Final simplification91.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ t (- t a)))
(t_2
(*
x
(+ (- 1.0 t_1) (- (/ z (- t a)) (* y (/ (/ (- z t) x) (- t a))))))))
(if (<= x -1.1e+24)
t_2
(if (<= x -1.2e-120)
(- x (* (- z t) (/ (- y x) (- t a))))
(if (<= x 5.8e-59) (* y (+ (+ (/ z (- a t)) (/ x y)) t_1)) t_2)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t / (t - a);
double t_2 = x * ((1.0 - t_1) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a)))));
double tmp;
if (x <= -1.1e+24) {
tmp = t_2;
} else if (x <= -1.2e-120) {
tmp = x - ((z - t) * ((y - x) / (t - a)));
} else if (x <= 5.8e-59) {
tmp = y * (((z / (a - t)) + (x / y)) + t_1);
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = t / (t - a)
t_2 = x * ((1.0d0 - t_1) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a)))))
if (x <= (-1.1d+24)) then
tmp = t_2
else if (x <= (-1.2d-120)) then
tmp = x - ((z - t) * ((y - x) / (t - a)))
else if (x <= 5.8d-59) then
tmp = y * (((z / (a - t)) + (x / y)) + t_1)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t / (t - a);
double t_2 = x * ((1.0 - t_1) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a)))));
double tmp;
if (x <= -1.1e+24) {
tmp = t_2;
} else if (x <= -1.2e-120) {
tmp = x - ((z - t) * ((y - x) / (t - a)));
} else if (x <= 5.8e-59) {
tmp = y * (((z / (a - t)) + (x / y)) + t_1);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t / (t - a) t_2 = x * ((1.0 - t_1) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a))))) tmp = 0 if x <= -1.1e+24: tmp = t_2 elif x <= -1.2e-120: tmp = x - ((z - t) * ((y - x) / (t - a))) elif x <= 5.8e-59: tmp = y * (((z / (a - t)) + (x / y)) + t_1) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t / Float64(t - a)) t_2 = Float64(x * Float64(Float64(1.0 - t_1) + Float64(Float64(z / Float64(t - a)) - Float64(y * Float64(Float64(Float64(z - t) / x) / Float64(t - a)))))) tmp = 0.0 if (x <= -1.1e+24) tmp = t_2; elseif (x <= -1.2e-120) tmp = Float64(x - Float64(Float64(z - t) * Float64(Float64(y - x) / Float64(t - a)))); elseif (x <= 5.8e-59) tmp = Float64(y * Float64(Float64(Float64(z / Float64(a - t)) + Float64(x / y)) + t_1)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t / (t - a); t_2 = x * ((1.0 - t_1) + ((z / (t - a)) - (y * (((z - t) / x) / (t - a))))); tmp = 0.0; if (x <= -1.1e+24) tmp = t_2; elseif (x <= -1.2e-120) tmp = x - ((z - t) * ((y - x) / (t - a))); elseif (x <= 5.8e-59) tmp = y * (((z / (a - t)) + (x / y)) + t_1); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t / N[(t - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(1.0 - t$95$1), $MachinePrecision] + N[(N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision] - N[(y * N[(N[(N[(z - t), $MachinePrecision] / x), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.1e+24], t$95$2, If[LessEqual[x, -1.2e-120], N[(x - N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 5.8e-59], N[(y * N[(N[(N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision] + N[(x / y), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{t - a}\\
t_2 := x \cdot \left(\left(1 - t\_1\right) + \left(\frac{z}{t - a} - y \cdot \frac{\frac{z - t}{x}}{t - a}\right)\right)\\
\mathbf{if}\;x \leq -1.1 \cdot 10^{+24}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.2 \cdot 10^{-120}:\\
\;\;\;\;x - \left(z - t\right) \cdot \frac{y - x}{t - a}\\
\mathbf{elif}\;x \leq 5.8 \cdot 10^{-59}:\\
\;\;\;\;y \cdot \left(\left(\frac{z}{a - t} + \frac{x}{y}\right) + t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.10000000000000001e24 or 5.80000000000000033e-59 < x Initial program 58.8%
+-commutative58.8%
associate-/l*78.8%
fma-define78.8%
Simplified78.8%
Taylor expanded in x around -inf 76.5%
mul-1-neg76.5%
distribute-rgt-neg-in76.5%
+-commutative76.5%
mul-1-neg76.5%
unsub-neg76.5%
associate-/r*78.5%
associate-/l*88.4%
*-lft-identity88.4%
times-frac91.2%
/-rgt-identity91.2%
+-commutative91.2%
Simplified91.2%
if -1.10000000000000001e24 < x < -1.2e-120Initial program 79.7%
+-commutative79.7%
associate-/l*94.6%
fma-define94.6%
Simplified94.6%
fma-undefine94.6%
associate-/l*79.7%
*-commutative79.7%
associate-/l*94.6%
Applied egg-rr94.6%
if -1.2e-120 < x < 5.80000000000000033e-59Initial program 81.2%
Taylor expanded in y around inf 77.8%
*-commutative77.8%
*-lft-identity77.8%
times-frac80.6%
/-rgt-identity80.6%
Simplified80.6%
Taylor expanded in y around inf 90.1%
Final simplification91.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (/ z (- a t)) y)))
(if (<= t -5.2e+70)
y
(if (<= t -1.96e-10)
t_1
(if (<= t 1.5e-69) x (if (<= t 4.4e+54) t_1 y))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z / (a - t)) * y;
double tmp;
if (t <= -5.2e+70) {
tmp = y;
} else if (t <= -1.96e-10) {
tmp = t_1;
} else if (t <= 1.5e-69) {
tmp = x;
} else if (t <= 4.4e+54) {
tmp = t_1;
} else {
tmp = y;
}
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 = (z / (a - t)) * y
if (t <= (-5.2d+70)) then
tmp = y
else if (t <= (-1.96d-10)) then
tmp = t_1
else if (t <= 1.5d-69) then
tmp = x
else if (t <= 4.4d+54) then
tmp = t_1
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z / (a - t)) * y;
double tmp;
if (t <= -5.2e+70) {
tmp = y;
} else if (t <= -1.96e-10) {
tmp = t_1;
} else if (t <= 1.5e-69) {
tmp = x;
} else if (t <= 4.4e+54) {
tmp = t_1;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z / (a - t)) * y tmp = 0 if t <= -5.2e+70: tmp = y elif t <= -1.96e-10: tmp = t_1 elif t <= 1.5e-69: tmp = x elif t <= 4.4e+54: tmp = t_1 else: tmp = y return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z / Float64(a - t)) * y) tmp = 0.0 if (t <= -5.2e+70) tmp = y; elseif (t <= -1.96e-10) tmp = t_1; elseif (t <= 1.5e-69) tmp = x; elseif (t <= 4.4e+54) tmp = t_1; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z / (a - t)) * y; tmp = 0.0; if (t <= -5.2e+70) tmp = y; elseif (t <= -1.96e-10) tmp = t_1; elseif (t <= 1.5e-69) tmp = x; elseif (t <= 4.4e+54) tmp = t_1; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[t, -5.2e+70], y, If[LessEqual[t, -1.96e-10], t$95$1, If[LessEqual[t, 1.5e-69], x, If[LessEqual[t, 4.4e+54], t$95$1, y]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z}{a - t} \cdot y\\
\mathbf{if}\;t \leq -5.2 \cdot 10^{+70}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -1.96 \cdot 10^{-10}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{-69}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{+54}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.2000000000000001e70 or 4.3999999999999998e54 < t Initial program 40.1%
+-commutative40.1%
associate-/l*75.8%
fma-define75.8%
Simplified75.8%
Taylor expanded in y around 0 60.3%
+-commutative60.3%
+-commutative60.3%
div-sub60.4%
mul-1-neg60.4%
associate-/l*75.8%
distribute-lft-neg-in75.8%
distribute-rgt-in75.8%
sub-neg75.8%
associate-*l/40.1%
associate-*r/67.0%
fma-define67.1%
Simplified67.1%
Taylor expanded in t around inf 54.1%
if -5.2000000000000001e70 < t < -1.96e-10 or 1.49999999999999995e-69 < t < 4.3999999999999998e54Initial program 77.0%
Taylor expanded in y around inf 63.1%
*-commutative63.1%
*-lft-identity63.1%
times-frac65.2%
/-rgt-identity65.2%
Simplified65.2%
Taylor expanded in y around inf 64.9%
Taylor expanded in z around inf 36.1%
associate-*r/38.0%
*-commutative38.0%
Simplified38.0%
if -1.96e-10 < t < 1.49999999999999995e-69Initial program 93.4%
+-commutative93.4%
associate-/l*95.6%
fma-define95.6%
Simplified95.6%
Taylor expanded in a around inf 46.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t z) (- t a)))))
(if (<= t -1.7e-40)
t_1
(if (<= t 4.2e-91)
(+ x (* z (/ (- y x) a)))
(if (<= t 1.05e+66) (* z (/ (- x y) (- t a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - z) / (t - a));
double tmp;
if (t <= -1.7e-40) {
tmp = t_1;
} else if (t <= 4.2e-91) {
tmp = x + (z * ((y - x) / a));
} else if (t <= 1.05e+66) {
tmp = z * ((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 = y * ((t - z) / (t - a))
if (t <= (-1.7d-40)) then
tmp = t_1
else if (t <= 4.2d-91) then
tmp = x + (z * ((y - x) / a))
else if (t <= 1.05d+66) then
tmp = z * ((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 = y * ((t - z) / (t - a));
double tmp;
if (t <= -1.7e-40) {
tmp = t_1;
} else if (t <= 4.2e-91) {
tmp = x + (z * ((y - x) / a));
} else if (t <= 1.05e+66) {
tmp = z * ((x - y) / (t - a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - z) / (t - a)) tmp = 0 if t <= -1.7e-40: tmp = t_1 elif t <= 4.2e-91: tmp = x + (z * ((y - x) / a)) elif t <= 1.05e+66: tmp = z * ((x - y) / (t - a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - z) / Float64(t - a))) tmp = 0.0 if (t <= -1.7e-40) tmp = t_1; elseif (t <= 4.2e-91) tmp = Float64(x + Float64(z * Float64(Float64(y - x) / a))); elseif (t <= 1.05e+66) tmp = Float64(z * Float64(Float64(x - y) / Float64(t - a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - z) / (t - a)); tmp = 0.0; if (t <= -1.7e-40) tmp = t_1; elseif (t <= 4.2e-91) tmp = x + (z * ((y - x) / a)); elseif (t <= 1.05e+66) tmp = z * ((x - y) / (t - a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.7e-40], t$95$1, If[LessEqual[t, 4.2e-91], N[(x + N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.05e+66], N[(z * N[(N[(x - y), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - z}{t - a}\\
\mathbf{if}\;t \leq -1.7 \cdot 10^{-40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4.2 \cdot 10^{-91}:\\
\;\;\;\;x + z \cdot \frac{y - x}{a}\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{+66}:\\
\;\;\;\;z \cdot \frac{x - y}{t - a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.69999999999999992e-40 or 1.05000000000000003e66 < t Initial program 46.9%
+-commutative46.9%
associate-/l*77.7%
fma-define77.7%
Simplified77.7%
Taylor expanded in y around 0 62.7%
+-commutative62.7%
+-commutative62.7%
div-sub62.7%
mul-1-neg62.7%
associate-/l*77.7%
distribute-lft-neg-in77.7%
distribute-rgt-in77.7%
sub-neg77.7%
associate-*l/46.9%
associate-*r/70.5%
fma-define70.7%
Simplified70.7%
Taylor expanded in y around inf 65.6%
div-sub65.6%
Simplified65.6%
if -1.69999999999999992e-40 < t < 4.1999999999999998e-91Initial program 93.0%
Taylor expanded in t around 0 75.3%
associate-/l*78.2%
Simplified78.2%
if 4.1999999999999998e-91 < t < 1.05000000000000003e66Initial program 79.7%
+-commutative79.7%
associate-/l*85.6%
fma-define85.6%
Simplified85.6%
Taylor expanded in y around 0 79.8%
+-commutative79.8%
+-commutative79.8%
div-sub79.8%
mul-1-neg79.8%
associate-/l*79.8%
distribute-lft-neg-in79.8%
distribute-rgt-in85.6%
sub-neg85.6%
associate-*l/79.7%
associate-*r/79.9%
fma-define80.1%
Simplified80.1%
Taylor expanded in z around inf 64.1%
div-sub64.1%
Simplified64.1%
Final simplification70.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t z) (- t a)))))
(if (<= t -3.05e-40)
t_1
(if (<= t 4.6e-91)
(+ x (* y (/ (- z t) a)))
(if (<= t 9e+59) (* z (/ (- x y) (- t a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - z) / (t - a));
double tmp;
if (t <= -3.05e-40) {
tmp = t_1;
} else if (t <= 4.6e-91) {
tmp = x + (y * ((z - t) / a));
} else if (t <= 9e+59) {
tmp = z * ((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 = y * ((t - z) / (t - a))
if (t <= (-3.05d-40)) then
tmp = t_1
else if (t <= 4.6d-91) then
tmp = x + (y * ((z - t) / a))
else if (t <= 9d+59) then
tmp = z * ((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 = y * ((t - z) / (t - a));
double tmp;
if (t <= -3.05e-40) {
tmp = t_1;
} else if (t <= 4.6e-91) {
tmp = x + (y * ((z - t) / a));
} else if (t <= 9e+59) {
tmp = z * ((x - y) / (t - a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - z) / (t - a)) tmp = 0 if t <= -3.05e-40: tmp = t_1 elif t <= 4.6e-91: tmp = x + (y * ((z - t) / a)) elif t <= 9e+59: tmp = z * ((x - y) / (t - a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - z) / Float64(t - a))) tmp = 0.0 if (t <= -3.05e-40) tmp = t_1; elseif (t <= 4.6e-91) tmp = Float64(x + Float64(y * Float64(Float64(z - t) / a))); elseif (t <= 9e+59) tmp = Float64(z * Float64(Float64(x - y) / Float64(t - a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - z) / (t - a)); tmp = 0.0; if (t <= -3.05e-40) tmp = t_1; elseif (t <= 4.6e-91) tmp = x + (y * ((z - t) / a)); elseif (t <= 9e+59) tmp = z * ((x - y) / (t - a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.05e-40], t$95$1, If[LessEqual[t, 4.6e-91], N[(x + N[(y * N[(N[(z - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9e+59], N[(z * N[(N[(x - y), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - z}{t - a}\\
\mathbf{if}\;t \leq -3.05 \cdot 10^{-40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4.6 \cdot 10^{-91}:\\
\;\;\;\;x + y \cdot \frac{z - t}{a}\\
\mathbf{elif}\;t \leq 9 \cdot 10^{+59}:\\
\;\;\;\;z \cdot \frac{x - y}{t - a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.0500000000000002e-40 or 8.99999999999999919e59 < t Initial program 46.9%
+-commutative46.9%
associate-/l*77.7%
fma-define77.7%
Simplified77.7%
Taylor expanded in y around 0 62.7%
+-commutative62.7%
+-commutative62.7%
div-sub62.7%
mul-1-neg62.7%
associate-/l*77.7%
distribute-lft-neg-in77.7%
distribute-rgt-in77.7%
sub-neg77.7%
associate-*l/46.9%
associate-*r/70.5%
fma-define70.7%
Simplified70.7%
Taylor expanded in y around inf 65.6%
div-sub65.6%
Simplified65.6%
if -3.0500000000000002e-40 < t < 4.59999999999999991e-91Initial program 93.0%
Taylor expanded in y around inf 79.6%
*-commutative79.6%
*-lft-identity79.6%
times-frac77.8%
/-rgt-identity77.8%
Simplified77.8%
Taylor expanded in a around inf 70.8%
associate-/l*72.0%
Simplified72.0%
if 4.59999999999999991e-91 < t < 8.99999999999999919e59Initial program 79.7%
+-commutative79.7%
associate-/l*85.6%
fma-define85.6%
Simplified85.6%
Taylor expanded in y around 0 79.8%
+-commutative79.8%
+-commutative79.8%
div-sub79.8%
mul-1-neg79.8%
associate-/l*79.8%
distribute-lft-neg-in79.8%
distribute-rgt-in85.6%
sub-neg85.6%
associate-*l/79.7%
associate-*r/79.9%
fma-define80.1%
Simplified80.1%
Taylor expanded in z around inf 64.1%
div-sub64.1%
Simplified64.1%
Final simplification67.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t z) (- t a)))))
(if (<= t -6.5e-40)
t_1
(if (<= t 1.2e-91)
(+ x (/ (* z y) a))
(if (<= t 1.35e+58) (* z (/ (- x y) (- t a))) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - z) / (t - a));
double tmp;
if (t <= -6.5e-40) {
tmp = t_1;
} else if (t <= 1.2e-91) {
tmp = x + ((z * y) / a);
} else if (t <= 1.35e+58) {
tmp = z * ((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 = y * ((t - z) / (t - a))
if (t <= (-6.5d-40)) then
tmp = t_1
else if (t <= 1.2d-91) then
tmp = x + ((z * y) / a)
else if (t <= 1.35d+58) then
tmp = z * ((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 = y * ((t - z) / (t - a));
double tmp;
if (t <= -6.5e-40) {
tmp = t_1;
} else if (t <= 1.2e-91) {
tmp = x + ((z * y) / a);
} else if (t <= 1.35e+58) {
tmp = z * ((x - y) / (t - a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - z) / (t - a)) tmp = 0 if t <= -6.5e-40: tmp = t_1 elif t <= 1.2e-91: tmp = x + ((z * y) / a) elif t <= 1.35e+58: tmp = z * ((x - y) / (t - a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - z) / Float64(t - a))) tmp = 0.0 if (t <= -6.5e-40) tmp = t_1; elseif (t <= 1.2e-91) tmp = Float64(x + Float64(Float64(z * y) / a)); elseif (t <= 1.35e+58) tmp = Float64(z * Float64(Float64(x - y) / Float64(t - a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - z) / (t - a)); tmp = 0.0; if (t <= -6.5e-40) tmp = t_1; elseif (t <= 1.2e-91) tmp = x + ((z * y) / a); elseif (t <= 1.35e+58) tmp = z * ((x - y) / (t - a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.5e-40], t$95$1, If[LessEqual[t, 1.2e-91], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.35e+58], N[(z * N[(N[(x - y), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - z}{t - a}\\
\mathbf{if}\;t \leq -6.5 \cdot 10^{-40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{-91}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{+58}:\\
\;\;\;\;z \cdot \frac{x - y}{t - a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -6.4999999999999999e-40 or 1.3500000000000001e58 < t Initial program 46.9%
+-commutative46.9%
associate-/l*77.7%
fma-define77.7%
Simplified77.7%
Taylor expanded in y around 0 62.7%
+-commutative62.7%
+-commutative62.7%
div-sub62.7%
mul-1-neg62.7%
associate-/l*77.7%
distribute-lft-neg-in77.7%
distribute-rgt-in77.7%
sub-neg77.7%
associate-*l/46.9%
associate-*r/70.5%
fma-define70.7%
Simplified70.7%
Taylor expanded in y around inf 65.6%
div-sub65.6%
Simplified65.6%
if -6.4999999999999999e-40 < t < 1.20000000000000005e-91Initial program 93.0%
Taylor expanded in y around inf 79.6%
*-commutative79.6%
*-lft-identity79.6%
times-frac77.8%
/-rgt-identity77.8%
Simplified77.8%
Taylor expanded in t around 0 68.8%
if 1.20000000000000005e-91 < t < 1.3500000000000001e58Initial program 79.7%
+-commutative79.7%
associate-/l*85.6%
fma-define85.6%
Simplified85.6%
Taylor expanded in y around 0 79.8%
+-commutative79.8%
+-commutative79.8%
div-sub79.8%
mul-1-neg79.8%
associate-/l*79.8%
distribute-lft-neg-in79.8%
distribute-rgt-in85.6%
sub-neg85.6%
associate-*l/79.7%
associate-*r/79.9%
fma-define80.1%
Simplified80.1%
Taylor expanded in z around inf 64.1%
div-sub64.1%
Simplified64.1%
Final simplification66.7%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.65e+75)
(* y (/ (- t z) (- t a)))
(if (<= t 2.1e+35)
(+ x (/ (* (- y x) (- t z)) (- t a)))
(- y (* z (/ (- y x) t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.65e+75) {
tmp = y * ((t - z) / (t - a));
} else if (t <= 2.1e+35) {
tmp = x + (((y - x) * (t - z)) / (t - a));
} else {
tmp = y - (z * ((y - x) / t));
}
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 (t <= (-1.65d+75)) then
tmp = y * ((t - z) / (t - a))
else if (t <= 2.1d+35) then
tmp = x + (((y - x) * (t - z)) / (t - a))
else
tmp = y - (z * ((y - x) / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.65e+75) {
tmp = y * ((t - z) / (t - a));
} else if (t <= 2.1e+35) {
tmp = x + (((y - x) * (t - z)) / (t - a));
} else {
tmp = y - (z * ((y - x) / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.65e+75: tmp = y * ((t - z) / (t - a)) elif t <= 2.1e+35: tmp = x + (((y - x) * (t - z)) / (t - a)) else: tmp = y - (z * ((y - x) / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.65e+75) tmp = Float64(y * Float64(Float64(t - z) / Float64(t - a))); elseif (t <= 2.1e+35) tmp = Float64(x + Float64(Float64(Float64(y - x) * Float64(t - z)) / Float64(t - a))); else tmp = Float64(y - Float64(z * Float64(Float64(y - x) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.65e+75) tmp = y * ((t - z) / (t - a)); elseif (t <= 2.1e+35) tmp = x + (((y - x) * (t - z)) / (t - a)); else tmp = y - (z * ((y - x) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.65e+75], N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.1e+35], N[(x + N[(N[(N[(y - x), $MachinePrecision] * N[(t - z), $MachinePrecision]), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y - N[(z * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.65 \cdot 10^{+75}:\\
\;\;\;\;y \cdot \frac{t - z}{t - a}\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{+35}:\\
\;\;\;\;x + \frac{\left(y - x\right) \cdot \left(t - z\right)}{t - a}\\
\mathbf{else}:\\
\;\;\;\;y - z \cdot \frac{y - x}{t}\\
\end{array}
\end{array}
if t < -1.64999999999999999e75Initial program 33.9%
+-commutative33.9%
associate-/l*79.6%
fma-define79.6%
Simplified79.6%
Taylor expanded in y around 0 57.0%
+-commutative57.0%
+-commutative57.0%
div-sub57.0%
mul-1-neg57.0%
associate-/l*79.6%
distribute-lft-neg-in79.6%
distribute-rgt-in79.6%
sub-neg79.6%
associate-*l/33.9%
associate-*r/67.4%
fma-define67.7%
Simplified67.7%
Taylor expanded in y around inf 75.8%
div-sub75.8%
Simplified75.8%
if -1.64999999999999999e75 < t < 2.0999999999999999e35Initial program 90.2%
if 2.0999999999999999e35 < t Initial program 45.4%
+-commutative45.4%
associate-/l*69.4%
fma-define69.4%
Simplified69.4%
Taylor expanded in z around inf 41.7%
+-commutative41.7%
mul-1-neg41.7%
unsub-neg41.7%
+-commutative41.7%
associate-/r*38.7%
associate-/l*51.0%
*-lft-identity51.0%
times-frac57.0%
/-rgt-identity57.0%
Simplified57.0%
Taylor expanded in t around -inf 43.4%
fma-define43.4%
associate-/l*43.3%
associate-/l*51.5%
mul-1-neg51.5%
Simplified51.5%
Taylor expanded in a around 0 63.6%
mul-1-neg63.6%
unsub-neg63.6%
associate-/l*71.5%
Simplified71.5%
Final simplification83.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t z) t))))
(if (<= t -1.4e-21)
t_1
(if (<= t 2.7e-8)
(+ x (/ (* z y) a))
(if (<= t 1.46e+53) (* z (/ (- x y) t)) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - z) / t);
double tmp;
if (t <= -1.4e-21) {
tmp = t_1;
} else if (t <= 2.7e-8) {
tmp = x + ((z * y) / a);
} else if (t <= 1.46e+53) {
tmp = z * ((x - y) / t);
} 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 = y * ((t - z) / t)
if (t <= (-1.4d-21)) then
tmp = t_1
else if (t <= 2.7d-8) then
tmp = x + ((z * y) / a)
else if (t <= 1.46d+53) then
tmp = z * ((x - y) / t)
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 = y * ((t - z) / t);
double tmp;
if (t <= -1.4e-21) {
tmp = t_1;
} else if (t <= 2.7e-8) {
tmp = x + ((z * y) / a);
} else if (t <= 1.46e+53) {
tmp = z * ((x - y) / t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((t - z) / t) tmp = 0 if t <= -1.4e-21: tmp = t_1 elif t <= 2.7e-8: tmp = x + ((z * y) / a) elif t <= 1.46e+53: tmp = z * ((x - y) / t) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - z) / t)) tmp = 0.0 if (t <= -1.4e-21) tmp = t_1; elseif (t <= 2.7e-8) tmp = Float64(x + Float64(Float64(z * y) / a)); elseif (t <= 1.46e+53) tmp = Float64(z * Float64(Float64(x - y) / t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((t - z) / t); tmp = 0.0; if (t <= -1.4e-21) tmp = t_1; elseif (t <= 2.7e-8) tmp = x + ((z * y) / a); elseif (t <= 1.46e+53) tmp = z * ((x - y) / t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.4e-21], t$95$1, If[LessEqual[t, 2.7e-8], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.46e+53], N[(z * N[(N[(x - y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - z}{t}\\
\mathbf{if}\;t \leq -1.4 \cdot 10^{-21}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.7 \cdot 10^{-8}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\mathbf{elif}\;t \leq 1.46 \cdot 10^{+53}:\\
\;\;\;\;z \cdot \frac{x - y}{t}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.40000000000000002e-21 or 1.45999999999999999e53 < t Initial program 46.9%
+-commutative46.9%
associate-/l*77.7%
fma-define77.7%
Simplified77.7%
Taylor expanded in y around 0 62.7%
+-commutative62.7%
+-commutative62.7%
div-sub62.7%
mul-1-neg62.7%
associate-/l*77.7%
distribute-lft-neg-in77.7%
distribute-rgt-in77.7%
sub-neg77.7%
associate-*l/46.9%
associate-*r/70.5%
fma-define70.7%
Simplified70.7%
Taylor expanded in y around -inf 40.6%
Taylor expanded in a around 0 35.6%
mul-1-neg35.6%
associate-/l*58.2%
distribute-lft-neg-in58.2%
Simplified58.2%
if -1.40000000000000002e-21 < t < 2.70000000000000002e-8Initial program 93.4%
Taylor expanded in y around inf 79.8%
*-commutative79.8%
*-lft-identity79.8%
times-frac77.6%
/-rgt-identity77.6%
Simplified77.6%
Taylor expanded in t around 0 66.1%
if 2.70000000000000002e-8 < t < 1.45999999999999999e53Initial program 57.8%
+-commutative57.8%
associate-/l*72.1%
fma-define72.1%
Simplified72.1%
Taylor expanded in z around inf 85.4%
+-commutative85.4%
mul-1-neg85.4%
unsub-neg85.4%
+-commutative85.4%
associate-/r*72.1%
associate-/l*78.3%
*-lft-identity78.3%
times-frac85.4%
/-rgt-identity85.4%
Simplified85.4%
Taylor expanded in t around -inf 71.5%
fma-define71.5%
associate-/l*71.5%
associate-/l*71.5%
mul-1-neg71.5%
Simplified71.5%
Taylor expanded in z around inf 76.2%
mul-1-neg76.2%
associate-/l*76.1%
*-commutative76.1%
distribute-lft-neg-in76.1%
mul-1-neg76.1%
associate-*r/76.1%
neg-mul-176.1%
Simplified76.1%
Final simplification62.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.06e+71)
y
(if (<= t -480.0)
(* (/ z (- a t)) y)
(if (<= t 4.4e+68) (+ x (/ (* z y) a)) (+ y (* a (/ y t)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.06e+71) {
tmp = y;
} else if (t <= -480.0) {
tmp = (z / (a - t)) * y;
} else if (t <= 4.4e+68) {
tmp = x + ((z * y) / a);
} else {
tmp = y + (a * (y / t));
}
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 (t <= (-1.06d+71)) then
tmp = y
else if (t <= (-480.0d0)) then
tmp = (z / (a - t)) * y
else if (t <= 4.4d+68) then
tmp = x + ((z * y) / a)
else
tmp = y + (a * (y / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.06e+71) {
tmp = y;
} else if (t <= -480.0) {
tmp = (z / (a - t)) * y;
} else if (t <= 4.4e+68) {
tmp = x + ((z * y) / a);
} else {
tmp = y + (a * (y / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.06e+71: tmp = y elif t <= -480.0: tmp = (z / (a - t)) * y elif t <= 4.4e+68: tmp = x + ((z * y) / a) else: tmp = y + (a * (y / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.06e+71) tmp = y; elseif (t <= -480.0) tmp = Float64(Float64(z / Float64(a - t)) * y); elseif (t <= 4.4e+68) tmp = Float64(x + Float64(Float64(z * y) / a)); else tmp = Float64(y + Float64(a * Float64(y / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.06e+71) tmp = y; elseif (t <= -480.0) tmp = (z / (a - t)) * y; elseif (t <= 4.4e+68) tmp = x + ((z * y) / a); else tmp = y + (a * (y / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.06e+71], y, If[LessEqual[t, -480.0], N[(N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, 4.4e+68], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(y + N[(a * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.06 \cdot 10^{+71}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -480:\\
\;\;\;\;\frac{z}{a - t} \cdot y\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{+68}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\mathbf{else}:\\
\;\;\;\;y + a \cdot \frac{y}{t}\\
\end{array}
\end{array}
if t < -1.06e71Initial program 35.2%
+-commutative35.2%
associate-/l*80.0%
fma-define80.0%
Simplified80.0%
Taylor expanded in y around 0 57.8%
+-commutative57.8%
+-commutative57.8%
div-sub57.8%
mul-1-neg57.8%
associate-/l*80.0%
distribute-lft-neg-in80.0%
distribute-rgt-in80.0%
sub-neg80.0%
associate-*l/35.2%
associate-*r/67.9%
fma-define68.3%
Simplified68.3%
Taylor expanded in t around inf 62.7%
if -1.06e71 < t < -480Initial program 78.7%
Taylor expanded in y around inf 59.5%
*-commutative59.5%
*-lft-identity59.5%
times-frac64.6%
/-rgt-identity64.6%
Simplified64.6%
Taylor expanded in y around inf 64.5%
Taylor expanded in z around inf 34.9%
associate-*r/40.1%
*-commutative40.1%
Simplified40.1%
if -480 < t < 4.39999999999999974e68Initial program 89.3%
Taylor expanded in y around inf 75.7%
*-commutative75.7%
*-lft-identity75.7%
times-frac74.5%
/-rgt-identity74.5%
Simplified74.5%
Taylor expanded in t around 0 61.1%
if 4.39999999999999974e68 < t Initial program 44.4%
+-commutative44.4%
associate-/l*70.5%
fma-define70.5%
Simplified70.5%
Taylor expanded in z around inf 36.0%
+-commutative36.0%
mul-1-neg36.0%
unsub-neg36.0%
+-commutative36.0%
associate-/r*34.6%
associate-/l*46.8%
*-lft-identity46.8%
times-frac53.9%
/-rgt-identity53.9%
Simplified53.9%
Taylor expanded in t around -inf 40.1%
fma-define40.1%
associate-/l*40.0%
associate-/l*49.6%
mul-1-neg49.6%
Simplified49.6%
Taylor expanded in z around 0 41.3%
associate-/l*56.9%
Simplified56.9%
Taylor expanded in y around inf 34.4%
associate-/l*45.6%
Simplified45.6%
Final simplification57.2%
(FPCore (x y z t a)
:precision binary64
(if (<= t -5.2e+70)
y
(if (<= t -24.5)
(* (/ z (- a t)) y)
(if (<= t 2.4e+66) (+ x (/ (* z y) a)) y))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5.2e+70) {
tmp = y;
} else if (t <= -24.5) {
tmp = (z / (a - t)) * y;
} else if (t <= 2.4e+66) {
tmp = x + ((z * y) / a);
} else {
tmp = y;
}
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 (t <= (-5.2d+70)) then
tmp = y
else if (t <= (-24.5d0)) then
tmp = (z / (a - t)) * y
else if (t <= 2.4d+66) then
tmp = x + ((z * y) / a)
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5.2e+70) {
tmp = y;
} else if (t <= -24.5) {
tmp = (z / (a - t)) * y;
} else if (t <= 2.4e+66) {
tmp = x + ((z * y) / a);
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -5.2e+70: tmp = y elif t <= -24.5: tmp = (z / (a - t)) * y elif t <= 2.4e+66: tmp = x + ((z * y) / a) else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -5.2e+70) tmp = y; elseif (t <= -24.5) tmp = Float64(Float64(z / Float64(a - t)) * y); elseif (t <= 2.4e+66) tmp = Float64(x + Float64(Float64(z * y) / a)); else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -5.2e+70) tmp = y; elseif (t <= -24.5) tmp = (z / (a - t)) * y; elseif (t <= 2.4e+66) tmp = x + ((z * y) / a); else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -5.2e+70], y, If[LessEqual[t, -24.5], N[(N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, 2.4e+66], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], y]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5.2 \cdot 10^{+70}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq -24.5:\\
\;\;\;\;\frac{z}{a - t} \cdot y\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{+66}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -5.2000000000000001e70 or 2.4000000000000002e66 < t Initial program 39.5%
+-commutative39.5%
associate-/l*75.6%
fma-define75.6%
Simplified75.6%
Taylor expanded in y around 0 59.9%
+-commutative59.9%
+-commutative59.9%
div-sub59.9%
mul-1-neg59.9%
associate-/l*75.6%
distribute-lft-neg-in75.6%
distribute-rgt-in75.6%
sub-neg75.6%
associate-*l/39.5%
associate-*r/66.7%
fma-define66.8%
Simplified66.8%
Taylor expanded in t around inf 54.6%
if -5.2000000000000001e70 < t < -24.5Initial program 78.7%
Taylor expanded in y around inf 59.5%
*-commutative59.5%
*-lft-identity59.5%
times-frac64.6%
/-rgt-identity64.6%
Simplified64.6%
Taylor expanded in y around inf 64.5%
Taylor expanded in z around inf 34.9%
associate-*r/40.1%
*-commutative40.1%
Simplified40.1%
if -24.5 < t < 2.4000000000000002e66Initial program 89.3%
Taylor expanded in y around inf 75.7%
*-commutative75.7%
*-lft-identity75.7%
times-frac74.5%
/-rgt-identity74.5%
Simplified74.5%
Taylor expanded in t around 0 61.1%
Final simplification57.1%
(FPCore (x y z t a) :precision binary64 (if (or (<= a -1.85e-96) (not (<= a 6.5e-41))) (+ x (* (- t z) (/ y (- t a)))) (- y (/ (* (- y x) (- z a)) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -1.85e-96) || !(a <= 6.5e-41)) {
tmp = x + ((t - z) * (y / (t - a)));
} else {
tmp = y - (((y - x) * (z - a)) / t);
}
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 ((a <= (-1.85d-96)) .or. (.not. (a <= 6.5d-41))) then
tmp = x + ((t - z) * (y / (t - a)))
else
tmp = y - (((y - x) * (z - a)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((a <= -1.85e-96) || !(a <= 6.5e-41)) {
tmp = x + ((t - z) * (y / (t - a)));
} else {
tmp = y - (((y - x) * (z - a)) / t);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (a <= -1.85e-96) or not (a <= 6.5e-41): tmp = x + ((t - z) * (y / (t - a))) else: tmp = y - (((y - x) * (z - a)) / t) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((a <= -1.85e-96) || !(a <= 6.5e-41)) tmp = Float64(x + Float64(Float64(t - z) * Float64(y / Float64(t - a)))); else tmp = Float64(y - Float64(Float64(Float64(y - x) * Float64(z - a)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((a <= -1.85e-96) || ~((a <= 6.5e-41))) tmp = x + ((t - z) * (y / (t - a))); else tmp = y - (((y - x) * (z - a)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -1.85e-96], N[Not[LessEqual[a, 6.5e-41]], $MachinePrecision]], N[(x + N[(N[(t - z), $MachinePrecision] * N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y - N[(N[(N[(y - x), $MachinePrecision] * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.85 \cdot 10^{-96} \lor \neg \left(a \leq 6.5 \cdot 10^{-41}\right):\\
\;\;\;\;x + \left(t - z\right) \cdot \frac{y}{t - a}\\
\mathbf{else}:\\
\;\;\;\;y - \frac{\left(y - x\right) \cdot \left(z - a\right)}{t}\\
\end{array}
\end{array}
if a < -1.84999999999999993e-96 or 6.5000000000000004e-41 < a Initial program 69.1%
Taylor expanded in y around inf 66.8%
*-commutative66.8%
*-lft-identity66.8%
times-frac73.7%
/-rgt-identity73.7%
Simplified73.7%
if -1.84999999999999993e-96 < a < 6.5000000000000004e-41Initial program 69.5%
+-commutative69.5%
associate-/l*80.7%
fma-define80.7%
Simplified80.7%
Taylor expanded in t around inf 86.7%
associate--l+86.7%
associate-*r/86.7%
associate-*r/86.7%
mul-1-neg86.7%
div-sub86.8%
mul-1-neg86.8%
distribute-lft-out--86.8%
associate-*r/86.8%
mul-1-neg86.8%
unsub-neg86.8%
distribute-rgt-out--86.8%
Simplified86.8%
Final simplification78.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -5.4e+72)
(* y (/ (- t z) (- t a)))
(if (<= t 3.6e+38)
(+ x (* z (/ (- x y) (- t a))))
(- y (* z (/ (- y x) t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5.4e+72) {
tmp = y * ((t - z) / (t - a));
} else if (t <= 3.6e+38) {
tmp = x + (z * ((x - y) / (t - a)));
} else {
tmp = y - (z * ((y - x) / t));
}
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 (t <= (-5.4d+72)) then
tmp = y * ((t - z) / (t - a))
else if (t <= 3.6d+38) then
tmp = x + (z * ((x - y) / (t - a)))
else
tmp = y - (z * ((y - x) / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -5.4e+72) {
tmp = y * ((t - z) / (t - a));
} else if (t <= 3.6e+38) {
tmp = x + (z * ((x - y) / (t - a)));
} else {
tmp = y - (z * ((y - x) / t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -5.4e+72: tmp = y * ((t - z) / (t - a)) elif t <= 3.6e+38: tmp = x + (z * ((x - y) / (t - a))) else: tmp = y - (z * ((y - x) / t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -5.4e+72) tmp = Float64(y * Float64(Float64(t - z) / Float64(t - a))); elseif (t <= 3.6e+38) tmp = Float64(x + Float64(z * Float64(Float64(x - y) / Float64(t - a)))); else tmp = Float64(y - Float64(z * Float64(Float64(y - x) / t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -5.4e+72) tmp = y * ((t - z) / (t - a)); elseif (t <= 3.6e+38) tmp = x + (z * ((x - y) / (t - a))); else tmp = y - (z * ((y - x) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -5.4e+72], N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e+38], N[(x + N[(z * N[(N[(x - y), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y - N[(z * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5.4 \cdot 10^{+72}:\\
\;\;\;\;y \cdot \frac{t - z}{t - a}\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+38}:\\
\;\;\;\;x + z \cdot \frac{x - y}{t - a}\\
\mathbf{else}:\\
\;\;\;\;y - z \cdot \frac{y - x}{t}\\
\end{array}
\end{array}
if t < -5.4000000000000001e72Initial program 33.9%
+-commutative33.9%
associate-/l*79.6%
fma-define79.6%
Simplified79.6%
Taylor expanded in y around 0 57.0%
+-commutative57.0%
+-commutative57.0%
div-sub57.0%
mul-1-neg57.0%
associate-/l*79.6%
distribute-lft-neg-in79.6%
distribute-rgt-in79.6%
sub-neg79.6%
associate-*l/33.9%
associate-*r/67.4%
fma-define67.7%
Simplified67.7%
Taylor expanded in y around inf 75.8%
div-sub75.8%
Simplified75.8%
if -5.4000000000000001e72 < t < 3.59999999999999969e38Initial program 89.6%
Taylor expanded in z around inf 78.4%
associate-/l*80.9%
Simplified80.9%
if 3.59999999999999969e38 < t Initial program 46.2%
+-commutative46.2%
associate-/l*68.8%
fma-define68.8%
Simplified68.8%
Taylor expanded in z around inf 42.5%
+-commutative42.5%
mul-1-neg42.5%
unsub-neg42.5%
+-commutative42.5%
associate-/r*39.4%
associate-/l*52.0%
*-lft-identity52.0%
times-frac58.1%
/-rgt-identity58.1%
Simplified58.1%
Taylor expanded in t around -inf 44.2%
fma-define44.2%
associate-/l*44.1%
associate-/l*52.5%
mul-1-neg52.5%
Simplified52.5%
Taylor expanded in a around 0 64.7%
mul-1-neg64.7%
unsub-neg64.7%
associate-/l*72.7%
Simplified72.7%
Final simplification78.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -3.4e-12) (not (<= t 2.75e-93))) (- y (* z (/ (- y x) t))) (+ x (* z (/ (- y x) a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -3.4e-12) || !(t <= 2.75e-93)) {
tmp = y - (z * ((y - x) / t));
} else {
tmp = x + (z * ((y - x) / a));
}
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 ((t <= (-3.4d-12)) .or. (.not. (t <= 2.75d-93))) then
tmp = y - (z * ((y - x) / t))
else
tmp = x + (z * ((y - x) / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -3.4e-12) || !(t <= 2.75e-93)) {
tmp = y - (z * ((y - x) / t));
} else {
tmp = x + (z * ((y - x) / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -3.4e-12) or not (t <= 2.75e-93): tmp = y - (z * ((y - x) / t)) else: tmp = x + (z * ((y - x) / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -3.4e-12) || !(t <= 2.75e-93)) tmp = Float64(y - Float64(z * Float64(Float64(y - x) / t))); else tmp = Float64(x + Float64(z * Float64(Float64(y - x) / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -3.4e-12) || ~((t <= 2.75e-93))) tmp = y - (z * ((y - x) / t)); else tmp = x + (z * ((y - x) / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -3.4e-12], N[Not[LessEqual[t, 2.75e-93]], $MachinePrecision]], N[(y - N[(z * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.4 \cdot 10^{-12} \lor \neg \left(t \leq 2.75 \cdot 10^{-93}\right):\\
\;\;\;\;y - z \cdot \frac{y - x}{t}\\
\mathbf{else}:\\
\;\;\;\;x + z \cdot \frac{y - x}{a}\\
\end{array}
\end{array}
if t < -3.4000000000000001e-12 or 2.74999999999999984e-93 < t Initial program 54.4%
+-commutative54.4%
associate-/l*79.6%
fma-define79.6%
Simplified79.6%
Taylor expanded in z around inf 48.8%
+-commutative48.8%
mul-1-neg48.8%
unsub-neg48.8%
+-commutative48.8%
associate-/r*46.5%
associate-/l*56.3%
*-lft-identity56.3%
times-frac63.2%
/-rgt-identity63.2%
Simplified63.2%
Taylor expanded in t around -inf 44.8%
fma-define44.8%
associate-/l*48.3%
associate-/l*52.4%
mul-1-neg52.4%
Simplified52.4%
Taylor expanded in a around 0 64.4%
mul-1-neg64.4%
unsub-neg64.4%
associate-/l*70.3%
Simplified70.3%
if -3.4000000000000001e-12 < t < 2.74999999999999984e-93Initial program 93.0%
Taylor expanded in t around 0 76.0%
associate-/l*79.0%
Simplified79.0%
Final simplification73.6%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -7.2e-40) (not (<= t 3.8e-68))) (* y (/ (- t z) (- t a))) (+ x (/ (* z y) a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -7.2e-40) || !(t <= 3.8e-68)) {
tmp = y * ((t - z) / (t - a));
} else {
tmp = x + ((z * y) / a);
}
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 ((t <= (-7.2d-40)) .or. (.not. (t <= 3.8d-68))) then
tmp = y * ((t - z) / (t - a))
else
tmp = x + ((z * y) / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -7.2e-40) || !(t <= 3.8e-68)) {
tmp = y * ((t - z) / (t - a));
} else {
tmp = x + ((z * y) / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -7.2e-40) or not (t <= 3.8e-68): tmp = y * ((t - z) / (t - a)) else: tmp = x + ((z * y) / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -7.2e-40) || !(t <= 3.8e-68)) tmp = Float64(y * Float64(Float64(t - z) / Float64(t - a))); else tmp = Float64(x + Float64(Float64(z * y) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -7.2e-40) || ~((t <= 3.8e-68))) tmp = y * ((t - z) / (t - a)); else tmp = x + ((z * y) / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -7.2e-40], N[Not[LessEqual[t, 3.8e-68]], $MachinePrecision]], N[(y * N[(N[(t - z), $MachinePrecision] / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.2 \cdot 10^{-40} \lor \neg \left(t \leq 3.8 \cdot 10^{-68}\right):\\
\;\;\;\;y \cdot \frac{t - z}{t - a}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\end{array}
\end{array}
if t < -7.2e-40 or 3.80000000000000038e-68 < t Initial program 53.2%
+-commutative53.2%
associate-/l*79.0%
fma-define79.0%
Simplified79.0%
Taylor expanded in y around 0 65.8%
+-commutative65.8%
+-commutative65.8%
div-sub65.8%
mul-1-neg65.8%
associate-/l*77.7%
distribute-lft-neg-in77.7%
distribute-rgt-in79.0%
sub-neg79.0%
associate-*l/53.2%
associate-*r/72.7%
fma-define72.9%
Simplified72.9%
Taylor expanded in y around inf 63.0%
div-sub63.0%
Simplified63.0%
if -7.2e-40 < t < 3.80000000000000038e-68Initial program 93.2%
Taylor expanded in y around inf 78.4%
*-commutative78.4%
*-lft-identity78.4%
times-frac76.6%
/-rgt-identity76.6%
Simplified76.6%
Taylor expanded in t around 0 67.9%
Final simplification65.0%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -1.7e-10) (not (<= t 7.5e-34))) (* y (/ (- t z) t)) (+ x (/ (* z y) a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.7e-10) || !(t <= 7.5e-34)) {
tmp = y * ((t - z) / t);
} else {
tmp = x + ((z * y) / a);
}
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 ((t <= (-1.7d-10)) .or. (.not. (t <= 7.5d-34))) then
tmp = y * ((t - z) / t)
else
tmp = x + ((z * y) / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.7e-10) || !(t <= 7.5e-34)) {
tmp = y * ((t - z) / t);
} else {
tmp = x + ((z * y) / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -1.7e-10) or not (t <= 7.5e-34): tmp = y * ((t - z) / t) else: tmp = x + ((z * y) / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -1.7e-10) || !(t <= 7.5e-34)) tmp = Float64(y * Float64(Float64(t - z) / t)); else tmp = Float64(x + Float64(Float64(z * y) / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -1.7e-10) || ~((t <= 7.5e-34))) tmp = y * ((t - z) / t); else tmp = x + ((z * y) / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.7e-10], N[Not[LessEqual[t, 7.5e-34]], $MachinePrecision]], N[(y * N[(N[(t - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.7 \cdot 10^{-10} \lor \neg \left(t \leq 7.5 \cdot 10^{-34}\right):\\
\;\;\;\;y \cdot \frac{t - z}{t}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z \cdot y}{a}\\
\end{array}
\end{array}
if t < -1.70000000000000007e-10 or 7.5000000000000004e-34 < t Initial program 49.6%
+-commutative49.6%
associate-/l*77.4%
fma-define77.4%
Simplified77.4%
Taylor expanded in y around 0 63.1%
+-commutative63.1%
+-commutative63.1%
div-sub63.1%
mul-1-neg63.1%
associate-/l*76.7%
distribute-lft-neg-in76.7%
distribute-rgt-in77.4%
sub-neg77.4%
associate-*l/49.6%
associate-*r/71.2%
fma-define71.4%
Simplified71.4%
Taylor expanded in y around -inf 41.4%
Taylor expanded in a around 0 36.4%
mul-1-neg36.4%
associate-/l*55.9%
distribute-lft-neg-in55.9%
Simplified55.9%
if -1.70000000000000007e-10 < t < 7.5000000000000004e-34Initial program 93.9%
Taylor expanded in y around inf 79.6%
*-commutative79.6%
*-lft-identity79.6%
times-frac77.3%
/-rgt-identity77.3%
Simplified77.3%
Taylor expanded in t around 0 66.8%
Final simplification60.8%
(FPCore (x y z t a) :precision binary64 (if (<= t -1.22e-11) y (if (<= t 8.2e+58) x y)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.22e-11) {
tmp = y;
} else if (t <= 8.2e+58) {
tmp = x;
} else {
tmp = y;
}
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 (t <= (-1.22d-11)) then
tmp = y
else if (t <= 8.2d+58) then
tmp = x
else
tmp = y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.22e-11) {
tmp = y;
} else if (t <= 8.2e+58) {
tmp = x;
} else {
tmp = y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -1.22e-11: tmp = y elif t <= 8.2e+58: tmp = x else: tmp = y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.22e-11) tmp = y; elseif (t <= 8.2e+58) tmp = x; else tmp = y; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -1.22e-11) tmp = y; elseif (t <= 8.2e+58) tmp = x; else tmp = y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.22e-11], y, If[LessEqual[t, 8.2e+58], x, y]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.22 \cdot 10^{-11}:\\
\;\;\;\;y\\
\mathbf{elif}\;t \leq 8.2 \cdot 10^{+58}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;y\\
\end{array}
\end{array}
if t < -1.2200000000000001e-11 or 8.2e58 < t Initial program 46.1%
+-commutative46.1%
associate-/l*77.4%
fma-define77.4%
Simplified77.4%
Taylor expanded in y around 0 62.1%
+-commutative62.1%
+-commutative62.1%
div-sub62.1%
mul-1-neg62.1%
associate-/l*77.4%
distribute-lft-neg-in77.4%
distribute-rgt-in77.4%
sub-neg77.4%
associate-*l/46.1%
associate-*r/70.0%
fma-define70.2%
Simplified70.2%
Taylor expanded in t around inf 47.0%
if -1.2200000000000001e-11 < t < 8.2e58Initial program 89.8%
+-commutative89.8%
associate-/l*93.0%
fma-define93.0%
Simplified93.0%
Taylor expanded in a around inf 42.1%
(FPCore (x y z t a) :precision binary64 x)
double code(double x, double y, double z, double t, double a) {
return x;
}
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
end function
public static double code(double x, double y, double z, double t, double a) {
return x;
}
def code(x, y, z, t, a): return x
function code(x, y, z, t, a) return x end
function tmp = code(x, y, z, t, a) tmp = x; end
code[x_, y_, z_, t_, a_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 69.3%
+-commutative69.3%
associate-/l*85.7%
fma-define85.7%
Simplified85.7%
Taylor expanded in a around inf 27.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
(if (< a -1.6153062845442575e-142)
t_1
(if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - x));
} 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 = x + (((y - x) / 1.0d0) * ((z - t) / (a - t)))
if (a < (-1.6153062845442575d-142)) then
tmp = t_1
else if (a < 3.774403170083174d-182) then
tmp = y - ((z / t) * (y - x))
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 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
double tmp;
if (a < -1.6153062845442575e-142) {
tmp = t_1;
} else if (a < 3.774403170083174e-182) {
tmp = y - ((z / t) * (y - x));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))) tmp = 0 if a < -1.6153062845442575e-142: tmp = t_1 elif a < 3.774403170083174e-182: tmp = y - ((z / t) * (y - x)) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(Float64(y - x) / 1.0) * Float64(Float64(z - t) / Float64(a - t)))) tmp = 0.0 if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = Float64(y - Float64(Float64(z / t) * Float64(y - x))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t))); tmp = 0.0; if (a < -1.6153062845442575e-142) tmp = t_1; elseif (a < 3.774403170083174e-182) tmp = y - ((z / t) * (y - x)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - x), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[a, -1.6153062845442575e-142], t$95$1, If[Less[a, 3.774403170083174e-182], N[(y - N[(N[(z / t), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y - x}{1} \cdot \frac{z - t}{a - t}\\
\mathbf{if}\;a < -1.6153062845442575 \cdot 10^{-142}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a < 3.774403170083174 \cdot 10^{-182}:\\
\;\;\;\;y - \frac{z}{t} \cdot \left(y - x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
herbie shell --seed 2024137
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
:precision binary64
:alt
(! :herbie-platform default (if (< a -646122513817703/4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ x (* (/ (- y x) 1) (/ (- z t) (- a t)))) (if (< a 1887201585041587/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- y (* (/ z t) (- y x))) (+ x (* (/ (- y x) 1) (/ (- z t) (- a t)))))))
(+ x (/ (* (- y x) (- z t)) (- a t))))