Diagrams.TwoD.Apollonian:initialConfig from diagrams-contrib-1.3.0.5, A

Percentage Accurate: 69.6% → 91.2%

Time: 11.9s

Alternatives: 10

Speedup: 0.9×

• 42.0% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))

C

double code(double x, double y, double z) {
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (((x * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function

Java

public static double code(double x, double y, double z) {
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}

Python

def code(x, y, z):
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]

Initial Program: 69.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))

C

double code(double x, double y, double z) {
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (((x * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function

Java

public static double code(double x, double y, double z) {
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}

Python

def code(x, y, z):
	return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]

Alternative 1: 91.2% accurate, 0.1× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \begin{array}{l} \mathbf{if}\;y_m \leq 1.8 \cdot 10^{+147}:\\ \;\;\;\;\frac{\mathsf{fma}\left(y_m - z, y_m + z, x \cdot x\right)}{y_m \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;\left(y_m - z\right) \cdot \left(\left(y_m + z\right) \cdot \frac{0.5}{y_m}\right)\\ \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (*
  y_s
  (if (<= y_m 1.8e+147)
    (/ (fma (- y_m z) (+ y_m z) (* x x)) (* y_m 2.0))
    (* (- y_m z) (* (+ y_m z) (/ 0.5 y_m))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if (y_m <= 1.8e+147) {
		tmp = fma((y_m - z), (y_m + z), (x * x)) / (y_m * 2.0);
	} else {
		tmp = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	}
	return y_s * tmp;
}

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	tmp = 0.0
	if (y_m <= 1.8e+147)
		tmp = Float64(fma(Float64(y_m - z), Float64(y_m + z), Float64(x * x)) / Float64(y_m * 2.0));
	else
		tmp = Float64(Float64(y_m - z) * Float64(Float64(y_m + z) * Float64(0.5 / y_m)));
	end
	return Float64(y_s * tmp)
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * If[LessEqual[y$95$m, 1.8e+147], N[(N[(N[(y$95$m - z), $MachinePrecision] * N[(y$95$m + z), $MachinePrecision] + N[(x * x), $MachinePrecision]), $MachinePrecision] / N[(y$95$m * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(y$95$m - z), $MachinePrecision] * N[(N[(y$95$m + z), $MachinePrecision] * N[(0.5 / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 43.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ \begin{array}{l} t_0 := \frac{z}{y_m} \cdot \frac{z}{-2}\\ t_1 := \left(y_m - z\right) \cdot 0.5\\ t_2 := \frac{x}{y_m} \cdot \frac{x}{2}\\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 2.5 \cdot 10^{-157}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2 \cdot 10^{-115}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.9 \cdot 10^{-47}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 9.8 \cdot 10^{-28}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq 0.02:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.3 \cdot 10^{+32}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.65 \cdot 10^{+69}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (let* ((t_0 (* (/ z y_m) (/ z -2.0)))
        (t_1 (* (- y_m z) 0.5))
        (t_2 (* (/ x y_m) (/ x 2.0))))
   (*
    y_s
    (if (<= x 2.5e-157)
      t_1
      (if (<= x 2e-115)
        t_0
        (if (<= x 1.9e-47)
          t_1
          (if (<= x 9.8e-28)
            t_2
            (if (<= x 0.02)
              t_1
              (if (<= x 2.3e+32) t_0 (if (<= x 1.65e+69) t_1 t_2))))))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double t_2 = (x / y_m) * (x / 2.0);
	double tmp;
	if (x <= 2.5e-157) {
		tmp = t_1;
	} else if (x <= 2e-115) {
		tmp = t_0;
	} else if (x <= 1.9e-47) {
		tmp = t_1;
	} else if (x <= 9.8e-28) {
		tmp = t_2;
	} else if (x <= 0.02) {
		tmp = t_1;
	} else if (x <= 2.3e+32) {
		tmp = t_0;
	} else if (x <= 1.65e+69) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (z / y_m) * (z / (-2.0d0))
    t_1 = (y_m - z) * 0.5d0
    t_2 = (x / y_m) * (x / 2.0d0)
    if (x <= 2.5d-157) then
        tmp = t_1
    else if (x <= 2d-115) then
        tmp = t_0
    else if (x <= 1.9d-47) then
        tmp = t_1
    else if (x <= 9.8d-28) then
        tmp = t_2
    else if (x <= 0.02d0) then
        tmp = t_1
    else if (x <= 2.3d+32) then
        tmp = t_0
    else if (x <= 1.65d+69) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double t_2 = (x / y_m) * (x / 2.0);
	double tmp;
	if (x <= 2.5e-157) {
		tmp = t_1;
	} else if (x <= 2e-115) {
		tmp = t_0;
	} else if (x <= 1.9e-47) {
		tmp = t_1;
	} else if (x <= 9.8e-28) {
		tmp = t_2;
	} else if (x <= 0.02) {
		tmp = t_1;
	} else if (x <= 2.3e+32) {
		tmp = t_0;
	} else if (x <= 1.65e+69) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	t_0 = (z / y_m) * (z / -2.0)
	t_1 = (y_m - z) * 0.5
	t_2 = (x / y_m) * (x / 2.0)
	tmp = 0
	if x <= 2.5e-157:
		tmp = t_1
	elif x <= 2e-115:
		tmp = t_0
	elif x <= 1.9e-47:
		tmp = t_1
	elif x <= 9.8e-28:
		tmp = t_2
	elif x <= 0.02:
		tmp = t_1
	elif x <= 2.3e+32:
		tmp = t_0
	elif x <= 1.65e+69:
		tmp = t_1
	else:
		tmp = t_2
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	t_0 = Float64(Float64(z / y_m) * Float64(z / -2.0))
	t_1 = Float64(Float64(y_m - z) * 0.5)
	t_2 = Float64(Float64(x / y_m) * Float64(x / 2.0))
	tmp = 0.0
	if (x <= 2.5e-157)
		tmp = t_1;
	elseif (x <= 2e-115)
		tmp = t_0;
	elseif (x <= 1.9e-47)
		tmp = t_1;
	elseif (x <= 9.8e-28)
		tmp = t_2;
	elseif (x <= 0.02)
		tmp = t_1;
	elseif (x <= 2.3e+32)
		tmp = t_0;
	elseif (x <= 1.65e+69)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	t_0 = (z / y_m) * (z / -2.0);
	t_1 = (y_m - z) * 0.5;
	t_2 = (x / y_m) * (x / 2.0);
	tmp = 0.0;
	if (x <= 2.5e-157)
		tmp = t_1;
	elseif (x <= 2e-115)
		tmp = t_0;
	elseif (x <= 1.9e-47)
		tmp = t_1;
	elseif (x <= 9.8e-28)
		tmp = t_2;
	elseif (x <= 0.02)
		tmp = t_1;
	elseif (x <= 2.3e+32)
		tmp = t_0;
	elseif (x <= 1.65e+69)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := Block[{t$95$0 = N[(N[(z / y$95$m), $MachinePrecision] * N[(z / -2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y$95$m), $MachinePrecision] * N[(x / 2.0), $MachinePrecision]), $MachinePrecision]}, N[(y$95$s * If[LessEqual[x, 2.5e-157], t$95$1, If[LessEqual[x, 2e-115], t$95$0, If[LessEqual[x, 1.9e-47], t$95$1, If[LessEqual[x, 9.8e-28], t$95$2, If[LessEqual[x, 0.02], t$95$1, If[LessEqual[x, 2.3e+32], t$95$0, If[LessEqual[x, 1.65e+69], t$95$1, t$95$2]]]]]]]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 43.2% accurate, 0.7× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ \begin{array}{l} t_0 := \frac{z}{y_m} \cdot \frac{z}{-2}\\ t_1 := \left(y_m - z\right) \cdot 0.5\\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 7 \cdot 10^{-159}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.2 \cdot 10^{-115}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 2 \cdot 10^{-47}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 1.48 \cdot 10^{-27}:\\ \;\;\;\;\frac{x}{y_m \cdot \frac{2}{x}}\\ \mathbf{elif}\;x \leq 0.025:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{+32}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.42 \cdot 10^{+69}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y_m} \cdot \frac{x}{2}\\ \end{array} \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (let* ((t_0 (* (/ z y_m) (/ z -2.0))) (t_1 (* (- y_m z) 0.5)))
   (*
    y_s
    (if (<= x 7e-159)
      t_1
      (if (<= x 2.2e-115)
        t_0
        (if (<= x 2e-47)
          t_1
          (if (<= x 1.48e-27)
            (/ x (* y_m (/ 2.0 x)))
            (if (<= x 0.025)
              t_1
              (if (<= x 1.6e+32)
                t_0
                (if (<= x 1.42e+69) t_1 (* (/ x y_m) (/ x 2.0))))))))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double tmp;
	if (x <= 7e-159) {
		tmp = t_1;
	} else if (x <= 2.2e-115) {
		tmp = t_0;
	} else if (x <= 2e-47) {
		tmp = t_1;
	} else if (x <= 1.48e-27) {
		tmp = x / (y_m * (2.0 / x));
	} else if (x <= 0.025) {
		tmp = t_1;
	} else if (x <= 1.6e+32) {
		tmp = t_0;
	} else if (x <= 1.42e+69) {
		tmp = t_1;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (z / y_m) * (z / (-2.0d0))
    t_1 = (y_m - z) * 0.5d0
    if (x <= 7d-159) then
        tmp = t_1
    else if (x <= 2.2d-115) then
        tmp = t_0
    else if (x <= 2d-47) then
        tmp = t_1
    else if (x <= 1.48d-27) then
        tmp = x / (y_m * (2.0d0 / x))
    else if (x <= 0.025d0) then
        tmp = t_1
    else if (x <= 1.6d+32) then
        tmp = t_0
    else if (x <= 1.42d+69) then
        tmp = t_1
    else
        tmp = (x / y_m) * (x / 2.0d0)
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double tmp;
	if (x <= 7e-159) {
		tmp = t_1;
	} else if (x <= 2.2e-115) {
		tmp = t_0;
	} else if (x <= 2e-47) {
		tmp = t_1;
	} else if (x <= 1.48e-27) {
		tmp = x / (y_m * (2.0 / x));
	} else if (x <= 0.025) {
		tmp = t_1;
	} else if (x <= 1.6e+32) {
		tmp = t_0;
	} else if (x <= 1.42e+69) {
		tmp = t_1;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	t_0 = (z / y_m) * (z / -2.0)
	t_1 = (y_m - z) * 0.5
	tmp = 0
	if x <= 7e-159:
		tmp = t_1
	elif x <= 2.2e-115:
		tmp = t_0
	elif x <= 2e-47:
		tmp = t_1
	elif x <= 1.48e-27:
		tmp = x / (y_m * (2.0 / x))
	elif x <= 0.025:
		tmp = t_1
	elif x <= 1.6e+32:
		tmp = t_0
	elif x <= 1.42e+69:
		tmp = t_1
	else:
		tmp = (x / y_m) * (x / 2.0)
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	t_0 = Float64(Float64(z / y_m) * Float64(z / -2.0))
	t_1 = Float64(Float64(y_m - z) * 0.5)
	tmp = 0.0
	if (x <= 7e-159)
		tmp = t_1;
	elseif (x <= 2.2e-115)
		tmp = t_0;
	elseif (x <= 2e-47)
		tmp = t_1;
	elseif (x <= 1.48e-27)
		tmp = Float64(x / Float64(y_m * Float64(2.0 / x)));
	elseif (x <= 0.025)
		tmp = t_1;
	elseif (x <= 1.6e+32)
		tmp = t_0;
	elseif (x <= 1.42e+69)
		tmp = t_1;
	else
		tmp = Float64(Float64(x / y_m) * Float64(x / 2.0));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	t_0 = (z / y_m) * (z / -2.0);
	t_1 = (y_m - z) * 0.5;
	tmp = 0.0;
	if (x <= 7e-159)
		tmp = t_1;
	elseif (x <= 2.2e-115)
		tmp = t_0;
	elseif (x <= 2e-47)
		tmp = t_1;
	elseif (x <= 1.48e-27)
		tmp = x / (y_m * (2.0 / x));
	elseif (x <= 0.025)
		tmp = t_1;
	elseif (x <= 1.6e+32)
		tmp = t_0;
	elseif (x <= 1.42e+69)
		tmp = t_1;
	else
		tmp = (x / y_m) * (x / 2.0);
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := Block[{t$95$0 = N[(N[(z / y$95$m), $MachinePrecision] * N[(z / -2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision]}, N[(y$95$s * If[LessEqual[x, 7e-159], t$95$1, If[LessEqual[x, 2.2e-115], t$95$0, If[LessEqual[x, 2e-47], t$95$1, If[LessEqual[x, 1.48e-27], N[(x / N[(y$95$m * N[(2.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.025], t$95$1, If[LessEqual[x, 1.6e+32], t$95$0, If[LessEqual[x, 1.42e+69], t$95$1, N[(N[(x / y$95$m), $MachinePrecision] * N[(x / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 43.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ \begin{array}{l} t_0 := \frac{z}{y_m} \cdot \frac{z}{-2}\\ t_1 := \left(y_m - z\right) \cdot 0.5\\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 4 \cdot 10^{-157}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.8 \cdot 10^{-115}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.8 \cdot 10^{-47}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 1.05 \cdot 10^{-27}:\\ \;\;\;\;\frac{x \cdot \left(-x\right)}{y_m \cdot -2}\\ \mathbf{elif}\;x \leq 0.0255:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.2 \cdot 10^{+33}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{+69}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y_m} \cdot \frac{x}{2}\\ \end{array} \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (let* ((t_0 (* (/ z y_m) (/ z -2.0))) (t_1 (* (- y_m z) 0.5)))
   (*
    y_s
    (if (<= x 4e-157)
      t_1
      (if (<= x 2.8e-115)
        t_0
        (if (<= x 1.8e-47)
          t_1
          (if (<= x 1.05e-27)
            (/ (* x (- x)) (* y_m -2.0))
            (if (<= x 0.0255)
              t_1
              (if (<= x 2.2e+33)
                t_0
                (if (<= x 1.02e+69) t_1 (* (/ x y_m) (/ x 2.0))))))))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double tmp;
	if (x <= 4e-157) {
		tmp = t_1;
	} else if (x <= 2.8e-115) {
		tmp = t_0;
	} else if (x <= 1.8e-47) {
		tmp = t_1;
	} else if (x <= 1.05e-27) {
		tmp = (x * -x) / (y_m * -2.0);
	} else if (x <= 0.0255) {
		tmp = t_1;
	} else if (x <= 2.2e+33) {
		tmp = t_0;
	} else if (x <= 1.02e+69) {
		tmp = t_1;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (z / y_m) * (z / (-2.0d0))
    t_1 = (y_m - z) * 0.5d0
    if (x <= 4d-157) then
        tmp = t_1
    else if (x <= 2.8d-115) then
        tmp = t_0
    else if (x <= 1.8d-47) then
        tmp = t_1
    else if (x <= 1.05d-27) then
        tmp = (x * -x) / (y_m * (-2.0d0))
    else if (x <= 0.0255d0) then
        tmp = t_1
    else if (x <= 2.2d+33) then
        tmp = t_0
    else if (x <= 1.02d+69) then
        tmp = t_1
    else
        tmp = (x / y_m) * (x / 2.0d0)
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double t_0 = (z / y_m) * (z / -2.0);
	double t_1 = (y_m - z) * 0.5;
	double tmp;
	if (x <= 4e-157) {
		tmp = t_1;
	} else if (x <= 2.8e-115) {
		tmp = t_0;
	} else if (x <= 1.8e-47) {
		tmp = t_1;
	} else if (x <= 1.05e-27) {
		tmp = (x * -x) / (y_m * -2.0);
	} else if (x <= 0.0255) {
		tmp = t_1;
	} else if (x <= 2.2e+33) {
		tmp = t_0;
	} else if (x <= 1.02e+69) {
		tmp = t_1;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	t_0 = (z / y_m) * (z / -2.0)
	t_1 = (y_m - z) * 0.5
	tmp = 0
	if x <= 4e-157:
		tmp = t_1
	elif x <= 2.8e-115:
		tmp = t_0
	elif x <= 1.8e-47:
		tmp = t_1
	elif x <= 1.05e-27:
		tmp = (x * -x) / (y_m * -2.0)
	elif x <= 0.0255:
		tmp = t_1
	elif x <= 2.2e+33:
		tmp = t_0
	elif x <= 1.02e+69:
		tmp = t_1
	else:
		tmp = (x / y_m) * (x / 2.0)
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	t_0 = Float64(Float64(z / y_m) * Float64(z / -2.0))
	t_1 = Float64(Float64(y_m - z) * 0.5)
	tmp = 0.0
	if (x <= 4e-157)
		tmp = t_1;
	elseif (x <= 2.8e-115)
		tmp = t_0;
	elseif (x <= 1.8e-47)
		tmp = t_1;
	elseif (x <= 1.05e-27)
		tmp = Float64(Float64(x * Float64(-x)) / Float64(y_m * -2.0));
	elseif (x <= 0.0255)
		tmp = t_1;
	elseif (x <= 2.2e+33)
		tmp = t_0;
	elseif (x <= 1.02e+69)
		tmp = t_1;
	else
		tmp = Float64(Float64(x / y_m) * Float64(x / 2.0));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	t_0 = (z / y_m) * (z / -2.0);
	t_1 = (y_m - z) * 0.5;
	tmp = 0.0;
	if (x <= 4e-157)
		tmp = t_1;
	elseif (x <= 2.8e-115)
		tmp = t_0;
	elseif (x <= 1.8e-47)
		tmp = t_1;
	elseif (x <= 1.05e-27)
		tmp = (x * -x) / (y_m * -2.0);
	elseif (x <= 0.0255)
		tmp = t_1;
	elseif (x <= 2.2e+33)
		tmp = t_0;
	elseif (x <= 1.02e+69)
		tmp = t_1;
	else
		tmp = (x / y_m) * (x / 2.0);
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := Block[{t$95$0 = N[(N[(z / y$95$m), $MachinePrecision] * N[(z / -2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision]}, N[(y$95$s * If[LessEqual[x, 4e-157], t$95$1, If[LessEqual[x, 2.8e-115], t$95$0, If[LessEqual[x, 1.8e-47], t$95$1, If[LessEqual[x, 1.05e-27], N[(N[(x * (-x)), $MachinePrecision] / N[(y$95$m * -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.0255], t$95$1, If[LessEqual[x, 2.2e+33], t$95$0, If[LessEqual[x, 1.02e+69], t$95$1, N[(N[(x / y$95$m), $MachinePrecision] * N[(x / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 72.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ \begin{array}{l} t_0 := \left(y_m - z\right) \cdot \left(\left(y_m + z\right) \cdot \frac{0.5}{y_m}\right)\\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 2 \cdot 10^{-47}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 9 \cdot 10^{-28}:\\ \;\;\;\;\frac{x \cdot \left(-x\right)}{y_m \cdot -2}\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{+86}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 6.2 \cdot 10^{+107}:\\ \;\;\;\;\frac{x}{y_m} \cdot \frac{x}{2}\\ \mathbf{elif}\;x \leq 4.2 \cdot 10^{+170}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y_m \cdot \frac{2}{x}}\\ \end{array} \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (let* ((t_0 (* (- y_m z) (* (+ y_m z) (/ 0.5 y_m)))))
   (*
    y_s
    (if (<= x 2e-47)
      t_0
      (if (<= x 9e-28)
        (/ (* x (- x)) (* y_m -2.0))
        (if (<= x 1.5e+86)
          t_0
          (if (<= x 6.2e+107)
            (* (/ x y_m) (/ x 2.0))
            (if (<= x 4.2e+170) t_0 (/ x (* y_m (/ 2.0 x)))))))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double t_0 = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	double tmp;
	if (x <= 2e-47) {
		tmp = t_0;
	} else if (x <= 9e-28) {
		tmp = (x * -x) / (y_m * -2.0);
	} else if (x <= 1.5e+86) {
		tmp = t_0;
	} else if (x <= 6.2e+107) {
		tmp = (x / y_m) * (x / 2.0);
	} else if (x <= 4.2e+170) {
		tmp = t_0;
	} else {
		tmp = x / (y_m * (2.0 / x));
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (y_m - z) * ((y_m + z) * (0.5d0 / y_m))
    if (x <= 2d-47) then
        tmp = t_0
    else if (x <= 9d-28) then
        tmp = (x * -x) / (y_m * (-2.0d0))
    else if (x <= 1.5d+86) then
        tmp = t_0
    else if (x <= 6.2d+107) then
        tmp = (x / y_m) * (x / 2.0d0)
    else if (x <= 4.2d+170) then
        tmp = t_0
    else
        tmp = x / (y_m * (2.0d0 / x))
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double t_0 = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	double tmp;
	if (x <= 2e-47) {
		tmp = t_0;
	} else if (x <= 9e-28) {
		tmp = (x * -x) / (y_m * -2.0);
	} else if (x <= 1.5e+86) {
		tmp = t_0;
	} else if (x <= 6.2e+107) {
		tmp = (x / y_m) * (x / 2.0);
	} else if (x <= 4.2e+170) {
		tmp = t_0;
	} else {
		tmp = x / (y_m * (2.0 / x));
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	t_0 = (y_m - z) * ((y_m + z) * (0.5 / y_m))
	tmp = 0
	if x <= 2e-47:
		tmp = t_0
	elif x <= 9e-28:
		tmp = (x * -x) / (y_m * -2.0)
	elif x <= 1.5e+86:
		tmp = t_0
	elif x <= 6.2e+107:
		tmp = (x / y_m) * (x / 2.0)
	elif x <= 4.2e+170:
		tmp = t_0
	else:
		tmp = x / (y_m * (2.0 / x))
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	t_0 = Float64(Float64(y_m - z) * Float64(Float64(y_m + z) * Float64(0.5 / y_m)))
	tmp = 0.0
	if (x <= 2e-47)
		tmp = t_0;
	elseif (x <= 9e-28)
		tmp = Float64(Float64(x * Float64(-x)) / Float64(y_m * -2.0));
	elseif (x <= 1.5e+86)
		tmp = t_0;
	elseif (x <= 6.2e+107)
		tmp = Float64(Float64(x / y_m) * Float64(x / 2.0));
	elseif (x <= 4.2e+170)
		tmp = t_0;
	else
		tmp = Float64(x / Float64(y_m * Float64(2.0 / x)));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	t_0 = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	tmp = 0.0;
	if (x <= 2e-47)
		tmp = t_0;
	elseif (x <= 9e-28)
		tmp = (x * -x) / (y_m * -2.0);
	elseif (x <= 1.5e+86)
		tmp = t_0;
	elseif (x <= 6.2e+107)
		tmp = (x / y_m) * (x / 2.0);
	elseif (x <= 4.2e+170)
		tmp = t_0;
	else
		tmp = x / (y_m * (2.0 / x));
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := Block[{t$95$0 = N[(N[(y$95$m - z), $MachinePrecision] * N[(N[(y$95$m + z), $MachinePrecision] * N[(0.5 / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(y$95$s * If[LessEqual[x, 2e-47], t$95$0, If[LessEqual[x, 9e-28], N[(N[(x * (-x)), $MachinePrecision] / N[(y$95$m * -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.5e+86], t$95$0, If[LessEqual[x, 6.2e+107], N[(N[(x / y$95$m), $MachinePrecision] * N[(x / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e+170], t$95$0, N[(x / N[(y$95$m * N[(2.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 43.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 2 \cdot 10^{-47} \lor \neg \left(x \leq 9 \cdot 10^{-28}\right) \land \left(x \leq 50000000000000 \lor \neg \left(x \leq 7 \cdot 10^{+42}\right) \land x \leq 1.28 \cdot 10^{+69}\right):\\ \;\;\;\;\left(y_m - z\right) \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(x \cdot \frac{0.5}{y_m}\right)\\ \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (*
  y_s
  (if (or (<= x 2e-47)
          (and (not (<= x 9e-28))
               (or (<= x 50000000000000.0)
                   (and (not (<= x 7e+42)) (<= x 1.28e+69)))))
    (* (- y_m z) 0.5)
    (* x (* x (/ 0.5 y_m))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if ((x <= 2e-47) || (!(x <= 9e-28) && ((x <= 50000000000000.0) || (!(x <= 7e+42) && (x <= 1.28e+69))))) {
		tmp = (y_m - z) * 0.5;
	} else {
		tmp = x * (x * (0.5 / y_m));
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: tmp
    if ((x <= 2d-47) .or. (.not. (x <= 9d-28)) .and. (x <= 50000000000000.0d0) .or. (.not. (x <= 7d+42)) .and. (x <= 1.28d+69)) then
        tmp = (y_m - z) * 0.5d0
    else
        tmp = x * (x * (0.5d0 / y_m))
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if ((x <= 2e-47) || (!(x <= 9e-28) && ((x <= 50000000000000.0) || (!(x <= 7e+42) && (x <= 1.28e+69))))) {
		tmp = (y_m - z) * 0.5;
	} else {
		tmp = x * (x * (0.5 / y_m));
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	tmp = 0
	if (x <= 2e-47) or (not (x <= 9e-28) and ((x <= 50000000000000.0) or (not (x <= 7e+42) and (x <= 1.28e+69)))):
		tmp = (y_m - z) * 0.5
	else:
		tmp = x * (x * (0.5 / y_m))
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	tmp = 0.0
	if ((x <= 2e-47) || (!(x <= 9e-28) && ((x <= 50000000000000.0) || (!(x <= 7e+42) && (x <= 1.28e+69)))))
		tmp = Float64(Float64(y_m - z) * 0.5);
	else
		tmp = Float64(x * Float64(x * Float64(0.5 / y_m)));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	tmp = 0.0;
	if ((x <= 2e-47) || (~((x <= 9e-28)) && ((x <= 50000000000000.0) || (~((x <= 7e+42)) && (x <= 1.28e+69)))))
		tmp = (y_m - z) * 0.5;
	else
		tmp = x * (x * (0.5 / y_m));
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * If[Or[LessEqual[x, 2e-47], And[N[Not[LessEqual[x, 9e-28]], $MachinePrecision], Or[LessEqual[x, 50000000000000.0], And[N[Not[LessEqual[x, 7e+42]], $MachinePrecision], LessEqual[x, 1.28e+69]]]]], N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision], N[(x * N[(x * N[(0.5 / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 43.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \begin{array}{l} \mathbf{if}\;x \leq 2 \cdot 10^{-47} \lor \neg \left(x \leq 5.2 \cdot 10^{-27}\right) \land \left(x \leq 245000000000 \lor \neg \left(x \leq 7.5 \cdot 10^{+43}\right) \land x \leq 9.5 \cdot 10^{+68}\right):\\ \;\;\;\;\left(y_m - z\right) \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y_m} \cdot \frac{x}{2}\\ \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (*
  y_s
  (if (or (<= x 2e-47)
          (and (not (<= x 5.2e-27))
               (or (<= x 245000000000.0)
                   (and (not (<= x 7.5e+43)) (<= x 9.5e+68)))))
    (* (- y_m z) 0.5)
    (* (/ x y_m) (/ x 2.0)))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if ((x <= 2e-47) || (!(x <= 5.2e-27) && ((x <= 245000000000.0) || (!(x <= 7.5e+43) && (x <= 9.5e+68))))) {
		tmp = (y_m - z) * 0.5;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: tmp
    if ((x <= 2d-47) .or. (.not. (x <= 5.2d-27)) .and. (x <= 245000000000.0d0) .or. (.not. (x <= 7.5d+43)) .and. (x <= 9.5d+68)) then
        tmp = (y_m - z) * 0.5d0
    else
        tmp = (x / y_m) * (x / 2.0d0)
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if ((x <= 2e-47) || (!(x <= 5.2e-27) && ((x <= 245000000000.0) || (!(x <= 7.5e+43) && (x <= 9.5e+68))))) {
		tmp = (y_m - z) * 0.5;
	} else {
		tmp = (x / y_m) * (x / 2.0);
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	tmp = 0
	if (x <= 2e-47) or (not (x <= 5.2e-27) and ((x <= 245000000000.0) or (not (x <= 7.5e+43) and (x <= 9.5e+68)))):
		tmp = (y_m - z) * 0.5
	else:
		tmp = (x / y_m) * (x / 2.0)
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	tmp = 0.0
	if ((x <= 2e-47) || (!(x <= 5.2e-27) && ((x <= 245000000000.0) || (!(x <= 7.5e+43) && (x <= 9.5e+68)))))
		tmp = Float64(Float64(y_m - z) * 0.5);
	else
		tmp = Float64(Float64(x / y_m) * Float64(x / 2.0));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	tmp = 0.0;
	if ((x <= 2e-47) || (~((x <= 5.2e-27)) && ((x <= 245000000000.0) || (~((x <= 7.5e+43)) && (x <= 9.5e+68)))))
		tmp = (y_m - z) * 0.5;
	else
		tmp = (x / y_m) * (x / 2.0);
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * If[Or[LessEqual[x, 2e-47], And[N[Not[LessEqual[x, 5.2e-27]], $MachinePrecision], Or[LessEqual[x, 245000000000.0], And[N[Not[LessEqual[x, 7.5e+43]], $MachinePrecision], LessEqual[x, 9.5e+68]]]]], N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision], N[(N[(x / y$95$m), $MachinePrecision] * N[(x / 2.0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 89.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \begin{array}{l} \mathbf{if}\;y_m \leq 2.15 \cdot 10^{+147}:\\ \;\;\;\;\frac{\left(x \cdot x + y_m \cdot y_m\right) - z \cdot z}{y_m \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;\left(y_m - z\right) \cdot \left(\left(y_m + z\right) \cdot \frac{0.5}{y_m}\right)\\ \end{array} \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z)
 :precision binary64
 (*
  y_s
  (if (<= y_m 2.15e+147)
    (/ (- (+ (* x x) (* y_m y_m)) (* z z)) (* y_m 2.0))
    (* (- y_m z) (* (+ y_m z) (/ 0.5 y_m))))))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if (y_m <= 2.15e+147) {
		tmp = (((x * x) + (y_m * y_m)) - (z * z)) / (y_m * 2.0);
	} else {
		tmp = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	}
	return y_s * tmp;
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y_m <= 2.15d+147) then
        tmp = (((x * x) + (y_m * y_m)) - (z * z)) / (y_m * 2.0d0)
    else
        tmp = (y_m - z) * ((y_m + z) * (0.5d0 / y_m))
    end if
    code = y_s * tmp
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	double tmp;
	if (y_m <= 2.15e+147) {
		tmp = (((x * x) + (y_m * y_m)) - (z * z)) / (y_m * 2.0);
	} else {
		tmp = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	}
	return y_s * tmp;
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	tmp = 0
	if y_m <= 2.15e+147:
		tmp = (((x * x) + (y_m * y_m)) - (z * z)) / (y_m * 2.0)
	else:
		tmp = (y_m - z) * ((y_m + z) * (0.5 / y_m))
	return y_s * tmp

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	tmp = 0.0
	if (y_m <= 2.15e+147)
		tmp = Float64(Float64(Float64(Float64(x * x) + Float64(y_m * y_m)) - Float64(z * z)) / Float64(y_m * 2.0));
	else
		tmp = Float64(Float64(y_m - z) * Float64(Float64(y_m + z) * Float64(0.5 / y_m)));
	end
	return Float64(y_s * tmp)
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp_2 = code(y_s, x, y_m, z)
	tmp = 0.0;
	if (y_m <= 2.15e+147)
		tmp = (((x * x) + (y_m * y_m)) - (z * z)) / (y_m * 2.0);
	else
		tmp = (y_m - z) * ((y_m + z) * (0.5 / y_m));
	end
	tmp_2 = y_s * tmp;
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * If[LessEqual[y$95$m, 2.15e+147], N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y$95$m * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(y$95$m - z), $MachinePrecision] * N[(N[(y$95$m + z), $MachinePrecision] * N[(0.5 / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 34.4% accurate, 3.0× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \left(\left(y_m - z\right) \cdot 0.5\right) \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z) :precision binary64 (* y_s (* (- y_m z) 0.5)))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	return y_s * ((y_m - z) * 0.5);
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    code = y_s * ((y_m - z) * 0.5d0)
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	return y_s * ((y_m - z) * 0.5);
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	return y_s * ((y_m - z) * 0.5)

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	return Float64(y_s * Float64(Float64(y_m - z) * 0.5))
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp = code(y_s, x, y_m, z)
	tmp = y_s * ((y_m - z) * 0.5);
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * N[(N[(y$95$m - z), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 33.8% accurate, 5.0× speedup

Math

\[\begin{array}{l} y_m = \left|y\right| \\ y_s = \mathsf{copysign}\left(1, y\right) \\ y_s \cdot \left(y_m \cdot 0.5\right) \end{array} \]

FPCore

y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
(FPCore (y_s x y_m z) :precision binary64 (* y_s (* y_m 0.5)))

C

y_m = fabs(y);
y_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z) {
	return y_s * (y_m * 0.5);
}

Fortran

y_m = abs(y)
y_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z)
    real(8), intent (in) :: y_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y_m
    real(8), intent (in) :: z
    code = y_s * (y_m * 0.5d0)
end function

Java

y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z) {
	return y_s * (y_m * 0.5);
}

Python

y_m = math.fabs(y)
y_s = math.copysign(1.0, y)
def code(y_s, x, y_m, z):
	return y_s * (y_m * 0.5)

Julia

y_m = abs(y)
y_s = copysign(1.0, y)
function code(y_s, x, y_m, z)
	return Float64(y_s * Float64(y_m * 0.5))
end

MATLAB

y_m = abs(y);
y_s = sign(y) * abs(1.0);
function tmp = code(y_s, x, y_m, z)
	tmp = y_s * (y_m * 0.5);
end

Wolfram

y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z_] := N[(y$95$s * N[(y$95$m * 0.5), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Developer target: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ y \cdot 0.5 - \left(\frac{0.5}{y} \cdot \left(z + x\right)\right) \cdot \left(z - x\right) \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (- (* y 0.5) (* (* (/ 0.5 y) (+ z x)) (- z x))))

C

double code(double x, double y, double z) {
	return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (y * 0.5d0) - (((0.5d0 / y) * (z + x)) * (z - x))
end function

Java

public static double code(double x, double y, double z) {
	return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}

Python

def code(x, y, z):
	return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x))

Julia

function code(x, y, z)
	return Float64(Float64(y * 0.5) - Float64(Float64(Float64(0.5 / y) * Float64(z + x)) * Float64(z - x)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
end

Wolfram

code[x_, y_, z_] := N[(N[(y * 0.5), $MachinePrecision] - N[(N[(N[(0.5 / y), $MachinePrecision] * N[(z + x), $MachinePrecision]), $MachinePrecision] * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2023350 
(FPCore (x y z)
  :name "Diagrams.TwoD.Apollonian:initialConfig from diagrams-contrib-1.3.0.5, A"
  :precision binary64

  :herbie-target
  (- (* y 0.5) (* (* (/ 0.5 y) (+ z x)) (- z x)))

  (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))