
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(* (- (* x j) (* z k)) (- (* y0 b) (* y1 i))))
(* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a))))
(* (- (* t j) (* y k)) (- (* y4 b) (* y5 i))))
(* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(Float64(y0 * b) - Float64(y1 * i)))) + Float64(Float64(Float64(x * y2) - Float64(z * y3)) * Float64(Float64(y0 * c) - Float64(y1 * a)))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * Float64(Float64(y4 * b) - Float64(y5 * i)))) - Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(y4 * c) - Float64(y5 * a)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(x \cdot j - z \cdot k\right) \cdot \left(y0 \cdot b - y1 \cdot i\right)\right) + \left(x \cdot y2 - z \cdot y3\right) \cdot \left(y0 \cdot c - y1 \cdot a\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot \left(y4 \cdot b - y5 \cdot i\right)\right) - \left(t \cdot y2 - y \cdot y3\right) \cdot \left(y4 \cdot c - y5 \cdot a\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 34 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(* (- (* x j) (* z k)) (- (* y0 b) (* y1 i))))
(* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a))))
(* (- (* t j) (* y k)) (- (* y4 b) (* y5 i))))
(* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(Float64(y0 * b) - Float64(y1 * i)))) + Float64(Float64(Float64(x * y2) - Float64(z * y3)) * Float64(Float64(y0 * c) - Float64(y1 * a)))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * Float64(Float64(y4 * b) - Float64(y5 * i)))) - Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(y4 * c) - Float64(y5 * a)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(x \cdot j - z \cdot k\right) \cdot \left(y0 \cdot b - y1 \cdot i\right)\right) + \left(x \cdot y2 - z \cdot y3\right) \cdot \left(y0 \cdot c - y1 \cdot a\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot \left(y4 \cdot b - y5 \cdot i\right)\right) - \left(t \cdot y2 - y \cdot y3\right) \cdot \left(y4 \cdot c - y5 \cdot a\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)
\end{array}
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y4 y1 (* (- y0) y5)))
(t_2 (fma t_1 j (* (fma y0 c (* (- a) y1)) z))))
(if (<= y3 -1.7e+122)
(* (- y3) (- t_2 (* (* (- a) y) y5)))
(if (<= y3 -1.9e+56)
(*
(-
(fma (- y3) t_1 (* (fma y4 b (* (- i) y5)) t))
(* (fma y0 b (* (- i) y1)) x))
j)
(if (<= y3 1.1e-23)
(*
(- i)
(-
(fma (fma y x (* (- t) z)) c (* (fma j t (* (- k) y)) y5))
(* (fma j x (* (- k) z)) y1)))
(if (<= y3 3.3e+168)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= y3 2.65e+219)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(* (- y3) (- t_2 (* (fma y4 c (* (- a) y5)) y))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(y4, y1, (-y0 * y5));
double t_2 = fma(t_1, j, (fma(y0, c, (-a * y1)) * z));
double tmp;
if (y3 <= -1.7e+122) {
tmp = -y3 * (t_2 - ((-a * y) * y5));
} else if (y3 <= -1.9e+56) {
tmp = (fma(-y3, t_1, (fma(y4, b, (-i * y5)) * t)) - (fma(y0, b, (-i * y1)) * x)) * j;
} else if (y3 <= 1.1e-23) {
tmp = -i * (fma(fma(y, x, (-t * z)), c, (fma(j, t, (-k * y)) * y5)) - (fma(j, x, (-k * z)) * y1));
} else if (y3 <= 3.3e+168) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (y3 <= 2.65e+219) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else {
tmp = -y3 * (t_2 - (fma(y4, c, (-a * y5)) * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(y4, y1, Float64(Float64(-y0) * y5)) t_2 = fma(t_1, j, Float64(fma(y0, c, Float64(Float64(-a) * y1)) * z)) tmp = 0.0 if (y3 <= -1.7e+122) tmp = Float64(Float64(-y3) * Float64(t_2 - Float64(Float64(Float64(-a) * y) * y5))); elseif (y3 <= -1.9e+56) tmp = Float64(Float64(fma(Float64(-y3), t_1, Float64(fma(y4, b, Float64(Float64(-i) * y5)) * t)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * x)) * j); elseif (y3 <= 1.1e-23) tmp = Float64(Float64(-i) * Float64(fma(fma(y, x, Float64(Float64(-t) * z)), c, Float64(fma(j, t, Float64(Float64(-k) * y)) * y5)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * y1))); elseif (y3 <= 3.3e+168) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (y3 <= 2.65e+219) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); else tmp = Float64(Float64(-y3) * Float64(t_2 - Float64(fma(y4, c, Float64(Float64(-a) * y5)) * y))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * j + N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y3, -1.7e+122], N[((-y3) * N[(t$95$2 - N[(N[((-a) * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, -1.9e+56], N[(N[(N[((-y3) * t$95$1 + N[(N[(y4 * b + N[((-i) * y5), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[y3, 1.1e-23], N[((-i) * N[(N[(N[(y * x + N[((-t) * z), $MachinePrecision]), $MachinePrecision] * c + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 3.3e+168], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 2.65e+219], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-y3) * N[(t$95$2 - N[(N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
t_2 := \mathsf{fma}\left(t\_1, j, \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right) \cdot z\right)\\
\mathbf{if}\;y3 \leq -1.7 \cdot 10^{+122}:\\
\;\;\;\;\left(-y3\right) \cdot \left(t\_2 - \left(\left(-a\right) \cdot y\right) \cdot y5\right)\\
\mathbf{elif}\;y3 \leq -1.9 \cdot 10^{+56}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y3, t\_1, \mathsf{fma}\left(y4, b, \left(-i\right) \cdot y5\right) \cdot t\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot x\right) \cdot j\\
\mathbf{elif}\;y3 \leq 1.1 \cdot 10^{-23}:\\
\;\;\;\;\left(-i\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y, x, \left(-t\right) \cdot z\right), c, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot y5\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot y1\right)\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;y3 \leq 2.65 \cdot 10^{+219}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-y3\right) \cdot \left(t\_2 - \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right) \cdot y\right)\\
\end{array}
\end{array}
if y3 < -1.7e122Initial program 27.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites64.0%
Taylor expanded in a around inf
Applied rewrites71.0%
if -1.7e122 < y3 < -1.89999999999999998e56Initial program 37.4%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites83.1%
if -1.89999999999999998e56 < y3 < 1.1e-23Initial program 33.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites54.6%
if 1.1e-23 < y3 < 3.2999999999999999e168Initial program 30.8%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in t around inf
Applied rewrites37.9%
Taylor expanded in y around inf
Applied rewrites54.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites58.9%
if 3.2999999999999999e168 < y3 < 2.64999999999999992e219Initial program 13.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites40.0%
Taylor expanded in y around -inf
Applied rewrites80.6%
if 2.64999999999999992e219 < y3 Initial program 6.3%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites81.3%
Final simplification63.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(* (- (* x j) (* z k)) (- (* y0 b) (* y1 i))))
(* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a))))
(* (- (* t j) (* y k)) (- (* y4 b) (* y5 i))))
(* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))))
(if (<= t_1 INFINITY)
t_1
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(Float64(y0 * b) - Float64(y1 * i)))) + Float64(Float64(Float64(x * y2) - Float64(z * y3)) * Float64(Float64(y0 * c) - Float64(y1 * a)))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * Float64(Float64(y4 * b) - Float64(y5 * i)))) - Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(y4 * c) - Float64(y5 * a)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(x \cdot j - z \cdot k\right) \cdot \left(y0 \cdot b - y1 \cdot i\right)\right) + \left(x \cdot y2 - z \cdot y3\right) \cdot \left(y0 \cdot c - y1 \cdot a\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot \left(y4 \cdot b - y5 \cdot i\right)\right) - \left(t \cdot y2 - y \cdot y3\right) \cdot \left(y4 \cdot c - y5 \cdot a\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (+.f64 (+.f64 (-.f64 (*.f64 (-.f64 (*.f64 x y) (*.f64 z t)) (-.f64 (*.f64 a b) (*.f64 c i))) (*.f64 (-.f64 (*.f64 x j) (*.f64 z k)) (-.f64 (*.f64 y0 b) (*.f64 y1 i)))) (*.f64 (-.f64 (*.f64 x y2) (*.f64 z y3)) (-.f64 (*.f64 y0 c) (*.f64 y1 a)))) (*.f64 (-.f64 (*.f64 t j) (*.f64 y k)) (-.f64 (*.f64 y4 b) (*.f64 y5 i)))) (*.f64 (-.f64 (*.f64 t y2) (*.f64 y y3)) (-.f64 (*.f64 y4 c) (*.f64 y5 a)))) (*.f64 (-.f64 (*.f64 k y2) (*.f64 j y3)) (-.f64 (*.f64 y4 y1) (*.f64 y5 y0)))) < +inf.0Initial program 91.1%
if +inf.0 < (+.f64 (-.f64 (+.f64 (+.f64 (-.f64 (*.f64 (-.f64 (*.f64 x y) (*.f64 z t)) (-.f64 (*.f64 a b) (*.f64 c i))) (*.f64 (-.f64 (*.f64 x j) (*.f64 z k)) (-.f64 (*.f64 y0 b) (*.f64 y1 i)))) (*.f64 (-.f64 (*.f64 x y2) (*.f64 z y3)) (-.f64 (*.f64 y0 c) (*.f64 y1 a)))) (*.f64 (-.f64 (*.f64 t j) (*.f64 y k)) (-.f64 (*.f64 y4 b) (*.f64 y5 i)))) (*.f64 (-.f64 (*.f64 t y2) (*.f64 y y3)) (-.f64 (*.f64 y4 c) (*.f64 y5 a)))) (*.f64 (-.f64 (*.f64 k y2) (*.f64 j y3)) (-.f64 (*.f64 y4 y1) (*.f64 y5 y0)))) Initial program 0.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites33.8%
Taylor expanded in t around inf
Applied rewrites35.3%
Taylor expanded in y around inf
Applied rewrites43.2%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites48.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y0 c (* (- a) y1)))
(t_2 (fma y4 y1 (* (- y0) y5)))
(t_3 (* (- y3) (- (fma t_2 j (* t_1 z)) (* (* (- a) y) y5)))))
(if (<= y3 -6.4e-97)
t_3
(if (<= y3 -3.8e-147)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= y3 3.5e-246)
(*
(-
(fma t_1 y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)
(if (<= y3 7.6e-174)
(* (- (fma t_2 k (* t_1 x)) (* (fma y4 c (* (- a) y5)) t)) y2)
(if (<= y3 3.3e+168)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= y3 2.65e+219)
(* i (* y (fma -1.0 (* c x) (* k y5))))
t_3))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(y0, c, (-a * y1));
double t_2 = fma(y4, y1, (-y0 * y5));
double t_3 = -y3 * (fma(t_2, j, (t_1 * z)) - ((-a * y) * y5));
double tmp;
if (y3 <= -6.4e-97) {
tmp = t_3;
} else if (y3 <= -3.8e-147) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (y3 <= 3.5e-246) {
tmp = (fma(t_1, y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
} else if (y3 <= 7.6e-174) {
tmp = (fma(t_2, k, (t_1 * x)) - (fma(y4, c, (-a * y5)) * t)) * y2;
} else if (y3 <= 3.3e+168) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (y3 <= 2.65e+219) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else {
tmp = t_3;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(y0, c, Float64(Float64(-a) * y1)) t_2 = fma(y4, y1, Float64(Float64(-y0) * y5)) t_3 = Float64(Float64(-y3) * Float64(fma(t_2, j, Float64(t_1 * z)) - Float64(Float64(Float64(-a) * y) * y5))) tmp = 0.0 if (y3 <= -6.4e-97) tmp = t_3; elseif (y3 <= -3.8e-147) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (y3 <= 3.5e-246) tmp = Float64(Float64(fma(t_1, y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x); elseif (y3 <= 7.6e-174) tmp = Float64(Float64(fma(t_2, k, Float64(t_1 * x)) - Float64(fma(y4, c, Float64(Float64(-a) * y5)) * t)) * y2); elseif (y3 <= 3.3e+168) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (y3 <= 2.65e+219) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); else tmp = t_3; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[((-y3) * N[(N[(t$95$2 * j + N[(t$95$1 * z), $MachinePrecision]), $MachinePrecision] - N[(N[((-a) * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y3, -6.4e-97], t$95$3, If[LessEqual[y3, -3.8e-147], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[y3, 3.5e-246], N[(N[(N[(t$95$1 * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y3, 7.6e-174], N[(N[(N[(t$95$2 * k + N[(t$95$1 * x), $MachinePrecision]), $MachinePrecision] - N[(N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], If[LessEqual[y3, 3.3e+168], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 2.65e+219], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right)\\
t_2 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
t_3 := \left(-y3\right) \cdot \left(\mathsf{fma}\left(t\_2, j, t\_1 \cdot z\right) - \left(\left(-a\right) \cdot y\right) \cdot y5\right)\\
\mathbf{if}\;y3 \leq -6.4 \cdot 10^{-97}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;y3 \leq -3.8 \cdot 10^{-147}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;y3 \leq 3.5 \cdot 10^{-246}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_1, y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{elif}\;y3 \leq 7.6 \cdot 10^{-174}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_2, k, t\_1 \cdot x\right) - \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right) \cdot t\right) \cdot y2\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;y3 \leq 2.65 \cdot 10^{+219}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if y3 < -6.39999999999999961e-97 or 2.64999999999999992e219 < y3 Initial program 27.9%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in a around inf
Applied rewrites61.3%
if -6.39999999999999961e-97 < y3 < -3.80000000000000028e-147Initial program 17.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites66.7%
Taylor expanded in k around -inf
Applied rewrites42.7%
Taylor expanded in t around -inf
Applied rewrites59.2%
Applied rewrites67.1%
if -3.80000000000000028e-147 < y3 < 3.5000000000000002e-246Initial program 38.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.4%
if 3.5000000000000002e-246 < y3 < 7.60000000000000042e-174Initial program 44.7%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites72.8%
if 7.60000000000000042e-174 < y3 < 3.2999999999999999e168Initial program 27.6%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.9%
Taylor expanded in t around inf
Applied rewrites39.3%
Taylor expanded in y around inf
Applied rewrites56.1%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites59.0%
if 3.2999999999999999e168 < y3 < 2.64999999999999992e219Initial program 13.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites40.0%
Taylor expanded in y around -inf
Applied rewrites80.6%
Final simplification61.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y0 c (* (- a) y1)))
(t_2
(*
(- y3)
(- (fma (fma y4 y1 (* (- y0) y5)) j (* t_1 z)) (* (* (- a) y) y5)))))
(if (<= y3 -6.4e-97)
t_2
(if (<= y3 -3.8e-147)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= y3 3.3e-161)
(*
(-
(fma t_1 y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)
(if (<= y3 3.3e+168)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= y3 2.65e+219)
(* i (* y (fma -1.0 (* c x) (* k y5))))
t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(y0, c, (-a * y1));
double t_2 = -y3 * (fma(fma(y4, y1, (-y0 * y5)), j, (t_1 * z)) - ((-a * y) * y5));
double tmp;
if (y3 <= -6.4e-97) {
tmp = t_2;
} else if (y3 <= -3.8e-147) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (y3 <= 3.3e-161) {
tmp = (fma(t_1, y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
} else if (y3 <= 3.3e+168) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (y3 <= 2.65e+219) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(y0, c, Float64(Float64(-a) * y1)) t_2 = Float64(Float64(-y3) * Float64(fma(fma(y4, y1, Float64(Float64(-y0) * y5)), j, Float64(t_1 * z)) - Float64(Float64(Float64(-a) * y) * y5))) tmp = 0.0 if (y3 <= -6.4e-97) tmp = t_2; elseif (y3 <= -3.8e-147) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (y3 <= 3.3e-161) tmp = Float64(Float64(fma(t_1, y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x); elseif (y3 <= 3.3e+168) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (y3 <= 2.65e+219) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-y3) * N[(N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * j + N[(t$95$1 * z), $MachinePrecision]), $MachinePrecision] - N[(N[((-a) * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y3, -6.4e-97], t$95$2, If[LessEqual[y3, -3.8e-147], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[y3, 3.3e-161], N[(N[(N[(t$95$1 * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y3, 3.3e+168], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 2.65e+219], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right)\\
t_2 := \left(-y3\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), j, t\_1 \cdot z\right) - \left(\left(-a\right) \cdot y\right) \cdot y5\right)\\
\mathbf{if}\;y3 \leq -6.4 \cdot 10^{-97}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y3 \leq -3.8 \cdot 10^{-147}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{-161}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_1, y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;y3 \leq 2.65 \cdot 10^{+219}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y3 < -6.39999999999999961e-97 or 2.64999999999999992e219 < y3 Initial program 27.9%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in a around inf
Applied rewrites61.3%
if -6.39999999999999961e-97 < y3 < -3.80000000000000028e-147Initial program 17.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites66.7%
Taylor expanded in k around -inf
Applied rewrites42.7%
Taylor expanded in t around -inf
Applied rewrites59.2%
Applied rewrites67.1%
if -3.80000000000000028e-147 < y3 < 3.2999999999999998e-161Initial program 39.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.7%
if 3.2999999999999998e-161 < y3 < 3.2999999999999999e168Initial program 28.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.2%
Taylor expanded in t around inf
Applied rewrites39.9%
Taylor expanded in y around inf
Applied rewrites56.9%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites59.8%
if 3.2999999999999999e168 < y3 < 2.64999999999999992e219Initial program 13.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites40.0%
Taylor expanded in y around -inf
Applied rewrites80.6%
Final simplification59.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma (fma y4 y1 (* (- y0) y5)) j (* (fma y0 c (* (- a) y1)) z))))
(if (<= y3 -1.85e+115)
(* (- y3) (- t_1 (* (* (- a) y) y5)))
(if (<= y3 1.1e-23)
(*
(- i)
(-
(fma (fma y x (* (- t) z)) c (* (fma j t (* (- k) y)) y5))
(* (fma j x (* (- k) z)) y1)))
(if (<= y3 3.3e+168)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= y3 2.65e+219)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(* (- y3) (- t_1 (* (fma y4 c (* (- a) y5)) y)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(fma(y4, y1, (-y0 * y5)), j, (fma(y0, c, (-a * y1)) * z));
double tmp;
if (y3 <= -1.85e+115) {
tmp = -y3 * (t_1 - ((-a * y) * y5));
} else if (y3 <= 1.1e-23) {
tmp = -i * (fma(fma(y, x, (-t * z)), c, (fma(j, t, (-k * y)) * y5)) - (fma(j, x, (-k * z)) * y1));
} else if (y3 <= 3.3e+168) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (y3 <= 2.65e+219) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else {
tmp = -y3 * (t_1 - (fma(y4, c, (-a * y5)) * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), j, Float64(fma(y0, c, Float64(Float64(-a) * y1)) * z)) tmp = 0.0 if (y3 <= -1.85e+115) tmp = Float64(Float64(-y3) * Float64(t_1 - Float64(Float64(Float64(-a) * y) * y5))); elseif (y3 <= 1.1e-23) tmp = Float64(Float64(-i) * Float64(fma(fma(y, x, Float64(Float64(-t) * z)), c, Float64(fma(j, t, Float64(Float64(-k) * y)) * y5)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * y1))); elseif (y3 <= 3.3e+168) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (y3 <= 2.65e+219) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); else tmp = Float64(Float64(-y3) * Float64(t_1 - Float64(fma(y4, c, Float64(Float64(-a) * y5)) * y))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * j + N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y3, -1.85e+115], N[((-y3) * N[(t$95$1 - N[(N[((-a) * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 1.1e-23], N[((-i) * N[(N[(N[(y * x + N[((-t) * z), $MachinePrecision]), $MachinePrecision] * c + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 3.3e+168], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 2.65e+219], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-y3) * N[(t$95$1 - N[(N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), j, \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right) \cdot z\right)\\
\mathbf{if}\;y3 \leq -1.85 \cdot 10^{+115}:\\
\;\;\;\;\left(-y3\right) \cdot \left(t\_1 - \left(\left(-a\right) \cdot y\right) \cdot y5\right)\\
\mathbf{elif}\;y3 \leq 1.1 \cdot 10^{-23}:\\
\;\;\;\;\left(-i\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y, x, \left(-t\right) \cdot z\right), c, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot y5\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot y1\right)\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;y3 \leq 2.65 \cdot 10^{+219}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-y3\right) \cdot \left(t\_1 - \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right) \cdot y\right)\\
\end{array}
\end{array}
if y3 < -1.85000000000000003e115Initial program 27.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites59.7%
Taylor expanded in a around inf
Applied rewrites68.5%
if -1.85000000000000003e115 < y3 < 1.1e-23Initial program 34.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites54.5%
if 1.1e-23 < y3 < 3.2999999999999999e168Initial program 30.8%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in t around inf
Applied rewrites37.9%
Taylor expanded in y around inf
Applied rewrites54.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites58.9%
if 3.2999999999999999e168 < y3 < 2.64999999999999992e219Initial program 13.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites40.0%
Taylor expanded in y around -inf
Applied rewrites80.6%
if 2.64999999999999992e219 < y3 Initial program 6.3%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites81.3%
Final simplification60.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(- y3)
(-
(fma (fma y4 y1 (* (- y0) y5)) j (* (fma y0 c (* (- a) y1)) z))
(* (* (- a) y) y5)))))
(if (<= y3 -1.85e+115)
t_1
(if (<= y3 1.1e-23)
(*
(- i)
(-
(fma (fma y x (* (- t) z)) c (* (fma j t (* (- k) y)) y5))
(* (fma j x (* (- k) z)) y1)))
(if (<= y3 3.3e+168)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= y3 2.65e+219)
(* i (* y (fma -1.0 (* c x) (* k y5))))
t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = -y3 * (fma(fma(y4, y1, (-y0 * y5)), j, (fma(y0, c, (-a * y1)) * z)) - ((-a * y) * y5));
double tmp;
if (y3 <= -1.85e+115) {
tmp = t_1;
} else if (y3 <= 1.1e-23) {
tmp = -i * (fma(fma(y, x, (-t * z)), c, (fma(j, t, (-k * y)) * y5)) - (fma(j, x, (-k * z)) * y1));
} else if (y3 <= 3.3e+168) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (y3 <= 2.65e+219) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(-y3) * Float64(fma(fma(y4, y1, Float64(Float64(-y0) * y5)), j, Float64(fma(y0, c, Float64(Float64(-a) * y1)) * z)) - Float64(Float64(Float64(-a) * y) * y5))) tmp = 0.0 if (y3 <= -1.85e+115) tmp = t_1; elseif (y3 <= 1.1e-23) tmp = Float64(Float64(-i) * Float64(fma(fma(y, x, Float64(Float64(-t) * z)), c, Float64(fma(j, t, Float64(Float64(-k) * y)) * y5)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * y1))); elseif (y3 <= 3.3e+168) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (y3 <= 2.65e+219) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[((-y3) * N[(N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * j + N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[((-a) * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y3, -1.85e+115], t$95$1, If[LessEqual[y3, 1.1e-23], N[((-i) * N[(N[(N[(y * x + N[((-t) * z), $MachinePrecision]), $MachinePrecision] * c + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 3.3e+168], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y3, 2.65e+219], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-y3\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), j, \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right) \cdot z\right) - \left(\left(-a\right) \cdot y\right) \cdot y5\right)\\
\mathbf{if}\;y3 \leq -1.85 \cdot 10^{+115}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y3 \leq 1.1 \cdot 10^{-23}:\\
\;\;\;\;\left(-i\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y, x, \left(-t\right) \cdot z\right), c, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot y5\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot y1\right)\\
\mathbf{elif}\;y3 \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;y3 \leq 2.65 \cdot 10^{+219}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y3 < -1.85000000000000003e115 or 2.64999999999999992e219 < y3 Initial program 21.8%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites65.5%
Taylor expanded in a around inf
Applied rewrites70.2%
if -1.85000000000000003e115 < y3 < 1.1e-23Initial program 34.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites54.5%
if 1.1e-23 < y3 < 3.2999999999999999e168Initial program 30.8%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in t around inf
Applied rewrites37.9%
Taylor expanded in y around inf
Applied rewrites54.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites58.9%
if 3.2999999999999999e168 < y3 < 2.64999999999999992e219Initial program 13.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites40.0%
Taylor expanded in y around -inf
Applied rewrites80.6%
Final simplification60.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= i -4e+47)
(* (* i k) (fma y y5 (* (- y1) z)))
(if (<= i -2.5e-210)
(* (* (- k) (fma y y4 (* (- y0) z))) b)
(if (<= i 1.3e-287)
(* (* j (fma y3 y5 (* (- b) x))) y0)
(if (<= i 2.35e-188)
(* (- y5) (* y2 (- (* k y0) (* a t))))
(if (<= i 2.1e+28)
(* (* y (fma -1.0 (* k y4) (* a x))) b)
(if (<= i 1.85e+163)
(* (* i z) (fma c t (* (- k) y1)))
(* (* (- i) x) (* (fma (- j) (/ y1 y) c) y)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (i <= -4e+47) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else if (i <= -2.5e-210) {
tmp = (-k * fma(y, y4, (-y0 * z))) * b;
} else if (i <= 1.3e-287) {
tmp = (j * fma(y3, y5, (-b * x))) * y0;
} else if (i <= 2.35e-188) {
tmp = -y5 * (y2 * ((k * y0) - (a * t)));
} else if (i <= 2.1e+28) {
tmp = (y * fma(-1.0, (k * y4), (a * x))) * b;
} else if (i <= 1.85e+163) {
tmp = (i * z) * fma(c, t, (-k * y1));
} else {
tmp = (-i * x) * (fma(-j, (y1 / y), c) * y);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (i <= -4e+47) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); elseif (i <= -2.5e-210) tmp = Float64(Float64(Float64(-k) * fma(y, y4, Float64(Float64(-y0) * z))) * b); elseif (i <= 1.3e-287) tmp = Float64(Float64(j * fma(y3, y5, Float64(Float64(-b) * x))) * y0); elseif (i <= 2.35e-188) tmp = Float64(Float64(-y5) * Float64(y2 * Float64(Float64(k * y0) - Float64(a * t)))); elseif (i <= 2.1e+28) tmp = Float64(Float64(y * fma(-1.0, Float64(k * y4), Float64(a * x))) * b); elseif (i <= 1.85e+163) tmp = Float64(Float64(i * z) * fma(c, t, Float64(Float64(-k) * y1))); else tmp = Float64(Float64(Float64(-i) * x) * Float64(fma(Float64(-j), Float64(y1 / y), c) * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[i, -4e+47], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -2.5e-210], N[(N[((-k) * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[i, 1.3e-287], N[(N[(j * N[(y3 * y5 + N[((-b) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[i, 2.35e-188], N[((-y5) * N[(y2 * N[(N[(k * y0), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.1e+28], N[(N[(y * N[(-1.0 * N[(k * y4), $MachinePrecision] + N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[i, 1.85e+163], N[(N[(i * z), $MachinePrecision] * N[(c * t + N[((-k) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * x), $MachinePrecision] * N[(N[((-j) * N[(y1 / y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4 \cdot 10^{+47}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{elif}\;i \leq -2.5 \cdot 10^{-210}:\\
\;\;\;\;\left(\left(-k\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\right) \cdot b\\
\mathbf{elif}\;i \leq 1.3 \cdot 10^{-287}:\\
\;\;\;\;\left(j \cdot \mathsf{fma}\left(y3, y5, \left(-b\right) \cdot x\right)\right) \cdot y0\\
\mathbf{elif}\;i \leq 2.35 \cdot 10^{-188}:\\
\;\;\;\;\left(-y5\right) \cdot \left(y2 \cdot \left(k \cdot y0 - a \cdot t\right)\right)\\
\mathbf{elif}\;i \leq 2.1 \cdot 10^{+28}:\\
\;\;\;\;\left(y \cdot \mathsf{fma}\left(-1, k \cdot y4, a \cdot x\right)\right) \cdot b\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+163}:\\
\;\;\;\;\left(i \cdot z\right) \cdot \mathsf{fma}\left(c, t, \left(-k\right) \cdot y1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-i\right) \cdot x\right) \cdot \left(\mathsf{fma}\left(-j, \frac{y1}{y}, c\right) \cdot y\right)\\
\end{array}
\end{array}
if i < -4.0000000000000002e47Initial program 25.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites62.8%
Taylor expanded in k around -inf
Applied rewrites57.8%
if -4.0000000000000002e47 < i < -2.5000000000000001e-210Initial program 28.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites38.3%
Taylor expanded in k around -inf
Applied rewrites43.2%
if -2.5000000000000001e-210 < i < 1.3e-287Initial program 43.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in j around inf
Applied rewrites49.6%
if 1.3e-287 < i < 2.34999999999999999e-188Initial program 28.9%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites57.7%
Taylor expanded in y2 around inf
Applied rewrites54.1%
if 2.34999999999999999e-188 < i < 2.09999999999999989e28Initial program 28.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.2%
Taylor expanded in y around inf
Applied rewrites38.6%
if 2.09999999999999989e28 < i < 1.84999999999999996e163Initial program 31.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in z around -inf
Applied rewrites64.8%
if 1.84999999999999996e163 < i Initial program 28.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.8%
Taylor expanded in x around inf
Applied rewrites55.9%
Taylor expanded in y around inf
Applied rewrites58.6%
Final simplification51.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= i -6.3e+158)
(* (- i) (fma (fma (- t) z (* y x)) c (* (fma (- y) k (* j t)) y5)))
(if (<= i 1.2e-107)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (fma (- b) k (* y3 c)) y) y4))
(if (<= i 9.8e+89)
(* (- i) (fma c (fma x y (* (- t) z)) (* y5 (fma j t (* (- k) y)))))
(if (<= i 1.85e+163)
(* (* i z) (fma c t (* (- k) y1)))
(* (* (- i) x) (* (fma (- j) (/ y1 y) c) y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (i <= -6.3e+158) {
tmp = -i * fma(fma(-t, z, (y * x)), c, (fma(-y, k, (j * t)) * y5));
} else if (i <= 1.2e-107) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), ((fma(-b, k, (y3 * c)) * y) * y4));
} else if (i <= 9.8e+89) {
tmp = -i * fma(c, fma(x, y, (-t * z)), (y5 * fma(j, t, (-k * y))));
} else if (i <= 1.85e+163) {
tmp = (i * z) * fma(c, t, (-k * y1));
} else {
tmp = (-i * x) * (fma(-j, (y1 / y), c) * y);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (i <= -6.3e+158) tmp = Float64(Float64(-i) * fma(fma(Float64(-t), z, Float64(y * x)), c, Float64(fma(Float64(-y), k, Float64(j * t)) * y5))); elseif (i <= 1.2e-107) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(fma(Float64(-b), k, Float64(y3 * c)) * y) * y4)); elseif (i <= 9.8e+89) tmp = Float64(Float64(-i) * fma(c, fma(x, y, Float64(Float64(-t) * z)), Float64(y5 * fma(j, t, Float64(Float64(-k) * y))))); elseif (i <= 1.85e+163) tmp = Float64(Float64(i * z) * fma(c, t, Float64(Float64(-k) * y1))); else tmp = Float64(Float64(Float64(-i) * x) * Float64(fma(Float64(-j), Float64(y1 / y), c) * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[i, -6.3e+158], N[((-i) * N[(N[((-t) * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-y) * k + N[(j * t), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.2e-107], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[((-b) * k + N[(y3 * c), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 9.8e+89], N[((-i) * N[(c * N[(x * y + N[((-t) * z), $MachinePrecision]), $MachinePrecision] + N[(y5 * N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.85e+163], N[(N[(i * z), $MachinePrecision] * N[(c * t + N[((-k) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * x), $MachinePrecision] * N[(N[((-j) * N[(y1 / y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -6.3 \cdot 10^{+158}:\\
\;\;\;\;\left(-i\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(-t, z, y \cdot x\right), c, \mathsf{fma}\left(-y, k, j \cdot t\right) \cdot y5\right)\\
\mathbf{elif}\;i \leq 1.2 \cdot 10^{-107}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\mathsf{fma}\left(-b, k, y3 \cdot c\right) \cdot y\right) \cdot y4\right)\\
\mathbf{elif}\;i \leq 9.8 \cdot 10^{+89}:\\
\;\;\;\;\left(-i\right) \cdot \mathsf{fma}\left(c, \mathsf{fma}\left(x, y, \left(-t\right) \cdot z\right), y5 \cdot \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right)\right)\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+163}:\\
\;\;\;\;\left(i \cdot z\right) \cdot \mathsf{fma}\left(c, t, \left(-k\right) \cdot y1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-i\right) \cdot x\right) \cdot \left(\mathsf{fma}\left(-j, \frac{y1}{y}, c\right) \cdot y\right)\\
\end{array}
\end{array}
if i < -6.2999999999999997e158Initial program 27.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites76.1%
Taylor expanded in j around inf
Applied rewrites38.6%
Taylor expanded in x around inf
Applied rewrites12.0%
Taylor expanded in y1 around 0
Applied rewrites79.7%
if -6.2999999999999997e158 < i < 1.19999999999999997e-107Initial program 29.1%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.6%
Taylor expanded in t around inf
Applied rewrites32.9%
Taylor expanded in y around inf
Applied rewrites47.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites51.1%
if 1.19999999999999997e-107 < i < 9.79999999999999992e89Initial program 38.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.5%
Taylor expanded in k around -inf
Applied rewrites29.3%
Taylor expanded in y1 around 0
Applied rewrites48.6%
if 9.79999999999999992e89 < i < 1.84999999999999996e163Initial program 15.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.2%
Taylor expanded in z around -inf
Applied rewrites92.5%
if 1.84999999999999996e163 < i Initial program 28.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.8%
Taylor expanded in x around inf
Applied rewrites55.9%
Taylor expanded in y around inf
Applied rewrites58.6%
Final simplification57.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= i -6.8e+158)
(* (- i) (fma (fma (- t) z (* y x)) c (* (fma (- y) k (* j t)) y5)))
(if (<= i 5.5e-126)
(fma
(fma (- y5) y0 (* y4 y1))
(fma (- j) y3 (* y2 k))
(* (* (* c y) y3) y4))
(if (<= i 1.85e+37)
(* (- (* (* j y3) y5) (* (fma j x (* (- k) z)) b)) y0)
(if (<= i 1.85e+163)
(* (* i z) (fma c t (* (- k) y1)))
(* (* (- i) x) (* (fma (- j) (/ y1 y) c) y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (i <= -6.8e+158) {
tmp = -i * fma(fma(-t, z, (y * x)), c, (fma(-y, k, (j * t)) * y5));
} else if (i <= 5.5e-126) {
tmp = fma(fma(-y5, y0, (y4 * y1)), fma(-j, y3, (y2 * k)), (((c * y) * y3) * y4));
} else if (i <= 1.85e+37) {
tmp = (((j * y3) * y5) - (fma(j, x, (-k * z)) * b)) * y0;
} else if (i <= 1.85e+163) {
tmp = (i * z) * fma(c, t, (-k * y1));
} else {
tmp = (-i * x) * (fma(-j, (y1 / y), c) * y);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (i <= -6.8e+158) tmp = Float64(Float64(-i) * fma(fma(Float64(-t), z, Float64(y * x)), c, Float64(fma(Float64(-y), k, Float64(j * t)) * y5))); elseif (i <= 5.5e-126) tmp = fma(fma(Float64(-y5), y0, Float64(y4 * y1)), fma(Float64(-j), y3, Float64(y2 * k)), Float64(Float64(Float64(c * y) * y3) * y4)); elseif (i <= 1.85e+37) tmp = Float64(Float64(Float64(Float64(j * y3) * y5) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); elseif (i <= 1.85e+163) tmp = Float64(Float64(i * z) * fma(c, t, Float64(Float64(-k) * y1))); else tmp = Float64(Float64(Float64(-i) * x) * Float64(fma(Float64(-j), Float64(y1 / y), c) * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[i, -6.8e+158], N[((-i) * N[(N[((-t) * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-y) * k + N[(j * t), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 5.5e-126], N[(N[((-y5) * y0 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * N[((-j) * y3 + N[(y2 * k), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(c * y), $MachinePrecision] * y3), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.85e+37], N[(N[(N[(N[(j * y3), $MachinePrecision] * y5), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[i, 1.85e+163], N[(N[(i * z), $MachinePrecision] * N[(c * t + N[((-k) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * x), $MachinePrecision] * N[(N[((-j) * N[(y1 / y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -6.8 \cdot 10^{+158}:\\
\;\;\;\;\left(-i\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(-t, z, y \cdot x\right), c, \mathsf{fma}\left(-y, k, j \cdot t\right) \cdot y5\right)\\
\mathbf{elif}\;i \leq 5.5 \cdot 10^{-126}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y5, y0, y4 \cdot y1\right), \mathsf{fma}\left(-j, y3, y2 \cdot k\right), \left(\left(c \cdot y\right) \cdot y3\right) \cdot y4\right)\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+37}:\\
\;\;\;\;\left(\left(j \cdot y3\right) \cdot y5 - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+163}:\\
\;\;\;\;\left(i \cdot z\right) \cdot \mathsf{fma}\left(c, t, \left(-k\right) \cdot y1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-i\right) \cdot x\right) \cdot \left(\mathsf{fma}\left(-j, \frac{y1}{y}, c\right) \cdot y\right)\\
\end{array}
\end{array}
if i < -6.7999999999999998e158Initial program 27.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites76.1%
Taylor expanded in j around inf
Applied rewrites38.6%
Taylor expanded in x around inf
Applied rewrites12.0%
Taylor expanded in y1 around 0
Applied rewrites79.7%
if -6.7999999999999998e158 < i < 5.49999999999999987e-126Initial program 29.3%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites38.9%
Taylor expanded in t around inf
Applied rewrites32.6%
Taylor expanded in y3 around inf
Applied rewrites46.6%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites49.7%
if 5.49999999999999987e-126 < i < 1.85e37Initial program 34.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.1%
Taylor expanded in j around inf
Applied rewrites49.4%
if 1.85e37 < i < 1.84999999999999996e163Initial program 27.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.5%
Taylor expanded in z around -inf
Applied rewrites69.0%
if 1.84999999999999996e163 < i Initial program 28.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.8%
Taylor expanded in x around inf
Applied rewrites55.9%
Taylor expanded in y around inf
Applied rewrites58.6%
Final simplification56.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.55e+116)
(* (- y3) (* (- a) (fma y1 z (* (- y) y5))))
(if (<= y1 7.5e-186)
(* (- i) (fma (fma (- t) z (* y x)) c (* (fma (- y) k (* j t)) y5)))
(if (<= y1 23000000000000.0)
(* (- y3) (* c (fma y0 z (* (- y) y4))))
(if (<= y1 5.2e+225)
(* (- (* (* j y3) y5) (* (fma j x (* (- k) z)) b)) y0)
(* (* y1 (fma y4 (- j) (* z a))) y3))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.55e+116) {
tmp = -y3 * (-a * fma(y1, z, (-y * y5)));
} else if (y1 <= 7.5e-186) {
tmp = -i * fma(fma(-t, z, (y * x)), c, (fma(-y, k, (j * t)) * y5));
} else if (y1 <= 23000000000000.0) {
tmp = -y3 * (c * fma(y0, z, (-y * y4)));
} else if (y1 <= 5.2e+225) {
tmp = (((j * y3) * y5) - (fma(j, x, (-k * z)) * b)) * y0;
} else {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.55e+116) tmp = Float64(Float64(-y3) * Float64(Float64(-a) * fma(y1, z, Float64(Float64(-y) * y5)))); elseif (y1 <= 7.5e-186) tmp = Float64(Float64(-i) * fma(fma(Float64(-t), z, Float64(y * x)), c, Float64(fma(Float64(-y), k, Float64(j * t)) * y5))); elseif (y1 <= 23000000000000.0) tmp = Float64(Float64(-y3) * Float64(c * fma(y0, z, Float64(Float64(-y) * y4)))); elseif (y1 <= 5.2e+225) tmp = Float64(Float64(Float64(Float64(j * y3) * y5) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); else tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.55e+116], N[((-y3) * N[((-a) * N[(y1 * z + N[((-y) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 7.5e-186], N[((-i) * N[(N[((-t) * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-y) * k + N[(j * t), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 23000000000000.0], N[((-y3) * N[(c * N[(y0 * z + N[((-y) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 5.2e+225], N[(N[(N[(N[(j * y3), $MachinePrecision] * y5), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.55 \cdot 10^{+116}:\\
\;\;\;\;\left(-y3\right) \cdot \left(\left(-a\right) \cdot \mathsf{fma}\left(y1, z, \left(-y\right) \cdot y5\right)\right)\\
\mathbf{elif}\;y1 \leq 7.5 \cdot 10^{-186}:\\
\;\;\;\;\left(-i\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(-t, z, y \cdot x\right), c, \mathsf{fma}\left(-y, k, j \cdot t\right) \cdot y5\right)\\
\mathbf{elif}\;y1 \leq 23000000000000:\\
\;\;\;\;\left(-y3\right) \cdot \left(c \cdot \mathsf{fma}\left(y0, z, \left(-y\right) \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 5.2 \cdot 10^{+225}:\\
\;\;\;\;\left(\left(j \cdot y3\right) \cdot y5 - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{else}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\end{array}
\end{array}
if y1 < -1.54999999999999998e116Initial program 24.4%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.4%
Taylor expanded in a around -inf
Applied rewrites50.0%
if -1.54999999999999998e116 < y1 < 7.50000000000000076e-186Initial program 32.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites53.2%
Taylor expanded in j around inf
Applied rewrites25.1%
Taylor expanded in x around inf
Applied rewrites13.5%
Taylor expanded in y1 around 0
Applied rewrites51.7%
if 7.50000000000000076e-186 < y1 < 2.3e13Initial program 25.6%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.1%
Taylor expanded in c around inf
Applied rewrites56.8%
if 2.3e13 < y1 < 5.20000000000000009e225Initial program 27.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.7%
Taylor expanded in j around inf
Applied rewrites39.8%
if 5.20000000000000009e225 < y1 Initial program 36.4%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in y1 around -inf
Applied rewrites60.4%
Applied rewrites68.7%
Final simplification51.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.55e+116)
(* (- y3) (* (- a) (fma y1 z (* (- y) y5))))
(if (<= y1 7.5e-186)
(* (- i) (fma c (fma x y (* (- t) z)) (* y5 (fma j t (* (- k) y)))))
(if (<= y1 23000000000000.0)
(* (- y3) (* c (fma y0 z (* (- y) y4))))
(if (<= y1 5.2e+225)
(* (- (* (* j y3) y5) (* (fma j x (* (- k) z)) b)) y0)
(* (* y1 (fma y4 (- j) (* z a))) y3))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.55e+116) {
tmp = -y3 * (-a * fma(y1, z, (-y * y5)));
} else if (y1 <= 7.5e-186) {
tmp = -i * fma(c, fma(x, y, (-t * z)), (y5 * fma(j, t, (-k * y))));
} else if (y1 <= 23000000000000.0) {
tmp = -y3 * (c * fma(y0, z, (-y * y4)));
} else if (y1 <= 5.2e+225) {
tmp = (((j * y3) * y5) - (fma(j, x, (-k * z)) * b)) * y0;
} else {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.55e+116) tmp = Float64(Float64(-y3) * Float64(Float64(-a) * fma(y1, z, Float64(Float64(-y) * y5)))); elseif (y1 <= 7.5e-186) tmp = Float64(Float64(-i) * fma(c, fma(x, y, Float64(Float64(-t) * z)), Float64(y5 * fma(j, t, Float64(Float64(-k) * y))))); elseif (y1 <= 23000000000000.0) tmp = Float64(Float64(-y3) * Float64(c * fma(y0, z, Float64(Float64(-y) * y4)))); elseif (y1 <= 5.2e+225) tmp = Float64(Float64(Float64(Float64(j * y3) * y5) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); else tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.55e+116], N[((-y3) * N[((-a) * N[(y1 * z + N[((-y) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 7.5e-186], N[((-i) * N[(c * N[(x * y + N[((-t) * z), $MachinePrecision]), $MachinePrecision] + N[(y5 * N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 23000000000000.0], N[((-y3) * N[(c * N[(y0 * z + N[((-y) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 5.2e+225], N[(N[(N[(N[(j * y3), $MachinePrecision] * y5), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.55 \cdot 10^{+116}:\\
\;\;\;\;\left(-y3\right) \cdot \left(\left(-a\right) \cdot \mathsf{fma}\left(y1, z, \left(-y\right) \cdot y5\right)\right)\\
\mathbf{elif}\;y1 \leq 7.5 \cdot 10^{-186}:\\
\;\;\;\;\left(-i\right) \cdot \mathsf{fma}\left(c, \mathsf{fma}\left(x, y, \left(-t\right) \cdot z\right), y5 \cdot \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right)\right)\\
\mathbf{elif}\;y1 \leq 23000000000000:\\
\;\;\;\;\left(-y3\right) \cdot \left(c \cdot \mathsf{fma}\left(y0, z, \left(-y\right) \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 5.2 \cdot 10^{+225}:\\
\;\;\;\;\left(\left(j \cdot y3\right) \cdot y5 - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{else}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\end{array}
\end{array}
if y1 < -1.54999999999999998e116Initial program 24.4%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.4%
Taylor expanded in a around -inf
Applied rewrites50.0%
if -1.54999999999999998e116 < y1 < 7.50000000000000076e-186Initial program 32.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites53.2%
Taylor expanded in k around -inf
Applied rewrites27.7%
Taylor expanded in y1 around 0
Applied rewrites50.8%
if 7.50000000000000076e-186 < y1 < 2.3e13Initial program 25.6%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.1%
Taylor expanded in c around inf
Applied rewrites56.8%
if 2.3e13 < y1 < 5.20000000000000009e225Initial program 27.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.7%
Taylor expanded in j around inf
Applied rewrites39.8%
if 5.20000000000000009e225 < y1 Initial program 36.4%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in y1 around -inf
Applied rewrites60.4%
Applied rewrites68.7%
Final simplification50.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= i -4e+47)
(* (* i k) (fma y y5 (* (- y1) z)))
(if (<= i -1.1e-195)
(* (* (- k) (fma y y4 (* (- y0) z))) b)
(if (<= i 1.85e+37)
(* (- (* (* j y3) y5) (* (fma j x (* (- k) z)) b)) y0)
(if (<= i 1.85e+163)
(* (* i z) (fma c t (* (- k) y1)))
(* (* (- i) x) (* (fma (- j) (/ y1 y) c) y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (i <= -4e+47) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else if (i <= -1.1e-195) {
tmp = (-k * fma(y, y4, (-y0 * z))) * b;
} else if (i <= 1.85e+37) {
tmp = (((j * y3) * y5) - (fma(j, x, (-k * z)) * b)) * y0;
} else if (i <= 1.85e+163) {
tmp = (i * z) * fma(c, t, (-k * y1));
} else {
tmp = (-i * x) * (fma(-j, (y1 / y), c) * y);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (i <= -4e+47) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); elseif (i <= -1.1e-195) tmp = Float64(Float64(Float64(-k) * fma(y, y4, Float64(Float64(-y0) * z))) * b); elseif (i <= 1.85e+37) tmp = Float64(Float64(Float64(Float64(j * y3) * y5) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); elseif (i <= 1.85e+163) tmp = Float64(Float64(i * z) * fma(c, t, Float64(Float64(-k) * y1))); else tmp = Float64(Float64(Float64(-i) * x) * Float64(fma(Float64(-j), Float64(y1 / y), c) * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[i, -4e+47], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.1e-195], N[(N[((-k) * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[i, 1.85e+37], N[(N[(N[(N[(j * y3), $MachinePrecision] * y5), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[i, 1.85e+163], N[(N[(i * z), $MachinePrecision] * N[(c * t + N[((-k) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * x), $MachinePrecision] * N[(N[((-j) * N[(y1 / y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4 \cdot 10^{+47}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{elif}\;i \leq -1.1 \cdot 10^{-195}:\\
\;\;\;\;\left(\left(-k\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\right) \cdot b\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+37}:\\
\;\;\;\;\left(\left(j \cdot y3\right) \cdot y5 - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{elif}\;i \leq 1.85 \cdot 10^{+163}:\\
\;\;\;\;\left(i \cdot z\right) \cdot \mathsf{fma}\left(c, t, \left(-k\right) \cdot y1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-i\right) \cdot x\right) \cdot \left(\mathsf{fma}\left(-j, \frac{y1}{y}, c\right) \cdot y\right)\\
\end{array}
\end{array}
if i < -4.0000000000000002e47Initial program 25.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites62.8%
Taylor expanded in k around -inf
Applied rewrites57.8%
if -4.0000000000000002e47 < i < -1.10000000000000003e-195Initial program 30.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites38.5%
Taylor expanded in k around -inf
Applied rewrites43.7%
if -1.10000000000000003e-195 < i < 1.85e37Initial program 32.6%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.8%
Taylor expanded in j around inf
Applied rewrites39.6%
if 1.85e37 < i < 1.84999999999999996e163Initial program 27.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.5%
Taylor expanded in z around -inf
Applied rewrites69.0%
if 1.84999999999999996e163 < i Initial program 28.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.8%
Taylor expanded in x around inf
Applied rewrites55.9%
Taylor expanded in y around inf
Applied rewrites58.6%
Final simplification49.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* j (fma y3 y5 (* (- b) x))) y0)))
(if (<= j -1.12e+176)
t_1
(if (<= j -3e+79)
(* (- c) (* i (fma x y (* (- t) z))))
(if (<= j -1.3e-97)
(* (* k y5) (fma i y (* (- y0) y2)))
(if (<= j -1.1e-289)
(* (* c y0) (fma (- y3) z (* x y2)))
(if (<= j 2100000000.0)
(* (* i k) (fma y y5 (* (- y1) z)))
(if (<= j 1.12e+84) (* (* (fma (- j) y5 (* c z)) t) i) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (j * fma(y3, y5, (-b * x))) * y0;
double tmp;
if (j <= -1.12e+176) {
tmp = t_1;
} else if (j <= -3e+79) {
tmp = -c * (i * fma(x, y, (-t * z)));
} else if (j <= -1.3e-97) {
tmp = (k * y5) * fma(i, y, (-y0 * y2));
} else if (j <= -1.1e-289) {
tmp = (c * y0) * fma(-y3, z, (x * y2));
} else if (j <= 2100000000.0) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else if (j <= 1.12e+84) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(j * fma(y3, y5, Float64(Float64(-b) * x))) * y0) tmp = 0.0 if (j <= -1.12e+176) tmp = t_1; elseif (j <= -3e+79) tmp = Float64(Float64(-c) * Float64(i * fma(x, y, Float64(Float64(-t) * z)))); elseif (j <= -1.3e-97) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(Float64(-y0) * y2))); elseif (j <= -1.1e-289) tmp = Float64(Float64(c * y0) * fma(Float64(-y3), z, Float64(x * y2))); elseif (j <= 2100000000.0) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); elseif (j <= 1.12e+84) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(j * N[(y3 * y5 + N[((-b) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]}, If[LessEqual[j, -1.12e+176], t$95$1, If[LessEqual[j, -3e+79], N[((-c) * N[(i * N[(x * y + N[((-t) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -1.3e-97], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[((-y0) * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -1.1e-289], N[(N[(c * y0), $MachinePrecision] * N[((-y3) * z + N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2100000000.0], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.12e+84], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(j \cdot \mathsf{fma}\left(y3, y5, \left(-b\right) \cdot x\right)\right) \cdot y0\\
\mathbf{if}\;j \leq -1.12 \cdot 10^{+176}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -3 \cdot 10^{+79}:\\
\;\;\;\;\left(-c\right) \cdot \left(i \cdot \mathsf{fma}\left(x, y, \left(-t\right) \cdot z\right)\right)\\
\mathbf{elif}\;j \leq -1.3 \cdot 10^{-97}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, \left(-y0\right) \cdot y2\right)\\
\mathbf{elif}\;j \leq -1.1 \cdot 10^{-289}:\\
\;\;\;\;\left(c \cdot y0\right) \cdot \mathsf{fma}\left(-y3, z, x \cdot y2\right)\\
\mathbf{elif}\;j \leq 2100000000:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{elif}\;j \leq 1.12 \cdot 10^{+84}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.12e176 or 1.12e84 < j Initial program 23.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.1%
Taylor expanded in j around inf
Applied rewrites56.8%
if -1.12e176 < j < -2.99999999999999974e79Initial program 22.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites55.6%
Taylor expanded in k around -inf
Applied rewrites34.0%
Taylor expanded in c around inf
Applied rewrites56.1%
if -2.99999999999999974e79 < j < -1.30000000000000003e-97Initial program 26.4%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.4%
Taylor expanded in k around -inf
Applied rewrites46.2%
if -1.30000000000000003e-97 < j < -1.1e-289Initial program 34.6%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.3%
Taylor expanded in c around inf
Applied rewrites54.5%
if -1.1e-289 < j < 2.1e9Initial program 37.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.9%
Taylor expanded in k around -inf
Applied rewrites36.3%
if 2.1e9 < j < 1.12e84Initial program 31.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites62.8%
Taylor expanded in k around -inf
Applied rewrites20.1%
Taylor expanded in t around -inf
Applied rewrites57.7%
Applied rewrites63.7%
Final simplification50.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma (- j) y5 (* c z)) t) i))
(t_2 (* (* j (fma y3 y5 (* (- b) x))) y0)))
(if (<= j -2.1e+176)
t_2
(if (<= j -3e+79)
t_1
(if (<= j -1.3e-97)
(* (* k y5) (fma i y (* (- y0) y2)))
(if (<= j -1.1e-289)
(* (* c y0) (fma (- y3) z (* x y2)))
(if (<= j 2100000000.0)
(* (* i k) (fma y y5 (* (- y1) z)))
(if (<= j 1.12e+84) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(-j, y5, (c * z)) * t) * i;
double t_2 = (j * fma(y3, y5, (-b * x))) * y0;
double tmp;
if (j <= -2.1e+176) {
tmp = t_2;
} else if (j <= -3e+79) {
tmp = t_1;
} else if (j <= -1.3e-97) {
tmp = (k * y5) * fma(i, y, (-y0 * y2));
} else if (j <= -1.1e-289) {
tmp = (c * y0) * fma(-y3, z, (x * y2));
} else if (j <= 2100000000.0) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else if (j <= 1.12e+84) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i) t_2 = Float64(Float64(j * fma(y3, y5, Float64(Float64(-b) * x))) * y0) tmp = 0.0 if (j <= -2.1e+176) tmp = t_2; elseif (j <= -3e+79) tmp = t_1; elseif (j <= -1.3e-97) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(Float64(-y0) * y2))); elseif (j <= -1.1e-289) tmp = Float64(Float64(c * y0) * fma(Float64(-y3), z, Float64(x * y2))); elseif (j <= 2100000000.0) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); elseif (j <= 1.12e+84) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * N[(y3 * y5 + N[((-b) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]}, If[LessEqual[j, -2.1e+176], t$95$2, If[LessEqual[j, -3e+79], t$95$1, If[LessEqual[j, -1.3e-97], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[((-y0) * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -1.1e-289], N[(N[(c * y0), $MachinePrecision] * N[((-y3) * z + N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2100000000.0], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.12e+84], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
t_2 := \left(j \cdot \mathsf{fma}\left(y3, y5, \left(-b\right) \cdot x\right)\right) \cdot y0\\
\mathbf{if}\;j \leq -2.1 \cdot 10^{+176}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -3 \cdot 10^{+79}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -1.3 \cdot 10^{-97}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, \left(-y0\right) \cdot y2\right)\\
\mathbf{elif}\;j \leq -1.1 \cdot 10^{-289}:\\
\;\;\;\;\left(c \cdot y0\right) \cdot \mathsf{fma}\left(-y3, z, x \cdot y2\right)\\
\mathbf{elif}\;j \leq 2100000000:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{elif}\;j \leq 1.12 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -2.0999999999999999e176 or 1.12e84 < j Initial program 23.4%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.1%
Taylor expanded in j around inf
Applied rewrites56.8%
if -2.0999999999999999e176 < j < -2.99999999999999974e79 or 2.1e9 < j < 1.12e84Initial program 26.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites59.0%
Taylor expanded in k around -inf
Applied rewrites27.5%
Taylor expanded in t around -inf
Applied rewrites56.7%
Applied rewrites59.6%
if -2.99999999999999974e79 < j < -1.30000000000000003e-97Initial program 26.4%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.4%
Taylor expanded in k around -inf
Applied rewrites46.2%
if -1.30000000000000003e-97 < j < -1.1e-289Initial program 34.6%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.3%
Taylor expanded in c around inf
Applied rewrites54.5%
if -1.1e-289 < j < 2.1e9Initial program 37.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.9%
Taylor expanded in k around -inf
Applied rewrites36.3%
Final simplification50.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -1.68e+38)
(* (* (- k) y0) (fma y2 y5 (* (- b) z)))
(if (<= k -3.6e-78)
(* (- y3) (* (- y5) (fma j y0 (* (- a) y))))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 3.25e+109)
(* (* y1 (fma y4 (- j) (* z a))) y3)
(if (<= k 2.6e+184)
(* (* (- k) (fma y y4 (* (- y0) z))) b)
(* (* i k) (fma y y5 (* (- y1) z)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -1.68e+38) {
tmp = (-k * y0) * fma(y2, y5, (-b * z));
} else if (k <= -3.6e-78) {
tmp = -y3 * (-y5 * fma(j, y0, (-a * y)));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 3.25e+109) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else if (k <= 2.6e+184) {
tmp = (-k * fma(y, y4, (-y0 * z))) * b;
} else {
tmp = (i * k) * fma(y, y5, (-y1 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -1.68e+38) tmp = Float64(Float64(Float64(-k) * y0) * fma(y2, y5, Float64(Float64(-b) * z))); elseif (k <= -3.6e-78) tmp = Float64(Float64(-y3) * Float64(Float64(-y5) * fma(j, y0, Float64(Float64(-a) * y)))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 3.25e+109) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); elseif (k <= 2.6e+184) tmp = Float64(Float64(Float64(-k) * fma(y, y4, Float64(Float64(-y0) * z))) * b); else tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -1.68e+38], N[(N[((-k) * y0), $MachinePrecision] * N[(y2 * y5 + N[((-b) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -3.6e-78], N[((-y3) * N[((-y5) * N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 3.25e+109], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[k, 2.6e+184], N[(N[((-k) * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.68 \cdot 10^{+38}:\\
\;\;\;\;\left(\left(-k\right) \cdot y0\right) \cdot \mathsf{fma}\left(y2, y5, \left(-b\right) \cdot z\right)\\
\mathbf{elif}\;k \leq -3.6 \cdot 10^{-78}:\\
\;\;\;\;\left(-y3\right) \cdot \left(\left(-y5\right) \cdot \mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right)\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 3.25 \cdot 10^{+109}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{elif}\;k \leq 2.6 \cdot 10^{+184}:\\
\;\;\;\;\left(\left(-k\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\end{array}
\end{array}
if k < -1.6800000000000001e38Initial program 24.1%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.7%
Taylor expanded in k around -inf
Applied rewrites55.2%
if -1.6800000000000001e38 < k < -3.6000000000000002e-78Initial program 22.2%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.1%
Taylor expanded in y5 around -inf
Applied rewrites46.4%
if -3.6000000000000002e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 3.25e109Initial program 38.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.3%
Taylor expanded in y1 around -inf
Applied rewrites33.8%
Applied rewrites37.1%
if 3.25e109 < k < 2.59999999999999993e184Initial program 30.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in k around -inf
Applied rewrites54.8%
if 2.59999999999999993e184 < k Initial program 10.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites57.1%
Taylor expanded in k around -inf
Applied rewrites65.6%
Final simplification49.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -1.42e+25)
(* (* (- k) y0) (fma y2 y5 (* (- b) z)))
(if (<= k -6.2e-78)
(* (* (- y3) y4) (fma j y1 (* (- c) y)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 3.25e+109)
(* (* y1 (fma y4 (- j) (* z a))) y3)
(if (<= k 2.6e+184)
(* (* (- k) (fma y y4 (* (- y0) z))) b)
(* (* i k) (fma y y5 (* (- y1) z)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -1.42e+25) {
tmp = (-k * y0) * fma(y2, y5, (-b * z));
} else if (k <= -6.2e-78) {
tmp = (-y3 * y4) * fma(j, y1, (-c * y));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 3.25e+109) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else if (k <= 2.6e+184) {
tmp = (-k * fma(y, y4, (-y0 * z))) * b;
} else {
tmp = (i * k) * fma(y, y5, (-y1 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -1.42e+25) tmp = Float64(Float64(Float64(-k) * y0) * fma(y2, y5, Float64(Float64(-b) * z))); elseif (k <= -6.2e-78) tmp = Float64(Float64(Float64(-y3) * y4) * fma(j, y1, Float64(Float64(-c) * y))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 3.25e+109) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); elseif (k <= 2.6e+184) tmp = Float64(Float64(Float64(-k) * fma(y, y4, Float64(Float64(-y0) * z))) * b); else tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -1.42e+25], N[(N[((-k) * y0), $MachinePrecision] * N[(y2 * y5 + N[((-b) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -6.2e-78], N[(N[((-y3) * y4), $MachinePrecision] * N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 3.25e+109], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[k, 2.6e+184], N[(N[((-k) * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.42 \cdot 10^{+25}:\\
\;\;\;\;\left(\left(-k\right) \cdot y0\right) \cdot \mathsf{fma}\left(y2, y5, \left(-b\right) \cdot z\right)\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(\left(-y3\right) \cdot y4\right) \cdot \mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 3.25 \cdot 10^{+109}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{elif}\;k \leq 2.6 \cdot 10^{+184}:\\
\;\;\;\;\left(\left(-k\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\end{array}
\end{array}
if k < -1.4199999999999999e25Initial program 24.3%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.1%
Taylor expanded in k around -inf
Applied rewrites51.1%
if -1.4199999999999999e25 < k < -6.20000000000000035e-78Initial program 21.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.0%
Taylor expanded in y4 around inf
Applied rewrites53.5%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 3.25e109Initial program 38.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites49.3%
Taylor expanded in y1 around -inf
Applied rewrites33.8%
Applied rewrites37.1%
if 3.25e109 < k < 2.59999999999999993e184Initial program 30.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in k around -inf
Applied rewrites54.8%
if 2.59999999999999993e184 < k Initial program 10.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites57.1%
Taylor expanded in k around -inf
Applied rewrites65.6%
Final simplification49.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -1.42e+25)
(* (* (- k) y0) (fma y2 y5 (* (- b) z)))
(if (<= k -6.2e-78)
(* (* (- y3) y4) (fma j y1 (* (- c) y)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 1.75e-17)
(* (* y1 (fma y4 (- j) (* z a))) y3)
(* (* i k) (fma y y5 (* (- y1) z))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -1.42e+25) {
tmp = (-k * y0) * fma(y2, y5, (-b * z));
} else if (k <= -6.2e-78) {
tmp = (-y3 * y4) * fma(j, y1, (-c * y));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 1.75e-17) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else {
tmp = (i * k) * fma(y, y5, (-y1 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -1.42e+25) tmp = Float64(Float64(Float64(-k) * y0) * fma(y2, y5, Float64(Float64(-b) * z))); elseif (k <= -6.2e-78) tmp = Float64(Float64(Float64(-y3) * y4) * fma(j, y1, Float64(Float64(-c) * y))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 1.75e-17) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); else tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -1.42e+25], N[(N[((-k) * y0), $MachinePrecision] * N[(y2 * y5 + N[((-b) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -6.2e-78], N[(N[((-y3) * y4), $MachinePrecision] * N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 1.75e-17], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.42 \cdot 10^{+25}:\\
\;\;\;\;\left(\left(-k\right) \cdot y0\right) \cdot \mathsf{fma}\left(y2, y5, \left(-b\right) \cdot z\right)\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(\left(-y3\right) \cdot y4\right) \cdot \mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 1.75 \cdot 10^{-17}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\end{array}
\end{array}
if k < -1.4199999999999999e25Initial program 24.3%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.1%
Taylor expanded in k around -inf
Applied rewrites51.1%
if -1.4199999999999999e25 < k < -6.20000000000000035e-78Initial program 21.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.0%
Taylor expanded in y4 around inf
Applied rewrites53.5%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 1.7500000000000001e-17Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.9%
Taylor expanded in y1 around -inf
Applied rewrites37.1%
Applied rewrites40.1%
if 1.7500000000000001e-17 < k Initial program 23.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.3%
Taylor expanded in k around -inf
Applied rewrites45.9%
Final simplification47.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* i k) (fma y y5 (* (- y1) z)))))
(if (<= k -2.55e+25)
t_1
(if (<= k -6.2e-78)
(* (* (- y3) y4) (fma j y1 (* (- c) y)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 1.75e-17) (* (* y1 (fma y4 (- j) (* z a))) y3) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (i * k) * fma(y, y5, (-y1 * z));
double tmp;
if (k <= -2.55e+25) {
tmp = t_1;
} else if (k <= -6.2e-78) {
tmp = (-y3 * y4) * fma(j, y1, (-c * y));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 1.75e-17) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))) tmp = 0.0 if (k <= -2.55e+25) tmp = t_1; elseif (k <= -6.2e-78) tmp = Float64(Float64(Float64(-y3) * y4) * fma(j, y1, Float64(Float64(-c) * y))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 1.75e-17) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -2.55e+25], t$95$1, If[LessEqual[k, -6.2e-78], N[(N[((-y3) * y4), $MachinePrecision] * N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 1.75e-17], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{if}\;k \leq -2.55 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(\left(-y3\right) \cdot y4\right) \cdot \mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 1.75 \cdot 10^{-17}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -2.5500000000000002e25 or 1.7500000000000001e-17 < k Initial program 24.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in k around -inf
Applied rewrites46.5%
if -2.5500000000000002e25 < k < -6.20000000000000035e-78Initial program 21.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.0%
Taylor expanded in y4 around inf
Applied rewrites53.5%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 1.7500000000000001e-17Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.9%
Taylor expanded in y1 around -inf
Applied rewrites37.1%
Applied rewrites40.1%
Final simplification47.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -1.5e+78)
(* (* k y5) (fma i y (* (- y0) y2)))
(if (<= k -6.2e-78)
(* (* y3 y5) (fma j y0 (* (- a) y)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 1.75e-17)
(* (* y1 (fma y4 (- j) (* z a))) y3)
(* (* i k) (fma y y5 (* (- y1) z))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -1.5e+78) {
tmp = (k * y5) * fma(i, y, (-y0 * y2));
} else if (k <= -6.2e-78) {
tmp = (y3 * y5) * fma(j, y0, (-a * y));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 1.75e-17) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else {
tmp = (i * k) * fma(y, y5, (-y1 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -1.5e+78) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(Float64(-y0) * y2))); elseif (k <= -6.2e-78) tmp = Float64(Float64(y3 * y5) * fma(j, y0, Float64(Float64(-a) * y))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 1.75e-17) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); else tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -1.5e+78], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[((-y0) * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -6.2e-78], N[(N[(y3 * y5), $MachinePrecision] * N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 1.75e-17], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.5 \cdot 10^{+78}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, \left(-y0\right) \cdot y2\right)\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(y3 \cdot y5\right) \cdot \mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 1.75 \cdot 10^{-17}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\end{array}
\end{array}
if k < -1.49999999999999991e78Initial program 18.9%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites43.5%
Taylor expanded in k around -inf
Applied rewrites60.0%
if -1.49999999999999991e78 < k < -6.20000000000000035e-78Initial program 28.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites42.9%
Taylor expanded in y5 around -inf
Applied rewrites35.6%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 1.7500000000000001e-17Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.9%
Taylor expanded in y1 around -inf
Applied rewrites37.1%
Applied rewrites40.1%
if 1.7500000000000001e-17 < k Initial program 23.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.3%
Taylor expanded in k around -inf
Applied rewrites45.9%
Final simplification46.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* i k) (fma y y5 (* (- y1) z)))))
(if (<= k -2.8e+39)
t_1
(if (<= k -6.2e-78)
(* (* y3 y5) (fma j y0 (* (- a) y)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 1.75e-17) (* (* y1 (fma y4 (- j) (* z a))) y3) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (i * k) * fma(y, y5, (-y1 * z));
double tmp;
if (k <= -2.8e+39) {
tmp = t_1;
} else if (k <= -6.2e-78) {
tmp = (y3 * y5) * fma(j, y0, (-a * y));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 1.75e-17) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))) tmp = 0.0 if (k <= -2.8e+39) tmp = t_1; elseif (k <= -6.2e-78) tmp = Float64(Float64(y3 * y5) * fma(j, y0, Float64(Float64(-a) * y))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 1.75e-17) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -2.8e+39], t$95$1, If[LessEqual[k, -6.2e-78], N[(N[(y3 * y5), $MachinePrecision] * N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 1.75e-17], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{if}\;k \leq -2.8 \cdot 10^{+39}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(y3 \cdot y5\right) \cdot \mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 1.75 \cdot 10^{-17}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -2.80000000000000001e39 or 1.7500000000000001e-17 < k Initial program 24.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.7%
Taylor expanded in k around -inf
Applied rewrites47.3%
if -2.80000000000000001e39 < k < -6.20000000000000035e-78Initial program 21.4%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.4%
Taylor expanded in y5 around -inf
Applied rewrites41.4%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 1.7500000000000001e-17Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.9%
Taylor expanded in y1 around -inf
Applied rewrites37.1%
Applied rewrites40.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* i k) (fma y y5 (* (- y1) z)))))
(if (<= k -8.5e+33)
t_1
(if (<= k -6.2e-78)
(* (* a y3) (fma y1 z (* (- y) y5)))
(if (<= k -1.6e-292)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 1.75e-17) (* (* y1 (fma y4 (- j) (* z a))) y3) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (i * k) * fma(y, y5, (-y1 * z));
double tmp;
if (k <= -8.5e+33) {
tmp = t_1;
} else if (k <= -6.2e-78) {
tmp = (a * y3) * fma(y1, z, (-y * y5));
} else if (k <= -1.6e-292) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 1.75e-17) {
tmp = (y1 * fma(y4, -j, (z * a))) * y3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))) tmp = 0.0 if (k <= -8.5e+33) tmp = t_1; elseif (k <= -6.2e-78) tmp = Float64(Float64(a * y3) * fma(y1, z, Float64(Float64(-y) * y5))); elseif (k <= -1.6e-292) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 1.75e-17) tmp = Float64(Float64(y1 * fma(y4, Float64(-j), Float64(z * a))) * y3); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -8.5e+33], t$95$1, If[LessEqual[k, -6.2e-78], N[(N[(a * y3), $MachinePrecision] * N[(y1 * z + N[((-y) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1.6e-292], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 1.75e-17], N[(N[(y1 * N[(y4 * (-j) + N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{if}\;k \leq -8.5 \cdot 10^{+33}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;\left(a \cdot y3\right) \cdot \mathsf{fma}\left(y1, z, \left(-y\right) \cdot y5\right)\\
\mathbf{elif}\;k \leq -1.6 \cdot 10^{-292}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 1.75 \cdot 10^{-17}:\\
\;\;\;\;\left(y1 \cdot \mathsf{fma}\left(y4, -j, z \cdot a\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -8.4999999999999998e33 or 1.7500000000000001e-17 < k Initial program 25.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.1%
Taylor expanded in k around -inf
Applied rewrites47.8%
if -8.4999999999999998e33 < k < -6.20000000000000035e-78Initial program 16.0%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.1%
Taylor expanded in a around -inf
Applied rewrites34.7%
if -6.20000000000000035e-78 < k < -1.6000000000000001e-292Initial program 33.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites56.3%
Taylor expanded in k around -inf
Applied rewrites10.3%
Taylor expanded in t around -inf
Applied rewrites47.5%
Applied rewrites56.1%
if -1.6000000000000001e-292 < k < 1.7500000000000001e-17Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.9%
Taylor expanded in y1 around -inf
Applied rewrites37.1%
Applied rewrites40.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* a y3) (fma y1 z (* (- y) y5))))
(t_2 (* (* i k) (fma y y5 (* (- y1) z)))))
(if (<= k -8.5e+33)
t_2
(if (<= k -6.2e-78)
t_1
(if (<= k -2.3e-297)
(* (* (fma (- j) y5 (* c z)) t) i)
(if (<= k 6800.0) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (a * y3) * fma(y1, z, (-y * y5));
double t_2 = (i * k) * fma(y, y5, (-y1 * z));
double tmp;
if (k <= -8.5e+33) {
tmp = t_2;
} else if (k <= -6.2e-78) {
tmp = t_1;
} else if (k <= -2.3e-297) {
tmp = (fma(-j, y5, (c * z)) * t) * i;
} else if (k <= 6800.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(a * y3) * fma(y1, z, Float64(Float64(-y) * y5))) t_2 = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))) tmp = 0.0 if (k <= -8.5e+33) tmp = t_2; elseif (k <= -6.2e-78) tmp = t_1; elseif (k <= -2.3e-297) tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); elseif (k <= 6800.0) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(a * y3), $MachinePrecision] * N[(y1 * z + N[((-y) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -8.5e+33], t$95$2, If[LessEqual[k, -6.2e-78], t$95$1, If[LessEqual[k, -2.3e-297], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[k, 6800.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot y3\right) \cdot \mathsf{fma}\left(y1, z, \left(-y\right) \cdot y5\right)\\
t_2 := \left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{if}\;k \leq -8.5 \cdot 10^{+33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -2.3 \cdot 10^{-297}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\mathbf{elif}\;k \leq 6800:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if k < -8.4999999999999998e33 or 6800 < k Initial program 25.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.8%
Taylor expanded in k around -inf
Applied rewrites48.6%
if -8.4999999999999998e33 < k < -6.20000000000000035e-78 or -2.2999999999999999e-297 < k < 6800Initial program 33.2%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.6%
Taylor expanded in a around -inf
Applied rewrites34.7%
if -6.20000000000000035e-78 < k < -2.2999999999999999e-297Initial program 33.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites54.9%
Taylor expanded in k around -inf
Applied rewrites9.9%
Taylor expanded in t around -inf
Applied rewrites44.9%
Applied rewrites54.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* i k) (fma y y5 (* (- y1) z)))))
(if (<= k -2.3e+35)
t_1
(if (<= k -6.2e-268)
(* j (* i (fma x y1 (* (- t) y5))))
(if (<= k 3e-16) (* y1 (* (* a y3) z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (i * k) * fma(y, y5, (-y1 * z));
double tmp;
if (k <= -2.3e+35) {
tmp = t_1;
} else if (k <= -6.2e-268) {
tmp = j * (i * fma(x, y1, (-t * y5)));
} else if (k <= 3e-16) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))) tmp = 0.0 if (k <= -2.3e+35) tmp = t_1; elseif (k <= -6.2e-268) tmp = Float64(j * Float64(i * fma(x, y1, Float64(Float64(-t) * y5)))); elseif (k <= 3e-16) tmp = Float64(y1 * Float64(Float64(a * y3) * z)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -2.3e+35], t$95$1, If[LessEqual[k, -6.2e-268], N[(j * N[(i * N[(x * y1 + N[((-t) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3e-16], N[(y1 * N[(N[(a * y3), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{if}\;k \leq -2.3 \cdot 10^{+35}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-268}:\\
\;\;\;\;j \cdot \left(i \cdot \mathsf{fma}\left(x, y1, \left(-t\right) \cdot y5\right)\right)\\
\mathbf{elif}\;k \leq 3 \cdot 10^{-16}:\\
\;\;\;\;y1 \cdot \left(\left(a \cdot y3\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -2.2999999999999998e35 or 2.99999999999999994e-16 < k Initial program 24.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.3%
Taylor expanded in k around -inf
Applied rewrites47.8%
if -2.2999999999999998e35 < k < -6.1999999999999996e-268Initial program 27.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites44.1%
Taylor expanded in j around inf
Applied rewrites37.1%
Applied rewrites34.8%
if -6.1999999999999996e-268 < k < 2.99999999999999994e-16Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.0%
Taylor expanded in y1 around -inf
Applied rewrites35.8%
Taylor expanded in z around inf
Applied rewrites30.1%
Final simplification39.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (or (<= k -1.65e+25) (not (<= k 6.2e-10))) (* (* i k) (fma y y5 (* (- y1) z))) (* (* (fma (- j) y5 (* c z)) t) i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if ((k <= -1.65e+25) || !(k <= 6.2e-10)) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else {
tmp = (fma(-j, y5, (c * z)) * t) * i;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if ((k <= -1.65e+25) || !(k <= 6.2e-10)) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); else tmp = Float64(Float64(fma(Float64(-j), y5, Float64(c * z)) * t) * i); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[Or[LessEqual[k, -1.65e+25], N[Not[LessEqual[k, 6.2e-10]], $MachinePrecision]], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * i), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.65 \cdot 10^{+25} \lor \neg \left(k \leq 6.2 \cdot 10^{-10}\right):\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(-j, y5, c \cdot z\right) \cdot t\right) \cdot i\\
\end{array}
\end{array}
if k < -1.6500000000000001e25 or 6.2000000000000003e-10 < k Initial program 24.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.4%
Taylor expanded in k around -inf
Applied rewrites46.8%
if -1.6500000000000001e25 < k < 6.2000000000000003e-10Initial program 34.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.6%
Taylor expanded in k around -inf
Applied rewrites9.9%
Taylor expanded in t around -inf
Applied rewrites32.1%
Applied rewrites36.6%
Final simplification41.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (or (<= k -1.65e+25) (not (<= k 2.5e-10))) (* (* i k) (fma y y5 (* (- y1) z))) (* (* i t) (fma (- j) y5 (* c z)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if ((k <= -1.65e+25) || !(k <= 2.5e-10)) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else {
tmp = (i * t) * fma(-j, y5, (c * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if ((k <= -1.65e+25) || !(k <= 2.5e-10)) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); else tmp = Float64(Float64(i * t) * fma(Float64(-j), y5, Float64(c * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[Or[LessEqual[k, -1.65e+25], N[Not[LessEqual[k, 2.5e-10]], $MachinePrecision]], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i * t), $MachinePrecision] * N[((-j) * y5 + N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.65 \cdot 10^{+25} \lor \neg \left(k \leq 2.5 \cdot 10^{-10}\right):\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot t\right) \cdot \mathsf{fma}\left(-j, y5, c \cdot z\right)\\
\end{array}
\end{array}
if k < -1.6500000000000001e25 or 2.50000000000000016e-10 < k Initial program 24.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.4%
Taylor expanded in k around -inf
Applied rewrites46.8%
if -1.6500000000000001e25 < k < 2.50000000000000016e-10Initial program 34.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.6%
Taylor expanded in k around -inf
Applied rewrites9.9%
Taylor expanded in t around -inf
Applied rewrites32.1%
Final simplification39.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -4.2e+84)
(* i (* (* k y) y5))
(if (<= k -6.2e-268)
(* j (* i (fma x y1 (* (- t) y5))))
(if (<= k 7e-12) (* y1 (* (* a y3) z)) (* (- i) (* k (* y1 z)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -4.2e+84) {
tmp = i * ((k * y) * y5);
} else if (k <= -6.2e-268) {
tmp = j * (i * fma(x, y1, (-t * y5)));
} else if (k <= 7e-12) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = -i * (k * (y1 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -4.2e+84) tmp = Float64(i * Float64(Float64(k * y) * y5)); elseif (k <= -6.2e-268) tmp = Float64(j * Float64(i * fma(x, y1, Float64(Float64(-t) * y5)))); elseif (k <= 7e-12) tmp = Float64(y1 * Float64(Float64(a * y3) * z)); else tmp = Float64(Float64(-i) * Float64(k * Float64(y1 * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -4.2e+84], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -6.2e-268], N[(j * N[(i * N[(x * y1 + N[((-t) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 7e-12], N[(y1 * N[(N[(a * y3), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[((-i) * N[(k * N[(y1 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -4.2 \cdot 10^{+84}:\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{elif}\;k \leq -6.2 \cdot 10^{-268}:\\
\;\;\;\;j \cdot \left(i \cdot \mathsf{fma}\left(x, y1, \left(-t\right) \cdot y5\right)\right)\\
\mathbf{elif}\;k \leq 7 \cdot 10^{-12}:\\
\;\;\;\;y1 \cdot \left(\left(a \cdot y3\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-i\right) \cdot \left(k \cdot \left(y1 \cdot z\right)\right)\\
\end{array}
\end{array}
if k < -4.20000000000000037e84Initial program 19.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites42.1%
Taylor expanded in k around -inf
Applied rewrites50.7%
Taylor expanded in y around inf
Applied rewrites42.7%
if -4.20000000000000037e84 < k < -6.1999999999999996e-268Initial program 29.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.0%
Taylor expanded in j around inf
Applied rewrites34.7%
Applied rewrites32.7%
if -6.1999999999999996e-268 < k < 7.0000000000000001e-12Initial program 40.5%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.0%
Taylor expanded in y1 around -inf
Applied rewrites35.8%
Taylor expanded in z around inf
Applied rewrites30.1%
if 7.0000000000000001e-12 < k Initial program 24.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.6%
Taylor expanded in k around -inf
Applied rewrites46.6%
Taylor expanded in y around 0
Applied rewrites36.1%
Final simplification34.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -3.6e+30)
(* i (* (* k y) y5))
(if (<= k -5.8e-291)
(* (* i t) (* c z))
(if (<= k 7e-12) (* y1 (* (* a y3) z)) (* (- i) (* k (* y1 z)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -3.6e+30) {
tmp = i * ((k * y) * y5);
} else if (k <= -5.8e-291) {
tmp = (i * t) * (c * z);
} else if (k <= 7e-12) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = -i * (k * (y1 * z));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if (k <= (-3.6d+30)) then
tmp = i * ((k * y) * y5)
else if (k <= (-5.8d-291)) then
tmp = (i * t) * (c * z)
else if (k <= 7d-12) then
tmp = y1 * ((a * y3) * z)
else
tmp = -i * (k * (y1 * z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -3.6e+30) {
tmp = i * ((k * y) * y5);
} else if (k <= -5.8e-291) {
tmp = (i * t) * (c * z);
} else if (k <= 7e-12) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = -i * (k * (y1 * z));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if k <= -3.6e+30: tmp = i * ((k * y) * y5) elif k <= -5.8e-291: tmp = (i * t) * (c * z) elif k <= 7e-12: tmp = y1 * ((a * y3) * z) else: tmp = -i * (k * (y1 * z)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -3.6e+30) tmp = Float64(i * Float64(Float64(k * y) * y5)); elseif (k <= -5.8e-291) tmp = Float64(Float64(i * t) * Float64(c * z)); elseif (k <= 7e-12) tmp = Float64(y1 * Float64(Float64(a * y3) * z)); else tmp = Float64(Float64(-i) * Float64(k * Float64(y1 * z))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if (k <= -3.6e+30) tmp = i * ((k * y) * y5); elseif (k <= -5.8e-291) tmp = (i * t) * (c * z); elseif (k <= 7e-12) tmp = y1 * ((a * y3) * z); else tmp = -i * (k * (y1 * z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -3.6e+30], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -5.8e-291], N[(N[(i * t), $MachinePrecision] * N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 7e-12], N[(y1 * N[(N[(a * y3), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[((-i) * N[(k * N[(y1 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -3.6 \cdot 10^{+30}:\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{elif}\;k \leq -5.8 \cdot 10^{-291}:\\
\;\;\;\;\left(i \cdot t\right) \cdot \left(c \cdot z\right)\\
\mathbf{elif}\;k \leq 7 \cdot 10^{-12}:\\
\;\;\;\;y1 \cdot \left(\left(a \cdot y3\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-i\right) \cdot \left(k \cdot \left(y1 \cdot z\right)\right)\\
\end{array}
\end{array}
if k < -3.6000000000000002e30Initial program 25.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites44.8%
Taylor expanded in k around -inf
Applied rewrites47.1%
Taylor expanded in y around inf
Applied rewrites37.8%
if -3.6000000000000002e30 < k < -5.80000000000000003e-291Initial program 29.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.2%
Taylor expanded in k around -inf
Applied rewrites11.9%
Taylor expanded in t around -inf
Applied rewrites38.8%
Taylor expanded in z around inf
Applied rewrites29.8%
if -5.80000000000000003e-291 < k < 7.0000000000000001e-12Initial program 39.9%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites51.0%
Taylor expanded in y1 around -inf
Applied rewrites36.5%
Taylor expanded in z around inf
Applied rewrites30.3%
if 7.0000000000000001e-12 < k Initial program 24.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.6%
Taylor expanded in k around -inf
Applied rewrites46.6%
Taylor expanded in y around 0
Applied rewrites36.1%
Final simplification33.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* i (* (* k y) y5))))
(if (<= k -3.6e+30)
t_1
(if (<= k -5.8e-291)
(* (* i t) (* c z))
(if (<= k 7e+110) (* y1 (* (* a y3) z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = i * ((k * y) * y5);
double tmp;
if (k <= -3.6e+30) {
tmp = t_1;
} else if (k <= -5.8e-291) {
tmp = (i * t) * (c * z);
} else if (k <= 7e+110) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = t_1;
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = i * ((k * y) * y5)
if (k <= (-3.6d+30)) then
tmp = t_1
else if (k <= (-5.8d-291)) then
tmp = (i * t) * (c * z)
else if (k <= 7d+110) then
tmp = y1 * ((a * y3) * 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 b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = i * ((k * y) * y5);
double tmp;
if (k <= -3.6e+30) {
tmp = t_1;
} else if (k <= -5.8e-291) {
tmp = (i * t) * (c * z);
} else if (k <= 7e+110) {
tmp = y1 * ((a * y3) * z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = i * ((k * y) * y5) tmp = 0 if k <= -3.6e+30: tmp = t_1 elif k <= -5.8e-291: tmp = (i * t) * (c * z) elif k <= 7e+110: tmp = y1 * ((a * y3) * z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(i * Float64(Float64(k * y) * y5)) tmp = 0.0 if (k <= -3.6e+30) tmp = t_1; elseif (k <= -5.8e-291) tmp = Float64(Float64(i * t) * Float64(c * z)); elseif (k <= 7e+110) tmp = Float64(y1 * Float64(Float64(a * y3) * z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = i * ((k * y) * y5); tmp = 0.0; if (k <= -3.6e+30) tmp = t_1; elseif (k <= -5.8e-291) tmp = (i * t) * (c * z); elseif (k <= 7e+110) tmp = y1 * ((a * y3) * z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -3.6e+30], t$95$1, If[LessEqual[k, -5.8e-291], N[(N[(i * t), $MachinePrecision] * N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 7e+110], N[(y1 * N[(N[(a * y3), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{if}\;k \leq -3.6 \cdot 10^{+30}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -5.8 \cdot 10^{-291}:\\
\;\;\;\;\left(i \cdot t\right) \cdot \left(c \cdot z\right)\\
\mathbf{elif}\;k \leq 7 \cdot 10^{+110}:\\
\;\;\;\;y1 \cdot \left(\left(a \cdot y3\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -3.6000000000000002e30 or 6.9999999999999998e110 < k Initial program 23.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.0%
Taylor expanded in k around -inf
Applied rewrites49.6%
Taylor expanded in y around inf
Applied rewrites35.6%
if -3.6000000000000002e30 < k < -5.80000000000000003e-291Initial program 29.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.2%
Taylor expanded in k around -inf
Applied rewrites11.9%
Taylor expanded in t around -inf
Applied rewrites38.8%
Taylor expanded in z around inf
Applied rewrites29.8%
if -5.80000000000000003e-291 < k < 6.9999999999999998e110Initial program 38.0%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.7%
Taylor expanded in y1 around -inf
Applied rewrites33.5%
Taylor expanded in z around inf
Applied rewrites28.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* i (* (* k y) y5))))
(if (<= k -3.6e+30)
t_1
(if (<= k -1.55e-288)
(* (* i t) (* c z))
(if (<= k 2.6e+120) (* a (* y1 (* y3 z))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = i * ((k * y) * y5);
double tmp;
if (k <= -3.6e+30) {
tmp = t_1;
} else if (k <= -1.55e-288) {
tmp = (i * t) * (c * z);
} else if (k <= 2.6e+120) {
tmp = a * (y1 * (y3 * z));
} else {
tmp = t_1;
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = i * ((k * y) * y5)
if (k <= (-3.6d+30)) then
tmp = t_1
else if (k <= (-1.55d-288)) then
tmp = (i * t) * (c * z)
else if (k <= 2.6d+120) then
tmp = a * (y1 * (y3 * 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 b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = i * ((k * y) * y5);
double tmp;
if (k <= -3.6e+30) {
tmp = t_1;
} else if (k <= -1.55e-288) {
tmp = (i * t) * (c * z);
} else if (k <= 2.6e+120) {
tmp = a * (y1 * (y3 * z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = i * ((k * y) * y5) tmp = 0 if k <= -3.6e+30: tmp = t_1 elif k <= -1.55e-288: tmp = (i * t) * (c * z) elif k <= 2.6e+120: tmp = a * (y1 * (y3 * z)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(i * Float64(Float64(k * y) * y5)) tmp = 0.0 if (k <= -3.6e+30) tmp = t_1; elseif (k <= -1.55e-288) tmp = Float64(Float64(i * t) * Float64(c * z)); elseif (k <= 2.6e+120) tmp = Float64(a * Float64(y1 * Float64(y3 * z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = i * ((k * y) * y5); tmp = 0.0; if (k <= -3.6e+30) tmp = t_1; elseif (k <= -1.55e-288) tmp = (i * t) * (c * z); elseif (k <= 2.6e+120) tmp = a * (y1 * (y3 * z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -3.6e+30], t$95$1, If[LessEqual[k, -1.55e-288], N[(N[(i * t), $MachinePrecision] * N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.6e+120], N[(a * N[(y1 * N[(y3 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{if}\;k \leq -3.6 \cdot 10^{+30}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -1.55 \cdot 10^{-288}:\\
\;\;\;\;\left(i \cdot t\right) \cdot \left(c \cdot z\right)\\
\mathbf{elif}\;k \leq 2.6 \cdot 10^{+120}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(y3 \cdot z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -3.6000000000000002e30 or 2.5999999999999999e120 < k Initial program 22.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.8%
Taylor expanded in k around -inf
Applied rewrites51.5%
Taylor expanded in y around inf
Applied rewrites36.0%
if -3.6000000000000002e30 < k < -1.54999999999999992e-288Initial program 28.0%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.4%
Taylor expanded in k around -inf
Applied rewrites12.1%
Taylor expanded in t around -inf
Applied rewrites39.4%
Taylor expanded in z around inf
Applied rewrites30.2%
if -1.54999999999999992e-288 < k < 2.5999999999999999e120Initial program 38.1%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.2%
Taylor expanded in y1 around -inf
Applied rewrites31.8%
Taylor expanded in z around inf
Applied rewrites27.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (or (<= t -2.6e+25) (not (<= t 5e+51))) (* (* (* t z) i) c) (* i (* (* k y) y5))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if ((t <= -2.6e+25) || !(t <= 5e+51)) {
tmp = ((t * z) * i) * c;
} else {
tmp = i * ((k * y) * y5);
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if ((t <= (-2.6d+25)) .or. (.not. (t <= 5d+51))) then
tmp = ((t * z) * i) * c
else
tmp = i * ((k * y) * y5)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if ((t <= -2.6e+25) || !(t <= 5e+51)) {
tmp = ((t * z) * i) * c;
} else {
tmp = i * ((k * y) * y5);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if (t <= -2.6e+25) or not (t <= 5e+51): tmp = ((t * z) * i) * c else: tmp = i * ((k * y) * y5) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if ((t <= -2.6e+25) || !(t <= 5e+51)) tmp = Float64(Float64(Float64(t * z) * i) * c); else tmp = Float64(i * Float64(Float64(k * y) * y5)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if ((t <= -2.6e+25) || ~((t <= 5e+51))) tmp = ((t * z) * i) * c; else tmp = i * ((k * y) * y5); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[Or[LessEqual[t, -2.6e+25], N[Not[LessEqual[t, 5e+51]], $MachinePrecision]], N[(N[(N[(t * z), $MachinePrecision] * i), $MachinePrecision] * c), $MachinePrecision], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.6 \cdot 10^{+25} \lor \neg \left(t \leq 5 \cdot 10^{+51}\right):\\
\;\;\;\;\left(\left(t \cdot z\right) \cdot i\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\end{array}
\end{array}
if t < -2.5999999999999998e25 or 5e51 < t Initial program 19.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.6%
Taylor expanded in k around -inf
Applied rewrites25.8%
Taylor expanded in t around -inf
Applied rewrites45.6%
Taylor expanded in z around inf
Applied rewrites36.0%
if -2.5999999999999998e25 < t < 5e51Initial program 36.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites42.1%
Taylor expanded in k around -inf
Applied rewrites30.5%
Taylor expanded in y around inf
Applied rewrites21.5%
Final simplification27.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (<= t -2.6e+25) (* (* i t) (* c z)) (if (<= t 5e+51) (* i (* (* k y) y5)) (* (* (* t z) i) c))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -2.6e+25) {
tmp = (i * t) * (c * z);
} else if (t <= 5e+51) {
tmp = i * ((k * y) * y5);
} else {
tmp = ((t * z) * i) * c;
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if (t <= (-2.6d+25)) then
tmp = (i * t) * (c * z)
else if (t <= 5d+51) then
tmp = i * ((k * y) * y5)
else
tmp = ((t * z) * i) * c
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -2.6e+25) {
tmp = (i * t) * (c * z);
} else if (t <= 5e+51) {
tmp = i * ((k * y) * y5);
} else {
tmp = ((t * z) * i) * c;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if t <= -2.6e+25: tmp = (i * t) * (c * z) elif t <= 5e+51: tmp = i * ((k * y) * y5) else: tmp = ((t * z) * i) * c return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -2.6e+25) tmp = Float64(Float64(i * t) * Float64(c * z)); elseif (t <= 5e+51) tmp = Float64(i * Float64(Float64(k * y) * y5)); else tmp = Float64(Float64(Float64(t * z) * i) * c); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if (t <= -2.6e+25) tmp = (i * t) * (c * z); elseif (t <= 5e+51) tmp = i * ((k * y) * y5); else tmp = ((t * z) * i) * c; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -2.6e+25], N[(N[(i * t), $MachinePrecision] * N[(c * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5e+51], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t * z), $MachinePrecision] * i), $MachinePrecision] * c), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.6 \cdot 10^{+25}:\\
\;\;\;\;\left(i \cdot t\right) \cdot \left(c \cdot z\right)\\
\mathbf{elif}\;t \leq 5 \cdot 10^{+51}:\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(t \cdot z\right) \cdot i\right) \cdot c\\
\end{array}
\end{array}
if t < -2.5999999999999998e25Initial program 18.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.6%
Taylor expanded in k around -inf
Applied rewrites25.3%
Taylor expanded in t around -inf
Applied rewrites45.3%
Taylor expanded in z around inf
Applied rewrites37.4%
if -2.5999999999999998e25 < t < 5e51Initial program 36.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites42.1%
Taylor expanded in k around -inf
Applied rewrites30.5%
Taylor expanded in y around inf
Applied rewrites21.5%
if 5e51 < t Initial program 20.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites45.7%
Taylor expanded in k around -inf
Applied rewrites26.5%
Taylor expanded in t around -inf
Applied rewrites46.1%
Taylor expanded in z around inf
Applied rewrites36.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (<= j -1.05e+44) (* (* j i) (* y1 x)) (if (<= j 1.95e-53) (* i (* (* k y) y5)) (* i (* (* j x) y1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (j <= -1.05e+44) {
tmp = (j * i) * (y1 * x);
} else if (j <= 1.95e-53) {
tmp = i * ((k * y) * y5);
} else {
tmp = i * ((j * x) * y1);
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if (j <= (-1.05d+44)) then
tmp = (j * i) * (y1 * x)
else if (j <= 1.95d-53) then
tmp = i * ((k * y) * y5)
else
tmp = i * ((j * x) * y1)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (j <= -1.05e+44) {
tmp = (j * i) * (y1 * x);
} else if (j <= 1.95e-53) {
tmp = i * ((k * y) * y5);
} else {
tmp = i * ((j * x) * y1);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if j <= -1.05e+44: tmp = (j * i) * (y1 * x) elif j <= 1.95e-53: tmp = i * ((k * y) * y5) else: tmp = i * ((j * x) * y1) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (j <= -1.05e+44) tmp = Float64(Float64(j * i) * Float64(y1 * x)); elseif (j <= 1.95e-53) tmp = Float64(i * Float64(Float64(k * y) * y5)); else tmp = Float64(i * Float64(Float64(j * x) * y1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if (j <= -1.05e+44) tmp = (j * i) * (y1 * x); elseif (j <= 1.95e-53) tmp = i * ((k * y) * y5); else tmp = i * ((j * x) * y1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[j, -1.05e+44], N[(N[(j * i), $MachinePrecision] * N[(y1 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.95e-53], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(j * x), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.05 \cdot 10^{+44}:\\
\;\;\;\;\left(j \cdot i\right) \cdot \left(y1 \cdot x\right)\\
\mathbf{elif}\;j \leq 1.95 \cdot 10^{-53}:\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(\left(j \cdot x\right) \cdot y1\right)\\
\end{array}
\end{array}
if j < -1.04999999999999993e44Initial program 28.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.6%
Taylor expanded in j around inf
Applied rewrites32.9%
Taylor expanded in x around inf
Applied rewrites17.6%
Applied rewrites21.3%
if -1.04999999999999993e44 < j < 1.9500000000000001e-53Initial program 33.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites43.4%
Taylor expanded in k around -inf
Applied rewrites37.0%
Taylor expanded in y around inf
Applied rewrites26.9%
if 1.9500000000000001e-53 < j Initial program 23.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.9%
Taylor expanded in j around inf
Applied rewrites35.8%
Taylor expanded in x around inf
Applied rewrites27.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (<= b 1e-66) (* i (* (* j x) y1)) (* j (* (* y1 x) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (b <= 1e-66) {
tmp = i * ((j * x) * y1);
} else {
tmp = j * ((y1 * x) * i);
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if (b <= 1d-66) then
tmp = i * ((j * x) * y1)
else
tmp = j * ((y1 * x) * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (b <= 1e-66) {
tmp = i * ((j * x) * y1);
} else {
tmp = j * ((y1 * x) * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if b <= 1e-66: tmp = i * ((j * x) * y1) else: tmp = j * ((y1 * x) * i) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= 1e-66) tmp = Float64(i * Float64(Float64(j * x) * y1)); else tmp = Float64(j * Float64(Float64(y1 * x) * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if (b <= 1e-66) tmp = i * ((j * x) * y1); else tmp = j * ((y1 * x) * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, 1e-66], N[(i * N[(N[(j * x), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision], N[(j * N[(N[(y1 * x), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 10^{-66}:\\
\;\;\;\;i \cdot \left(\left(j \cdot x\right) \cdot y1\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(\left(y1 \cdot x\right) \cdot i\right)\\
\end{array}
\end{array}
if b < 9.9999999999999998e-67Initial program 30.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites42.4%
Taylor expanded in j around inf
Applied rewrites20.8%
Taylor expanded in x around inf
Applied rewrites14.7%
if 9.9999999999999998e-67 < b Initial program 27.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.0%
Taylor expanded in j around inf
Applied rewrites27.2%
Taylor expanded in x around inf
Applied rewrites16.3%
Applied rewrites24.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (* (* (* y1 x) j) i))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return ((y1 * x) * j) * i;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = ((y1 * x) * j) * i
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return ((y1 * x) * j) * i;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return ((y1 * x) * j) * i
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(y1 * x) * j) * i) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = ((y1 * x) * j) * i; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(y1 * x), $MachinePrecision] * j), $MachinePrecision] * i), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(y1 \cdot x\right) \cdot j\right) \cdot i
\end{array}
Initial program 29.5%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites43.5%
Taylor expanded in j around inf
Applied rewrites22.8%
Taylor expanded in x around inf
Applied rewrites15.2%
Taylor expanded in x around 0
Applied rewrites15.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* y4 c) (* y5 a)))
(t_2 (- (* x y2) (* z y3)))
(t_3 (- (* y2 t) (* y3 y)))
(t_4 (- (* k y2) (* j y3)))
(t_5 (- (* y4 b) (* y5 i)))
(t_6 (* (- (* j t) (* k y)) t_5))
(t_7 (- (* b a) (* i c)))
(t_8 (* t_7 (- (* y x) (* t z))))
(t_9 (- (* j x) (* k z)))
(t_10 (* (- (* b y0) (* i y1)) t_9))
(t_11 (* t_9 (- (* y0 b) (* i y1))))
(t_12 (- (* y4 y1) (* y5 y0)))
(t_13 (* t_4 t_12))
(t_14 (* (- (* y2 k) (* y3 j)) t_12))
(t_15
(+
(-
(-
(- (* (* k y) (* y5 i)) (* (* y b) (* y4 k)))
(* (* y5 t) (* i j)))
(- (* t_3 t_1) t_14))
(- t_8 (- t_11 (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))))
(t_16
(+
(+
(- t_6 (* (* y3 y) (- (* y5 a) (* y4 c))))
(+ (* (* y5 a) (* t y2)) t_13))
(-
(* t_2 (- (* c y0) (* a y1)))
(- t_10 (* (- (* y x) (* z t)) t_7)))))
(t_17 (- (* t y2) (* y y3))))
(if (< y4 -7.206256231996481e+60)
(- (- t_8 (- t_11 t_6)) (- (/ t_3 (/ 1.0 t_1)) t_14))
(if (< y4 -3.364603505246317e-66)
(+
(-
(- (- (* (* t c) (* i z)) (* (* a t) (* b z))) (* (* y c) (* i x)))
t_10)
(-
(* (- (* y0 c) (* a y1)) t_2)
(- (* t_17 (- (* y4 c) (* a y5))) (* (- (* y1 y4) (* y5 y0)) t_4))))
(if (< y4 -1.2000065055686116e-105)
t_16
(if (< y4 6.718963124057495e-279)
t_15
(if (< y4 4.77962681403792e-222)
t_16
(if (< y4 2.2852241541266835e-175)
t_15
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(-
(* k (* i (* z y1)))
(+ (* j (* i (* x y1))) (* y0 (* k (* z b))))))
(-
(* z (* y3 (* a y1)))
(+ (* y2 (* x (* a y1))) (* y0 (* z (* c y3))))))
(* (- (* t j) (* y k)) t_5))
(* t_17 t_1))
t_13)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (y4 * c) - (y5 * a);
double t_2 = (x * y2) - (z * y3);
double t_3 = (y2 * t) - (y3 * y);
double t_4 = (k * y2) - (j * y3);
double t_5 = (y4 * b) - (y5 * i);
double t_6 = ((j * t) - (k * y)) * t_5;
double t_7 = (b * a) - (i * c);
double t_8 = t_7 * ((y * x) - (t * z));
double t_9 = (j * x) - (k * z);
double t_10 = ((b * y0) - (i * y1)) * t_9;
double t_11 = t_9 * ((y0 * b) - (i * y1));
double t_12 = (y4 * y1) - (y5 * y0);
double t_13 = t_4 * t_12;
double t_14 = ((y2 * k) - (y3 * j)) * t_12;
double t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))));
double t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)));
double t_17 = (t * y2) - (y * y3);
double tmp;
if (y4 < -7.206256231996481e+60) {
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14);
} else if (y4 < -3.364603505246317e-66) {
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)));
} else if (y4 < -1.2000065055686116e-105) {
tmp = t_16;
} else if (y4 < 6.718963124057495e-279) {
tmp = t_15;
} else if (y4 < 4.77962681403792e-222) {
tmp = t_16;
} else if (y4 < 2.2852241541266835e-175) {
tmp = t_15;
} else {
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13;
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: t_10
real(8) :: t_11
real(8) :: t_12
real(8) :: t_13
real(8) :: t_14
real(8) :: t_15
real(8) :: t_16
real(8) :: t_17
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: t_6
real(8) :: t_7
real(8) :: t_8
real(8) :: t_9
real(8) :: tmp
t_1 = (y4 * c) - (y5 * a)
t_2 = (x * y2) - (z * y3)
t_3 = (y2 * t) - (y3 * y)
t_4 = (k * y2) - (j * y3)
t_5 = (y4 * b) - (y5 * i)
t_6 = ((j * t) - (k * y)) * t_5
t_7 = (b * a) - (i * c)
t_8 = t_7 * ((y * x) - (t * z))
t_9 = (j * x) - (k * z)
t_10 = ((b * y0) - (i * y1)) * t_9
t_11 = t_9 * ((y0 * b) - (i * y1))
t_12 = (y4 * y1) - (y5 * y0)
t_13 = t_4 * t_12
t_14 = ((y2 * k) - (y3 * j)) * t_12
t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))))
t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)))
t_17 = (t * y2) - (y * y3)
if (y4 < (-7.206256231996481d+60)) then
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0d0 / t_1)) - t_14)
else if (y4 < (-3.364603505246317d-66)) then
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)))
else if (y4 < (-1.2000065055686116d-105)) then
tmp = t_16
else if (y4 < 6.718963124057495d-279) then
tmp = t_15
else if (y4 < 4.77962681403792d-222) then
tmp = t_16
else if (y4 < 2.2852241541266835d-175) then
tmp = t_15
else
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (y4 * c) - (y5 * a);
double t_2 = (x * y2) - (z * y3);
double t_3 = (y2 * t) - (y3 * y);
double t_4 = (k * y2) - (j * y3);
double t_5 = (y4 * b) - (y5 * i);
double t_6 = ((j * t) - (k * y)) * t_5;
double t_7 = (b * a) - (i * c);
double t_8 = t_7 * ((y * x) - (t * z));
double t_9 = (j * x) - (k * z);
double t_10 = ((b * y0) - (i * y1)) * t_9;
double t_11 = t_9 * ((y0 * b) - (i * y1));
double t_12 = (y4 * y1) - (y5 * y0);
double t_13 = t_4 * t_12;
double t_14 = ((y2 * k) - (y3 * j)) * t_12;
double t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))));
double t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)));
double t_17 = (t * y2) - (y * y3);
double tmp;
if (y4 < -7.206256231996481e+60) {
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14);
} else if (y4 < -3.364603505246317e-66) {
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)));
} else if (y4 < -1.2000065055686116e-105) {
tmp = t_16;
} else if (y4 < 6.718963124057495e-279) {
tmp = t_15;
} else if (y4 < 4.77962681403792e-222) {
tmp = t_16;
} else if (y4 < 2.2852241541266835e-175) {
tmp = t_15;
} else {
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = (y4 * c) - (y5 * a) t_2 = (x * y2) - (z * y3) t_3 = (y2 * t) - (y3 * y) t_4 = (k * y2) - (j * y3) t_5 = (y4 * b) - (y5 * i) t_6 = ((j * t) - (k * y)) * t_5 t_7 = (b * a) - (i * c) t_8 = t_7 * ((y * x) - (t * z)) t_9 = (j * x) - (k * z) t_10 = ((b * y0) - (i * y1)) * t_9 t_11 = t_9 * ((y0 * b) - (i * y1)) t_12 = (y4 * y1) - (y5 * y0) t_13 = t_4 * t_12 t_14 = ((y2 * k) - (y3 * j)) * t_12 t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a))))) t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7))) t_17 = (t * y2) - (y * y3) tmp = 0 if y4 < -7.206256231996481e+60: tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14) elif y4 < -3.364603505246317e-66: tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4))) elif y4 < -1.2000065055686116e-105: tmp = t_16 elif y4 < 6.718963124057495e-279: tmp = t_15 elif y4 < 4.77962681403792e-222: tmp = t_16 elif y4 < 2.2852241541266835e-175: tmp = t_15 else: tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(y4 * c) - Float64(y5 * a)) t_2 = Float64(Float64(x * y2) - Float64(z * y3)) t_3 = Float64(Float64(y2 * t) - Float64(y3 * y)) t_4 = Float64(Float64(k * y2) - Float64(j * y3)) t_5 = Float64(Float64(y4 * b) - Float64(y5 * i)) t_6 = Float64(Float64(Float64(j * t) - Float64(k * y)) * t_5) t_7 = Float64(Float64(b * a) - Float64(i * c)) t_8 = Float64(t_7 * Float64(Float64(y * x) - Float64(t * z))) t_9 = Float64(Float64(j * x) - Float64(k * z)) t_10 = Float64(Float64(Float64(b * y0) - Float64(i * y1)) * t_9) t_11 = Float64(t_9 * Float64(Float64(y0 * b) - Float64(i * y1))) t_12 = Float64(Float64(y4 * y1) - Float64(y5 * y0)) t_13 = Float64(t_4 * t_12) t_14 = Float64(Float64(Float64(y2 * k) - Float64(y3 * j)) * t_12) t_15 = Float64(Float64(Float64(Float64(Float64(Float64(k * y) * Float64(y5 * i)) - Float64(Float64(y * b) * Float64(y4 * k))) - Float64(Float64(y5 * t) * Float64(i * j))) - Float64(Float64(t_3 * t_1) - t_14)) + Float64(t_8 - Float64(t_11 - Float64(Float64(Float64(y2 * x) - Float64(y3 * z)) * Float64(Float64(c * y0) - Float64(y1 * a)))))) t_16 = Float64(Float64(Float64(t_6 - Float64(Float64(y3 * y) * Float64(Float64(y5 * a) - Float64(y4 * c)))) + Float64(Float64(Float64(y5 * a) * Float64(t * y2)) + t_13)) + Float64(Float64(t_2 * Float64(Float64(c * y0) - Float64(a * y1))) - Float64(t_10 - Float64(Float64(Float64(y * x) - Float64(z * t)) * t_7)))) t_17 = Float64(Float64(t * y2) - Float64(y * y3)) tmp = 0.0 if (y4 < -7.206256231996481e+60) tmp = Float64(Float64(t_8 - Float64(t_11 - t_6)) - Float64(Float64(t_3 / Float64(1.0 / t_1)) - t_14)); elseif (y4 < -3.364603505246317e-66) tmp = Float64(Float64(Float64(Float64(Float64(Float64(t * c) * Float64(i * z)) - Float64(Float64(a * t) * Float64(b * z))) - Float64(Float64(y * c) * Float64(i * x))) - t_10) + Float64(Float64(Float64(Float64(y0 * c) - Float64(a * y1)) * t_2) - Float64(Float64(t_17 * Float64(Float64(y4 * c) - Float64(a * y5))) - Float64(Float64(Float64(y1 * y4) - Float64(y5 * y0)) * t_4)))); elseif (y4 < -1.2000065055686116e-105) tmp = t_16; elseif (y4 < 6.718963124057495e-279) tmp = t_15; elseif (y4 < 4.77962681403792e-222) tmp = t_16; elseif (y4 < 2.2852241541266835e-175) tmp = t_15; else tmp = Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(k * Float64(i * Float64(z * y1))) - Float64(Float64(j * Float64(i * Float64(x * y1))) + Float64(y0 * Float64(k * Float64(z * b)))))) + Float64(Float64(z * Float64(y3 * Float64(a * y1))) - Float64(Float64(y2 * Float64(x * Float64(a * y1))) + Float64(y0 * Float64(z * Float64(c * y3)))))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * t_5)) - Float64(t_17 * t_1)) + t_13); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = (y4 * c) - (y5 * a); t_2 = (x * y2) - (z * y3); t_3 = (y2 * t) - (y3 * y); t_4 = (k * y2) - (j * y3); t_5 = (y4 * b) - (y5 * i); t_6 = ((j * t) - (k * y)) * t_5; t_7 = (b * a) - (i * c); t_8 = t_7 * ((y * x) - (t * z)); t_9 = (j * x) - (k * z); t_10 = ((b * y0) - (i * y1)) * t_9; t_11 = t_9 * ((y0 * b) - (i * y1)); t_12 = (y4 * y1) - (y5 * y0); t_13 = t_4 * t_12; t_14 = ((y2 * k) - (y3 * j)) * t_12; t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a))))); t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7))); t_17 = (t * y2) - (y * y3); tmp = 0.0; if (y4 < -7.206256231996481e+60) tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14); elseif (y4 < -3.364603505246317e-66) tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4))); elseif (y4 < -1.2000065055686116e-105) tmp = t_16; elseif (y4 < 6.718963124057495e-279) tmp = t_15; elseif (y4 < 4.77962681403792e-222) tmp = t_16; elseif (y4 < 2.2852241541266835e-175) tmp = t_15; else tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(y2 * t), $MachinePrecision] - N[(y3 * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision]}, Block[{t$95$7 = N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$8 = N[(t$95$7 * N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$9 = N[(N[(j * x), $MachinePrecision] - N[(k * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$10 = N[(N[(N[(b * y0), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision] * t$95$9), $MachinePrecision]}, Block[{t$95$11 = N[(t$95$9 * N[(N[(y0 * b), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$12 = N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$13 = N[(t$95$4 * t$95$12), $MachinePrecision]}, Block[{t$95$14 = N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * t$95$12), $MachinePrecision]}, Block[{t$95$15 = N[(N[(N[(N[(N[(N[(k * y), $MachinePrecision] * N[(y5 * i), $MachinePrecision]), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] * N[(y4 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y5 * t), $MachinePrecision] * N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(t$95$3 * t$95$1), $MachinePrecision] - t$95$14), $MachinePrecision]), $MachinePrecision] + N[(t$95$8 - N[(t$95$11 - N[(N[(N[(y2 * x), $MachinePrecision] - N[(y3 * z), $MachinePrecision]), $MachinePrecision] * N[(N[(c * y0), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$16 = N[(N[(N[(t$95$6 - N[(N[(y3 * y), $MachinePrecision] * N[(N[(y5 * a), $MachinePrecision] - N[(y4 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y5 * a), $MachinePrecision] * N[(t * y2), $MachinePrecision]), $MachinePrecision] + t$95$13), $MachinePrecision]), $MachinePrecision] + N[(N[(t$95$2 * N[(N[(c * y0), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(t$95$10 - N[(N[(N[(y * x), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * t$95$7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$17 = N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]}, If[Less[y4, -7.206256231996481e+60], N[(N[(t$95$8 - N[(t$95$11 - t$95$6), $MachinePrecision]), $MachinePrecision] - N[(N[(t$95$3 / N[(1.0 / t$95$1), $MachinePrecision]), $MachinePrecision] - t$95$14), $MachinePrecision]), $MachinePrecision], If[Less[y4, -3.364603505246317e-66], N[(N[(N[(N[(N[(N[(t * c), $MachinePrecision] * N[(i * z), $MachinePrecision]), $MachinePrecision] - N[(N[(a * t), $MachinePrecision] * N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y * c), $MachinePrecision] * N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$10), $MachinePrecision] + N[(N[(N[(N[(y0 * c), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision] - N[(N[(t$95$17 * N[(N[(y4 * c), $MachinePrecision] - N[(a * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(y1 * y4), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * t$95$4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Less[y4, -1.2000065055686116e-105], t$95$16, If[Less[y4, 6.718963124057495e-279], t$95$15, If[Less[y4, 4.77962681403792e-222], t$95$16, If[Less[y4, 2.2852241541266835e-175], t$95$15, N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(k * N[(i * N[(z * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * N[(i * N[(x * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(k * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(y3 * N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * N[(x * N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(z * N[(c * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision]), $MachinePrecision] - N[(t$95$17 * t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$13), $MachinePrecision]]]]]]]]]]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y4 \cdot c - y5 \cdot a\\
t_2 := x \cdot y2 - z \cdot y3\\
t_3 := y2 \cdot t - y3 \cdot y\\
t_4 := k \cdot y2 - j \cdot y3\\
t_5 := y4 \cdot b - y5 \cdot i\\
t_6 := \left(j \cdot t - k \cdot y\right) \cdot t\_5\\
t_7 := b \cdot a - i \cdot c\\
t_8 := t\_7 \cdot \left(y \cdot x - t \cdot z\right)\\
t_9 := j \cdot x - k \cdot z\\
t_10 := \left(b \cdot y0 - i \cdot y1\right) \cdot t\_9\\
t_11 := t\_9 \cdot \left(y0 \cdot b - i \cdot y1\right)\\
t_12 := y4 \cdot y1 - y5 \cdot y0\\
t_13 := t\_4 \cdot t\_12\\
t_14 := \left(y2 \cdot k - y3 \cdot j\right) \cdot t\_12\\
t_15 := \left(\left(\left(\left(k \cdot y\right) \cdot \left(y5 \cdot i\right) - \left(y \cdot b\right) \cdot \left(y4 \cdot k\right)\right) - \left(y5 \cdot t\right) \cdot \left(i \cdot j\right)\right) - \left(t\_3 \cdot t\_1 - t\_14\right)\right) + \left(t\_8 - \left(t\_11 - \left(y2 \cdot x - y3 \cdot z\right) \cdot \left(c \cdot y0 - y1 \cdot a\right)\right)\right)\\
t_16 := \left(\left(t\_6 - \left(y3 \cdot y\right) \cdot \left(y5 \cdot a - y4 \cdot c\right)\right) + \left(\left(y5 \cdot a\right) \cdot \left(t \cdot y2\right) + t\_13\right)\right) + \left(t\_2 \cdot \left(c \cdot y0 - a \cdot y1\right) - \left(t\_10 - \left(y \cdot x - z \cdot t\right) \cdot t\_7\right)\right)\\
t_17 := t \cdot y2 - y \cdot y3\\
\mathbf{if}\;y4 < -7.206256231996481 \cdot 10^{+60}:\\
\;\;\;\;\left(t\_8 - \left(t\_11 - t\_6\right)\right) - \left(\frac{t\_3}{\frac{1}{t\_1}} - t\_14\right)\\
\mathbf{elif}\;y4 < -3.364603505246317 \cdot 10^{-66}:\\
\;\;\;\;\left(\left(\left(\left(t \cdot c\right) \cdot \left(i \cdot z\right) - \left(a \cdot t\right) \cdot \left(b \cdot z\right)\right) - \left(y \cdot c\right) \cdot \left(i \cdot x\right)\right) - t\_10\right) + \left(\left(y0 \cdot c - a \cdot y1\right) \cdot t\_2 - \left(t\_17 \cdot \left(y4 \cdot c - a \cdot y5\right) - \left(y1 \cdot y4 - y5 \cdot y0\right) \cdot t\_4\right)\right)\\
\mathbf{elif}\;y4 < -1.2000065055686116 \cdot 10^{-105}:\\
\;\;\;\;t\_16\\
\mathbf{elif}\;y4 < 6.718963124057495 \cdot 10^{-279}:\\
\;\;\;\;t\_15\\
\mathbf{elif}\;y4 < 4.77962681403792 \cdot 10^{-222}:\\
\;\;\;\;t\_16\\
\mathbf{elif}\;y4 < 2.2852241541266835 \cdot 10^{-175}:\\
\;\;\;\;t\_15\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(k \cdot \left(i \cdot \left(z \cdot y1\right)\right) - \left(j \cdot \left(i \cdot \left(x \cdot y1\right)\right) + y0 \cdot \left(k \cdot \left(z \cdot b\right)\right)\right)\right)\right) + \left(z \cdot \left(y3 \cdot \left(a \cdot y1\right)\right) - \left(y2 \cdot \left(x \cdot \left(a \cdot y1\right)\right) + y0 \cdot \left(z \cdot \left(c \cdot y3\right)\right)\right)\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot t\_5\right) - t\_17 \cdot t\_1\right) + t\_13\\
\end{array}
\end{array}
herbie shell --seed 2024359
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:name "Linear.Matrix:det44 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< y4 -7206256231996481000000000000000000000000000000000000000000000) (- (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))))) (- (/ (- (* y2 t) (* y3 y)) (/ 1 (- (* y4 c) (* y5 a)))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (if (< y4 -3364603505246317/1000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* t c) (* i z)) (* (* a t) (* b z))) (* (* y c) (* i x))) (* (- (* b y0) (* i y1)) (- (* j x) (* k z)))) (- (* (- (* y0 c) (* a y1)) (- (* x y2) (* z y3))) (- (* (- (* t y2) (* y y3)) (- (* y4 c) (* a y5))) (* (- (* y1 y4) (* y5 y0)) (- (* k y2) (* j y3)))))) (if (< y4 -3000016263921529/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (+ (- (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))) (* (* y3 y) (- (* y5 a) (* y4 c)))) (+ (* (* y5 a) (* t y2)) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* x y2) (* z y3)) (- (* c y0) (* a y1))) (- (* (- (* b y0) (* i y1)) (- (* j x) (* k z))) (* (- (* y x) (* z t)) (- (* b a) (* i c)))))) (if (< y4 1343792624811499/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* k y) (* y5 i)) (* (* y b) (* y4 k))) (* (* y5 t) (* i j))) (- (* (- (* y2 t) (* y3 y)) (- (* y4 c) (* y5 a))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))) (if (< y4 29872667587737/6250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (+ (- (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))) (* (* y3 y) (- (* y5 a) (* y4 c)))) (+ (* (* y5 a) (* t y2)) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* x y2) (* z y3)) (- (* c y0) (* a y1))) (- (* (- (* b y0) (* i y1)) (- (* j x) (* k z))) (* (- (* y x) (* z t)) (- (* b a) (* i c)))))) (if (< y4 4570448308253367/20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* k y) (* y5 i)) (* (* y b) (* y4 k))) (* (* y5 t) (* i j))) (- (* (- (* y2 t) (* y3 y)) (- (* y4 c) (* y5 a))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))) (+ (- (+ (+ (- (* (- (* x y) (* z t)) (- (* a b) (* c i))) (- (* k (* i (* z y1))) (+ (* j (* i (* x y1))) (* y0 (* k (* z b)))))) (- (* z (* y3 (* a y1))) (+ (* y2 (* x (* a y1))) (* y0 (* z (* c y3)))))) (* (- (* t j) (* y k)) (- (* y4 b) (* y5 i)))) (* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a)))) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))))))))
(+ (- (+ (+ (- (* (- (* x y) (* z t)) (- (* a b) (* c i))) (* (- (* x j) (* z k)) (- (* y0 b) (* y1 i)))) (* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a)))) (* (- (* t j) (* y k)) (- (* y4 b) (* y5 i)))) (* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a)))) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))