(/ z0 (* z1 (* z2 PI)))

Percentage Accurate: 92.3% → 99.6%

Time: 2.2s

Alternatives: 7

Speedup: 1.0×

Specification

Math

\[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (/ z0 (* z1 (* z2 PI))))

C

double code(double z0, double z1, double z2) {
	return z0 / (z1 * (z2 * ((double) M_PI)));
}

Java

public static double code(double z0, double z1, double z2) {
	return z0 / (z1 * (z2 * Math.PI));
}

Python

def code(z0, z1, z2):
	return z0 / (z1 * (z2 * math.pi))

Julia

function code(z0, z1, z2)
	return Float64(z0 / Float64(z1 * Float64(z2 * pi)))
end

MATLAB

function tmp = code(z0, z1, z2)
	tmp = z0 / (z1 * (z2 * pi));
end

Wolfram

code[z0_, z1_, z2_] := N[(z0 / N[(z1 * N[(z2 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 92.3% accurate, 1.0× speedup

Math

\[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (/ z0 (* z1 (* z2 PI))))

C

double code(double z0, double z1, double z2) {
	return z0 / (z1 * (z2 * ((double) M_PI)));
}

Java

public static double code(double z0, double z1, double z2) {
	return z0 / (z1 * (z2 * Math.PI));
}

Python

def code(z0, z1, z2):
	return z0 / (z1 * (z2 * math.pi))

Julia

function code(z0, z1, z2)
	return Float64(z0 / Float64(z1 * Float64(z2 * pi)))
end

MATLAB

function tmp = code(z0, z1, z2)
	tmp = z0 / (z1 * (z2 * pi));
end

Wolfram

code[z0_, z1_, z2_] := N[(z0 / N[(z1 * N[(z2 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.6% accurate, 0.0× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\left|z1\right|, \left|z2\right|\right)\\ t_1 := \mathsf{max}\left(\left|z1\right|, \left|z2\right|\right)\\ \mathsf{copysign}\left(1, z0\right) \cdot \left(\mathsf{copysign}\left(1, z1\right) \cdot \left(\mathsf{copysign}\left(1, z2\right) \cdot \begin{array}{l} \mathbf{if}\;\left|z0\right| \leq \frac{7737125245533627}{154742504910672534362390528}:\\ \;\;\;\;\frac{\frac{\frac{-\left|z0\right|}{\pi}}{t\_0}}{-t\_1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\left|z0\right|}{t\_1}}{\pi \cdot t\_0}\\ \end{array}\right)\right) \end{array} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (let* ((t_0 (fmin (fabs z1) (fabs z2)))
       (t_1 (fmax (fabs z1) (fabs z2))))
  (*
   (copysign 1 z0)
   (*
    (copysign 1 z1)
    (*
     (copysign 1 z2)
     (if (<= (fabs z0) 7737125245533627/154742504910672534362390528)
       (/ (/ (/ (- (fabs z0)) PI) t_0) (- t_1))
       (/ (/ (fabs z0) t_1) (* PI t_0))))))))

C

double code(double z0, double z1, double z2) {
	double t_0 = fmin(fabs(z1), fabs(z2));
	double t_1 = fmax(fabs(z1), fabs(z2));
	double tmp;
	if (fabs(z0) <= 5e-11) {
		tmp = ((-fabs(z0) / ((double) M_PI)) / t_0) / -t_1;
	} else {
		tmp = (fabs(z0) / t_1) / (((double) M_PI) * t_0);
	}
	return copysign(1.0, z0) * (copysign(1.0, z1) * (copysign(1.0, z2) * tmp));
}

Java

public static double code(double z0, double z1, double z2) {
	double t_0 = fmin(Math.abs(z1), Math.abs(z2));
	double t_1 = fmax(Math.abs(z1), Math.abs(z2));
	double tmp;
	if (Math.abs(z0) <= 5e-11) {
		tmp = ((-Math.abs(z0) / Math.PI) / t_0) / -t_1;
	} else {
		tmp = (Math.abs(z0) / t_1) / (Math.PI * t_0);
	}
	return Math.copySign(1.0, z0) * (Math.copySign(1.0, z1) * (Math.copySign(1.0, z2) * tmp));
}

Python

def code(z0, z1, z2):
	t_0 = fmin(math.fabs(z1), math.fabs(z2))
	t_1 = fmax(math.fabs(z1), math.fabs(z2))
	tmp = 0
	if math.fabs(z0) <= 5e-11:
		tmp = ((-math.fabs(z0) / math.pi) / t_0) / -t_1
	else:
		tmp = (math.fabs(z0) / t_1) / (math.pi * t_0)
	return math.copysign(1.0, z0) * (math.copysign(1.0, z1) * (math.copysign(1.0, z2) * tmp))

Julia

function code(z0, z1, z2)
	t_0 = fmin(abs(z1), abs(z2))
	t_1 = fmax(abs(z1), abs(z2))
	tmp = 0.0
	if (abs(z0) <= 5e-11)
		tmp = Float64(Float64(Float64(Float64(-abs(z0)) / pi) / t_0) / Float64(-t_1));
	else
		tmp = Float64(Float64(abs(z0) / t_1) / Float64(pi * t_0));
	end
	return Float64(copysign(1.0, z0) * Float64(copysign(1.0, z1) * Float64(copysign(1.0, z2) * tmp)))
end

MATLAB

function tmp_2 = code(z0, z1, z2)
	t_0 = min(abs(z1), abs(z2));
	t_1 = max(abs(z1), abs(z2));
	tmp = 0.0;
	if (abs(z0) <= 5e-11)
		tmp = ((-abs(z0) / pi) / t_0) / -t_1;
	else
		tmp = (abs(z0) / t_1) / (pi * t_0);
	end
	tmp_2 = (sign(z0) * abs(1.0)) * ((sign(z1) * abs(1.0)) * ((sign(z2) * abs(1.0)) * tmp));
end

Wolfram

code[z0_, z1_, z2_] := Block[{t$95$0 = N[Min[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z0]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z2]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[z0], $MachinePrecision], 7737125245533627/154742504910672534362390528], N[(N[(N[((-N[Abs[z0], $MachinePrecision]) / Pi), $MachinePrecision] / t$95$0), $MachinePrecision] / (-t$95$1)), $MachinePrecision], N[(N[(N[Abs[z0], $MachinePrecision] / t$95$1), $MachinePrecision] / N[(Pi * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z0 < 5.0000000000000002e-11

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{z2 \cdot \pi}} \]

      4. lift-*.f64 N/A

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{z2 \cdot \pi}} \]

      5. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{\frac{z0}{z1}}{z2}}{\pi}} \]

      6. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{\frac{z0}{z1}}{z2}}{\pi}} \]

      7. associate-/l/ N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{z1 \cdot z2}}}{\pi} \]

      8. lower-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{z1 \cdot z2}}}{\pi} \]

      9. *-commutative N/A

         \[\leadsto \frac{\frac{z0}{\color{blue}{z2 \cdot z1}}}{\pi} \]

      10. lower-*.f64 92.3%

          \[\leadsto \frac{\frac{z0}{\color{blue}{z2 \cdot z1}}}{\pi} \]

   3. Applied rewrites 92.3%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z2 \cdot z1}}{\pi}} \]
   4. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2 \cdot z1}}{\pi}} \]

      2. mult-flip N/A

         \[\leadsto \color{blue}{\frac{z0}{z2 \cdot z1} \cdot \frac{1}{\pi}} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z2 \cdot z1}} \cdot \frac{1}{\pi} \]

      4. associate-*l/ N/A

         \[\leadsto \color{blue}{\frac{z0 \cdot \frac{1}{\pi}}{z2 \cdot z1}} \]

      5. mult-flip N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{\pi}}}{z2 \cdot z1} \]

      6. frac-2neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{\mathsf{neg}\left(z2 \cdot z1\right)}} \]

      7. lift-*.f64 N/A

         \[\leadsto \frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{\mathsf{neg}\left(\color{blue}{z2 \cdot z1}\right)} \]

      8. *-commutative N/A

         \[\leadsto \frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{\mathsf{neg}\left(\color{blue}{z1 \cdot z2}\right)} \]

      9. distribute-rgt-neg-in N/A

         \[\leadsto \frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{\color{blue}{z1 \cdot \left(\mathsf{neg}\left(z2\right)\right)}} \]

      10. associate-/r* N/A

          \[\leadsto \color{blue}{\frac{\frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{z1}}{\mathsf{neg}\left(z2\right)}} \]

      11. lower-/.f64 N/A

          \[\leadsto \color{blue}{\frac{\frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{z1}}{\mathsf{neg}\left(z2\right)}} \]

      12. lower-/.f64 N/A

          \[\leadsto \frac{\color{blue}{\frac{\mathsf{neg}\left(\frac{z0}{\pi}\right)}{z1}}}{\mathsf{neg}\left(z2\right)} \]

      13. distribute-neg-frac N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\mathsf{neg}\left(z0\right)}{\pi}}}{z1}}{\mathsf{neg}\left(z2\right)} \]

      14. lower-/.f64 N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\mathsf{neg}\left(z0\right)}{\pi}}}{z1}}{\mathsf{neg}\left(z2\right)} \]

      15. lower-neg.f64 N/A

          \[\leadsto \frac{\frac{\frac{\color{blue}{-z0}}{\pi}}{z1}}{\mathsf{neg}\left(z2\right)} \]

      16. lower-neg.f64 91.4%

          \[\leadsto \frac{\frac{\frac{-z0}{\pi}}{z1}}{\color{blue}{-z2}} \]

   5. Applied rewrites 91.4%

      \[\leadsto \color{blue}{\frac{\frac{\frac{-z0}{\pi}}{z1}}{-z2}} \]

   if 5.0000000000000002e-11 < z0

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. *-commutative N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right) \cdot z1}} \]

      4. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right)} \cdot z1} \]

      5. associate-*l* N/A

         \[\leadsto \frac{z0}{\color{blue}{z2 \cdot \left(\pi \cdot z1\right)}} \]

      6. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      8. lower-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{z2}}}{\pi \cdot z1} \]

      9. lower-*.f64 91.9%

         \[\leadsto \frac{\frac{z0}{z2}}{\color{blue}{\pi \cdot z1}} \]

   3. Applied rewrites 91.9%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 99.6% accurate, 0.0× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\left|z1\right|, \left|z2\right|\right)\\ t_1 := \mathsf{max}\left(\left|z1\right|, \left|z2\right|\right)\\ \mathsf{copysign}\left(1, z0\right) \cdot \left(\mathsf{copysign}\left(1, z1\right) \cdot \left(\mathsf{copysign}\left(1, z2\right) \cdot \begin{array}{l} \mathbf{if}\;\frac{\left|z0\right|}{t\_0 \cdot \left(t\_1 \cdot \pi\right)} \leq 2000000000000000000:\\ \;\;\;\;\frac{1}{\left(\frac{t\_0}{\left|z0\right|} \cdot t\_1\right) \cdot \pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\left|z0\right|}{t\_1}}{\pi \cdot t\_0}\\ \end{array}\right)\right) \end{array} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (let* ((t_0 (fmin (fabs z1) (fabs z2)))
       (t_1 (fmax (fabs z1) (fabs z2))))
  (*
   (copysign 1 z0)
   (*
    (copysign 1 z1)
    (*
     (copysign 1 z2)
     (if (<= (/ (fabs z0) (* t_0 (* t_1 PI))) 2000000000000000000)
       (/ 1 (* (* (/ t_0 (fabs z0)) t_1) PI))
       (/ (/ (fabs z0) t_1) (* PI t_0))))))))

C

double code(double z0, double z1, double z2) {
	double t_0 = fmin(fabs(z1), fabs(z2));
	double t_1 = fmax(fabs(z1), fabs(z2));
	double tmp;
	if ((fabs(z0) / (t_0 * (t_1 * ((double) M_PI)))) <= 2e+18) {
		tmp = 1.0 / (((t_0 / fabs(z0)) * t_1) * ((double) M_PI));
	} else {
		tmp = (fabs(z0) / t_1) / (((double) M_PI) * t_0);
	}
	return copysign(1.0, z0) * (copysign(1.0, z1) * (copysign(1.0, z2) * tmp));
}

Java

public static double code(double z0, double z1, double z2) {
	double t_0 = fmin(Math.abs(z1), Math.abs(z2));
	double t_1 = fmax(Math.abs(z1), Math.abs(z2));
	double tmp;
	if ((Math.abs(z0) / (t_0 * (t_1 * Math.PI))) <= 2e+18) {
		tmp = 1.0 / (((t_0 / Math.abs(z0)) * t_1) * Math.PI);
	} else {
		tmp = (Math.abs(z0) / t_1) / (Math.PI * t_0);
	}
	return Math.copySign(1.0, z0) * (Math.copySign(1.0, z1) * (Math.copySign(1.0, z2) * tmp));
}

Python

def code(z0, z1, z2):
	t_0 = fmin(math.fabs(z1), math.fabs(z2))
	t_1 = fmax(math.fabs(z1), math.fabs(z2))
	tmp = 0
	if (math.fabs(z0) / (t_0 * (t_1 * math.pi))) <= 2e+18:
		tmp = 1.0 / (((t_0 / math.fabs(z0)) * t_1) * math.pi)
	else:
		tmp = (math.fabs(z0) / t_1) / (math.pi * t_0)
	return math.copysign(1.0, z0) * (math.copysign(1.0, z1) * (math.copysign(1.0, z2) * tmp))

Julia

function code(z0, z1, z2)
	t_0 = fmin(abs(z1), abs(z2))
	t_1 = fmax(abs(z1), abs(z2))
	tmp = 0.0
	if (Float64(abs(z0) / Float64(t_0 * Float64(t_1 * pi))) <= 2e+18)
		tmp = Float64(1.0 / Float64(Float64(Float64(t_0 / abs(z0)) * t_1) * pi));
	else
		tmp = Float64(Float64(abs(z0) / t_1) / Float64(pi * t_0));
	end
	return Float64(copysign(1.0, z0) * Float64(copysign(1.0, z1) * Float64(copysign(1.0, z2) * tmp)))
end

MATLAB

function tmp_2 = code(z0, z1, z2)
	t_0 = min(abs(z1), abs(z2));
	t_1 = max(abs(z1), abs(z2));
	tmp = 0.0;
	if ((abs(z0) / (t_0 * (t_1 * pi))) <= 2e+18)
		tmp = 1.0 / (((t_0 / abs(z0)) * t_1) * pi);
	else
		tmp = (abs(z0) / t_1) / (pi * t_0);
	end
	tmp_2 = (sign(z0) * abs(1.0)) * ((sign(z1) * abs(1.0)) * ((sign(z2) * abs(1.0)) * tmp));
end

Wolfram

code[z0_, z1_, z2_] := Block[{t$95$0 = N[Min[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z0]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z2]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[z0], $MachinePrecision] / N[(t$95$0 * N[(t$95$1 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2000000000000000000], N[(1 / N[(N[(N[(t$95$0 / N[Abs[z0], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[z0], $MachinePrecision] / t$95$1), $MachinePrecision] / N[(Pi * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 z0 (*.f64 z1 (*.f64 z2 (PI.f64)))) < 2e18

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{z1 \cdot \left(z2 \cdot \pi\right)}{z0}}} \]

      3. lower-unsound-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{z1 \cdot \left(z2 \cdot \pi\right)}{z0}}} \]

      4. lower-unsound-/.f64 92.0%

         \[\leadsto \frac{1}{\color{blue}{\frac{z1 \cdot \left(z2 \cdot \pi\right)}{z0}}} \]

      5. lift-*.f64 N/A

         \[\leadsto \frac{1}{\frac{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}}{z0}} \]

      6. *-commutative N/A

         \[\leadsto \frac{1}{\frac{\color{blue}{\left(z2 \cdot \pi\right) \cdot z1}}{z0}} \]

      7. lower-*.f64 92.0%

         \[\leadsto \frac{1}{\frac{\color{blue}{\left(z2 \cdot \pi\right) \cdot z1}}{z0}} \]

      8. lift-*.f64 N/A

         \[\leadsto \frac{1}{\frac{\color{blue}{\left(z2 \cdot \pi\right)} \cdot z1}{z0}} \]

      9. *-commutative N/A

         \[\leadsto \frac{1}{\frac{\color{blue}{\left(\pi \cdot z2\right)} \cdot z1}{z0}} \]

      10. lower-*.f64 92.0%

          \[\leadsto \frac{1}{\frac{\color{blue}{\left(\pi \cdot z2\right)} \cdot z1}{z0}} \]

   3. Applied rewrites 92.0%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\pi \cdot z2\right) \cdot z1}{z0}}} \]
   4. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \frac{1}{\color{blue}{\frac{\left(\pi \cdot z2\right) \cdot z1}{z0}}} \]

      2. mult-flip N/A

         \[\leadsto \frac{1}{\color{blue}{\left(\left(\pi \cdot z2\right) \cdot z1\right) \cdot \frac{1}{z0}}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{1}{\color{blue}{\left(\left(\pi \cdot z2\right) \cdot z1\right)} \cdot \frac{1}{z0}} \]

      4. lift-*.f64 N/A

         \[\leadsto \frac{1}{\left(\color{blue}{\left(\pi \cdot z2\right)} \cdot z1\right) \cdot \frac{1}{z0}} \]

      5. associate-*l* N/A

         \[\leadsto \frac{1}{\color{blue}{\left(\pi \cdot \left(z2 \cdot z1\right)\right)} \cdot \frac{1}{z0}} \]

      6. lift-*.f64 N/A

         \[\leadsto \frac{1}{\left(\pi \cdot \color{blue}{\left(z2 \cdot z1\right)}\right) \cdot \frac{1}{z0}} \]

      7. associate-*l* N/A

         \[\leadsto \frac{1}{\color{blue}{\pi \cdot \left(\left(z2 \cdot z1\right) \cdot \frac{1}{z0}\right)}} \]

      8. *-commutative N/A

         \[\leadsto \frac{1}{\color{blue}{\left(\left(z2 \cdot z1\right) \cdot \frac{1}{z0}\right) \cdot \pi}} \]

      9. lower-*.f64 N/A

         \[\leadsto \frac{1}{\color{blue}{\left(\left(z2 \cdot z1\right) \cdot \frac{1}{z0}\right) \cdot \pi}} \]

      10. mult-flip-rev N/A

          \[\leadsto \frac{1}{\color{blue}{\frac{z2 \cdot z1}{z0}} \cdot \pi} \]

      11. lift-*.f64 N/A

          \[\leadsto \frac{1}{\frac{\color{blue}{z2 \cdot z1}}{z0} \cdot \pi} \]

      12. associate-/l* N/A

          \[\leadsto \frac{1}{\color{blue}{\left(z2 \cdot \frac{z1}{z0}\right)} \cdot \pi} \]

      13. *-commutative N/A

          \[\leadsto \frac{1}{\color{blue}{\left(\frac{z1}{z0} \cdot z2\right)} \cdot \pi} \]

      14. lower-*.f64 N/A

          \[\leadsto \frac{1}{\color{blue}{\left(\frac{z1}{z0} \cdot z2\right)} \cdot \pi} \]

      15. lower-/.f64 91.0%

          \[\leadsto \frac{1}{\left(\color{blue}{\frac{z1}{z0}} \cdot z2\right) \cdot \pi} \]

   5. Applied rewrites 91.0%

      \[\leadsto \frac{1}{\color{blue}{\left(\frac{z1}{z0} \cdot z2\right) \cdot \pi}} \]

   if 2e18 < (/.f64 z0 (*.f64 z1 (*.f64 z2 (PI.f64))))

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. *-commutative N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right) \cdot z1}} \]

      4. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right)} \cdot z1} \]

      5. associate-*l* N/A

         \[\leadsto \frac{z0}{\color{blue}{z2 \cdot \left(\pi \cdot z1\right)}} \]

      6. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      8. lower-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{z2}}}{\pi \cdot z1} \]

      9. lower-*.f64 91.9%

         \[\leadsto \frac{\frac{z0}{z2}}{\color{blue}{\pi \cdot z1}} \]

   3. Applied rewrites 91.9%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 99.5% accurate, 0.0× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\left|z1\right|, \left|z2\right|\right)\\ t_1 := \mathsf{max}\left(\left|z1\right|, \left|z2\right|\right)\\ \mathsf{copysign}\left(1, z0\right) \cdot \left(\mathsf{copysign}\left(1, z1\right) \cdot \left(\mathsf{copysign}\left(1, z2\right) \cdot \begin{array}{l} \mathbf{if}\;\left|z0\right| \leq \frac{7737125245533627}{154742504910672534362390528}:\\ \;\;\;\;\frac{\frac{\left|z0\right|}{t\_0}}{\pi \cdot t\_1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\left|z0\right|}{t\_1}}{\pi \cdot t\_0}\\ \end{array}\right)\right) \end{array} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (let* ((t_0 (fmin (fabs z1) (fabs z2)))
       (t_1 (fmax (fabs z1) (fabs z2))))
  (*
   (copysign 1 z0)
   (*
    (copysign 1 z1)
    (*
     (copysign 1 z2)
     (if (<= (fabs z0) 7737125245533627/154742504910672534362390528)
       (/ (/ (fabs z0) t_0) (* PI t_1))
       (/ (/ (fabs z0) t_1) (* PI t_0))))))))

C

double code(double z0, double z1, double z2) {
	double t_0 = fmin(fabs(z1), fabs(z2));
	double t_1 = fmax(fabs(z1), fabs(z2));
	double tmp;
	if (fabs(z0) <= 5e-11) {
		tmp = (fabs(z0) / t_0) / (((double) M_PI) * t_1);
	} else {
		tmp = (fabs(z0) / t_1) / (((double) M_PI) * t_0);
	}
	return copysign(1.0, z0) * (copysign(1.0, z1) * (copysign(1.0, z2) * tmp));
}

Java

public static double code(double z0, double z1, double z2) {
	double t_0 = fmin(Math.abs(z1), Math.abs(z2));
	double t_1 = fmax(Math.abs(z1), Math.abs(z2));
	double tmp;
	if (Math.abs(z0) <= 5e-11) {
		tmp = (Math.abs(z0) / t_0) / (Math.PI * t_1);
	} else {
		tmp = (Math.abs(z0) / t_1) / (Math.PI * t_0);
	}
	return Math.copySign(1.0, z0) * (Math.copySign(1.0, z1) * (Math.copySign(1.0, z2) * tmp));
}

Python

def code(z0, z1, z2):
	t_0 = fmin(math.fabs(z1), math.fabs(z2))
	t_1 = fmax(math.fabs(z1), math.fabs(z2))
	tmp = 0
	if math.fabs(z0) <= 5e-11:
		tmp = (math.fabs(z0) / t_0) / (math.pi * t_1)
	else:
		tmp = (math.fabs(z0) / t_1) / (math.pi * t_0)
	return math.copysign(1.0, z0) * (math.copysign(1.0, z1) * (math.copysign(1.0, z2) * tmp))

Julia

function code(z0, z1, z2)
	t_0 = fmin(abs(z1), abs(z2))
	t_1 = fmax(abs(z1), abs(z2))
	tmp = 0.0
	if (abs(z0) <= 5e-11)
		tmp = Float64(Float64(abs(z0) / t_0) / Float64(pi * t_1));
	else
		tmp = Float64(Float64(abs(z0) / t_1) / Float64(pi * t_0));
	end
	return Float64(copysign(1.0, z0) * Float64(copysign(1.0, z1) * Float64(copysign(1.0, z2) * tmp)))
end

MATLAB

function tmp_2 = code(z0, z1, z2)
	t_0 = min(abs(z1), abs(z2));
	t_1 = max(abs(z1), abs(z2));
	tmp = 0.0;
	if (abs(z0) <= 5e-11)
		tmp = (abs(z0) / t_0) / (pi * t_1);
	else
		tmp = (abs(z0) / t_1) / (pi * t_0);
	end
	tmp_2 = (sign(z0) * abs(1.0)) * ((sign(z1) * abs(1.0)) * ((sign(z2) * abs(1.0)) * tmp));
end

Wolfram

code[z0_, z1_, z2_] := Block[{t$95$0 = N[Min[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z0]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z2]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[z0], $MachinePrecision], 7737125245533627/154742504910672534362390528], N[(N[(N[Abs[z0], $MachinePrecision] / t$95$0), $MachinePrecision] / N[(Pi * t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[z0], $MachinePrecision] / t$95$1), $MachinePrecision] / N[(Pi * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z0 < 5.0000000000000002e-11

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{z2 \cdot \pi}} \]

      4. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{z2 \cdot \pi}} \]

      5. lower-/.f64 91.4%

         \[\leadsto \frac{\color{blue}{\frac{z0}{z1}}}{z2 \cdot \pi} \]

      6. lift-*.f64 N/A

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{z2 \cdot \pi}} \]

      7. *-commutative N/A

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{\pi \cdot z2}} \]

      8. lower-*.f64 91.4%

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{\pi \cdot z2}} \]

   3. Applied rewrites 91.4%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{\pi \cdot z2}} \]

   if 5.0000000000000002e-11 < z0

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. *-commutative N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right) \cdot z1}} \]

      4. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot \pi\right)} \cdot z1} \]

      5. associate-*l* N/A

         \[\leadsto \frac{z0}{\color{blue}{z2 \cdot \left(\pi \cdot z1\right)}} \]

      6. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]

      8. lower-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{z0}{z2}}}{\pi \cdot z1} \]

      9. lower-*.f64 91.9%

         \[\leadsto \frac{\frac{z0}{z2}}{\color{blue}{\pi \cdot z1}} \]

   3. Applied rewrites 91.9%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z2}}{\pi \cdot z1}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 99.1% accurate, 0.0× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\left|z1\right|, \left|z2\right|\right)\\ t_1 := \mathsf{min}\left(\left|z1\right|, \left|z2\right|\right)\\ t_2 := \frac{\frac{z0}{t\_1}}{\pi \cdot t\_0}\\ t_3 := t\_1 \cdot \left(t\_0 \cdot \pi\right)\\ \mathsf{copysign}\left(1, z1\right) \cdot \left(\mathsf{copysign}\left(1, z2\right) \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq \frac{4388899255034951}{21944496275174754733023745004748837080297570543729328280448007953824789527038691788660702798145451174453138901351488446979832735450978591612896414872982681198457994802840025058142360791167736098566050165049439180766375815715632675961171034001565824849041810386302038359368560295224574744242597208206082048}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 99999999999999995981677400789769932612359931733321583285118877944076548466448094957909476304960015890806678857380756006307062602577317320133875536163700284518967198097453618232695975663570046546450378657742479671982722077174989256760731188933351130765773907040474247261585408:\\ \;\;\;\;\frac{z0}{\left(\pi \cdot t\_1\right) \cdot t\_0}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array}\right) \end{array} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (let* ((t_0 (fmax (fabs z1) (fabs z2)))
       (t_1 (fmin (fabs z1) (fabs z2)))
       (t_2 (/ (/ z0 t_1) (* PI t_0)))
       (t_3 (* t_1 (* t_0 PI))))
  (*
   (copysign 1 z1)
   (*
    (copysign 1 z2)
    (if (<=
         t_3
         4388899255034951/21944496275174754733023745004748837080297570543729328280448007953824789527038691788660702798145451174453138901351488446979832735450978591612896414872982681198457994802840025058142360791167736098566050165049439180766375815715632675961171034001565824849041810386302038359368560295224574744242597208206082048)
      t_2
      (if (<=
           t_3
           99999999999999995981677400789769932612359931733321583285118877944076548466448094957909476304960015890806678857380756006307062602577317320133875536163700284518967198097453618232695975663570046546450378657742479671982722077174989256760731188933351130765773907040474247261585408)
        (/ z0 (* (* PI t_1) t_0))
        t_2))))))

C

double code(double z0, double z1, double z2) {
	double t_0 = fmax(fabs(z1), fabs(z2));
	double t_1 = fmin(fabs(z1), fabs(z2));
	double t_2 = (z0 / t_1) / (((double) M_PI) * t_0);
	double t_3 = t_1 * (t_0 * ((double) M_PI));
	double tmp;
	if (t_3 <= 2e-289) {
		tmp = t_2;
	} else if (t_3 <= 1e+275) {
		tmp = z0 / ((((double) M_PI) * t_1) * t_0);
	} else {
		tmp = t_2;
	}
	return copysign(1.0, z1) * (copysign(1.0, z2) * tmp);
}

Java

public static double code(double z0, double z1, double z2) {
	double t_0 = fmax(Math.abs(z1), Math.abs(z2));
	double t_1 = fmin(Math.abs(z1), Math.abs(z2));
	double t_2 = (z0 / t_1) / (Math.PI * t_0);
	double t_3 = t_1 * (t_0 * Math.PI);
	double tmp;
	if (t_3 <= 2e-289) {
		tmp = t_2;
	} else if (t_3 <= 1e+275) {
		tmp = z0 / ((Math.PI * t_1) * t_0);
	} else {
		tmp = t_2;
	}
	return Math.copySign(1.0, z1) * (Math.copySign(1.0, z2) * tmp);
}

Python

def code(z0, z1, z2):
	t_0 = fmax(math.fabs(z1), math.fabs(z2))
	t_1 = fmin(math.fabs(z1), math.fabs(z2))
	t_2 = (z0 / t_1) / (math.pi * t_0)
	t_3 = t_1 * (t_0 * math.pi)
	tmp = 0
	if t_3 <= 2e-289:
		tmp = t_2
	elif t_3 <= 1e+275:
		tmp = z0 / ((math.pi * t_1) * t_0)
	else:
		tmp = t_2
	return math.copysign(1.0, z1) * (math.copysign(1.0, z2) * tmp)

Julia

function code(z0, z1, z2)
	t_0 = fmax(abs(z1), abs(z2))
	t_1 = fmin(abs(z1), abs(z2))
	t_2 = Float64(Float64(z0 / t_1) / Float64(pi * t_0))
	t_3 = Float64(t_1 * Float64(t_0 * pi))
	tmp = 0.0
	if (t_3 <= 2e-289)
		tmp = t_2;
	elseif (t_3 <= 1e+275)
		tmp = Float64(z0 / Float64(Float64(pi * t_1) * t_0));
	else
		tmp = t_2;
	end
	return Float64(copysign(1.0, z1) * Float64(copysign(1.0, z2) * tmp))
end

MATLAB

function tmp_2 = code(z0, z1, z2)
	t_0 = max(abs(z1), abs(z2));
	t_1 = min(abs(z1), abs(z2));
	t_2 = (z0 / t_1) / (pi * t_0);
	t_3 = t_1 * (t_0 * pi);
	tmp = 0.0;
	if (t_3 <= 2e-289)
		tmp = t_2;
	elseif (t_3 <= 1e+275)
		tmp = z0 / ((pi * t_1) * t_0);
	else
		tmp = t_2;
	end
	tmp_2 = (sign(z1) * abs(1.0)) * ((sign(z2) * abs(1.0)) * tmp);
end

Wolfram

code[z0_, z1_, z2_] := Block[{t$95$0 = N[Max[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Min[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(z0 / t$95$1), $MachinePrecision] / N[(Pi * t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 * N[(t$95$0 * Pi), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z2]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, 4388899255034951/21944496275174754733023745004748837080297570543729328280448007953824789527038691788660702798145451174453138901351488446979832735450978591612896414872982681198457994802840025058142360791167736098566050165049439180766375815715632675961171034001565824849041810386302038359368560295224574744242597208206082048], t$95$2, If[LessEqual[t$95$3, 99999999999999995981677400789769932612359931733321583285118877944076548466448094957909476304960015890806678857380756006307062602577317320133875536163700284518967198097453618232695975663570046546450378657742479671982722077174989256760731188933351130765773907040474247261585408], N[(z0 / N[(N[(Pi * t$95$1), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], t$95$2]]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 z1 (*.f64 z2 (PI.f64))) < 2e-289 or 9.9999999999999996e274 < (*.f64 z1 (*.f64 z2 (PI.f64)))

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      3. associate-/r* N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{z2 \cdot \pi}} \]

      4. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{z2 \cdot \pi}} \]

      5. lower-/.f64 91.4%

         \[\leadsto \frac{\color{blue}{\frac{z0}{z1}}}{z2 \cdot \pi} \]

      6. lift-*.f64 N/A

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{z2 \cdot \pi}} \]

      7. *-commutative N/A

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{\pi \cdot z2}} \]

      8. lower-*.f64 91.4%

         \[\leadsto \frac{\frac{z0}{z1}}{\color{blue}{\pi \cdot z2}} \]

   3. Applied rewrites 91.4%

      \[\leadsto \color{blue}{\frac{\frac{z0}{z1}}{\pi \cdot z2}} \]

   if 2e-289 < (*.f64 z1 (*.f64 z2 (PI.f64))) < 9.9999999999999996e274

   1. Initial program 92.3%

      \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
   2. Step-by-step derivation

      1. lift-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

      2. lift-*.f64 N/A

         \[\leadsto \frac{z0}{z1 \cdot \color{blue}{\left(z2 \cdot \pi\right)}} \]

      3. associate-*r* N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(z1 \cdot z2\right) \cdot \pi}} \]

      4. *-commutative N/A

         \[\leadsto \frac{z0}{\color{blue}{\pi \cdot \left(z1 \cdot z2\right)}} \]

      5. associate-*r* N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]

      6. lower-*.f64 N/A

         \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]

      7. lower-*.f64 92.4%

         \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right)} \cdot z2} \]

   3. Applied rewrites 92.4%

      \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 92.4% accurate, 0.0× speedup

Math

\[\mathsf{copysign}\left(1, z1\right) \cdot \left(\mathsf{copysign}\left(1, z2\right) \cdot \frac{z0}{\left(\pi \cdot \mathsf{min}\left(\left|z1\right|, \left|z2\right|\right)\right) \cdot \mathsf{max}\left(\left|z1\right|, \left|z2\right|\right)}\right) \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (*
 (copysign 1 z1)
 (*
  (copysign 1 z2)
  (/
   z0
   (* (* PI (fmin (fabs z1) (fabs z2))) (fmax (fabs z1) (fabs z2)))))))

C

double code(double z0, double z1, double z2) {
	return copysign(1.0, z1) * (copysign(1.0, z2) * (z0 / ((((double) M_PI) * fmin(fabs(z1), fabs(z2))) * fmax(fabs(z1), fabs(z2)))));
}

Java

public static double code(double z0, double z1, double z2) {
	return Math.copySign(1.0, z1) * (Math.copySign(1.0, z2) * (z0 / ((Math.PI * fmin(Math.abs(z1), Math.abs(z2))) * fmax(Math.abs(z1), Math.abs(z2)))));
}

Python

def code(z0, z1, z2):
	return math.copysign(1.0, z1) * (math.copysign(1.0, z2) * (z0 / ((math.pi * fmin(math.fabs(z1), math.fabs(z2))) * fmax(math.fabs(z1), math.fabs(z2)))))

Julia

function code(z0, z1, z2)
	return Float64(copysign(1.0, z1) * Float64(copysign(1.0, z2) * Float64(z0 / Float64(Float64(pi * fmin(abs(z1), abs(z2))) * fmax(abs(z1), abs(z2))))))
end

MATLAB

function tmp = code(z0, z1, z2)
	tmp = (sign(z1) * abs(1.0)) * ((sign(z2) * abs(1.0)) * (z0 / ((pi * min(abs(z1), abs(z2))) * max(abs(z1), abs(z2)))));
end

Wolfram

code[z0_, z1_, z2_] := N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(N[With[{TMP1 = Abs[1], TMP2 = Sign[z2]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(z0 / N[(N[(Pi * N[Min[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Max[N[Abs[z1], $MachinePrecision], N[Abs[z2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 92.3%

   \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
2. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

   2. lift-*.f64 N/A

      \[\leadsto \frac{z0}{z1 \cdot \color{blue}{\left(z2 \cdot \pi\right)}} \]

   3. associate-*r* N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(z1 \cdot z2\right) \cdot \pi}} \]

   4. *-commutative N/A

      \[\leadsto \frac{z0}{\color{blue}{\pi \cdot \left(z1 \cdot z2\right)}} \]

   5. associate-*r* N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]

   6. lower-*.f64 N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]

   7. lower-*.f64 92.4%

      \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right)} \cdot z2} \]

3. Applied rewrites 92.4%

   \[\leadsto \frac{z0}{\color{blue}{\left(\pi \cdot z1\right) \cdot z2}} \]
4. Add Preprocessing

Alternative 6: 92.4% accurate, 1.0× speedup

Math

\[\frac{z0}{\left(z2 \cdot z1\right) \cdot \pi} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (/ z0 (* (* z2 z1) PI)))

C

double code(double z0, double z1, double z2) {
	return z0 / ((z2 * z1) * ((double) M_PI));
}

Java

public static double code(double z0, double z1, double z2) {
	return z0 / ((z2 * z1) * Math.PI);
}

Python

def code(z0, z1, z2):
	return z0 / ((z2 * z1) * math.pi)

Julia

function code(z0, z1, z2)
	return Float64(z0 / Float64(Float64(z2 * z1) * pi))
end

MATLAB

function tmp = code(z0, z1, z2)
	tmp = z0 / ((z2 * z1) * pi);
end

Wolfram

code[z0_, z1_, z2_] := N[(z0 / N[(N[(z2 * z1), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 92.3%

   \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
2. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \frac{z0}{\color{blue}{z1 \cdot \left(z2 \cdot \pi\right)}} \]

   2. lift-*.f64 N/A

      \[\leadsto \frac{z0}{z1 \cdot \color{blue}{\left(z2 \cdot \pi\right)}} \]

   3. associate-*r* N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(z1 \cdot z2\right) \cdot \pi}} \]

   4. lower-*.f64 N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(z1 \cdot z2\right) \cdot \pi}} \]

   5. *-commutative N/A

      \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot z1\right)} \cdot \pi} \]

   6. lower-*.f64 92.4%

      \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot z1\right)} \cdot \pi} \]

3. Applied rewrites 92.4%

   \[\leadsto \frac{z0}{\color{blue}{\left(z2 \cdot z1\right) \cdot \pi}} \]
4. Add Preprocessing

Alternative 7: 92.3% accurate, 0.1× speedup

Math

\[\frac{z0}{\mathsf{min}\left(z1, z2\right) \cdot \left(\mathsf{max}\left(z1, z2\right) \cdot \pi\right)} \]

FPCore

(FPCore (z0 z1 z2)
  :precision binary64
  (/ z0 (* (fmin z1 z2) (* (fmax z1 z2) PI))))

C

double code(double z0, double z1, double z2) {
	return z0 / (fmin(z1, z2) * (fmax(z1, z2) * ((double) M_PI)));
}

Java

public static double code(double z0, double z1, double z2) {
	return z0 / (fmin(z1, z2) * (fmax(z1, z2) * Math.PI));
}

Python

def code(z0, z1, z2):
	return z0 / (fmin(z1, z2) * (fmax(z1, z2) * math.pi))

Julia

function code(z0, z1, z2)
	return Float64(z0 / Float64(fmin(z1, z2) * Float64(fmax(z1, z2) * pi)))
end

MATLAB

function tmp = code(z0, z1, z2)
	tmp = z0 / (min(z1, z2) * (max(z1, z2) * pi));
end

Wolfram

code[z0_, z1_, z2_] := N[(z0 / N[(N[Min[z1, z2], $MachinePrecision] * N[(N[Max[z1, z2], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 92.3%

   \[\frac{z0}{z1 \cdot \left(z2 \cdot \pi\right)} \]
2. Add Preprocessing

Reproduce

herbie shell --seed 2025277 -o generate:taylor -o generate:evaluate
(FPCore (z0 z1 z2)
  :name "(/ z0 (* z1 (* z2 PI)))"
  :precision binary64
  (/ z0 (* z1 (* z2 PI))))