(- PI (* (* PI (* z0 8333333333333333/50000000000000000)) (* (* PI PI) z0)))

Percentage Accurate: 99.7% → 99.8%

Time: 1.3s

Alternatives: 3

Speedup: 2.1×

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

Specification

Math

\[\pi - \left(\pi \cdot \left(z0 \cdot 0.16666666666666666\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right) \]

FPCore

(FPCore (z0)
  :precision binary64
  (- PI (* (* PI (* z0 0.16666666666666666)) (* (* PI PI) z0))))

C

double code(double z0) {
	return ((double) M_PI) - ((((double) M_PI) * (z0 * 0.16666666666666666)) * ((((double) M_PI) * ((double) M_PI)) * z0));
}

Java

public static double code(double z0) {
	return Math.PI - ((Math.PI * (z0 * 0.16666666666666666)) * ((Math.PI * Math.PI) * z0));
}

Python

def code(z0):
	return math.pi - ((math.pi * (z0 * 0.16666666666666666)) * ((math.pi * math.pi) * z0))

Julia

function code(z0)
	return Float64(pi - Float64(Float64(pi * Float64(z0 * 0.16666666666666666)) * Float64(Float64(pi * pi) * z0)))
end

MATLAB

function tmp = code(z0)
	tmp = pi - ((pi * (z0 * 0.16666666666666666)) * ((pi * pi) * z0));
end

Wolfram

code[z0_] := N[(Pi - N[(N[(Pi * N[(z0 * 0.16666666666666666), $MachinePrecision]), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * z0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 99.7% accurate, 1.0× speedup

Math

\[\pi - \left(\pi \cdot \left(z0 \cdot 0.16666666666666666\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right) \]

FPCore

(FPCore (z0)
  :precision binary64
  (- PI (* (* PI (* z0 0.16666666666666666)) (* (* PI PI) z0))))

C

double code(double z0) {
	return ((double) M_PI) - ((((double) M_PI) * (z0 * 0.16666666666666666)) * ((((double) M_PI) * ((double) M_PI)) * z0));
}

Java

public static double code(double z0) {
	return Math.PI - ((Math.PI * (z0 * 0.16666666666666666)) * ((Math.PI * Math.PI) * z0));
}

Python

def code(z0):
	return math.pi - ((math.pi * (z0 * 0.16666666666666666)) * ((math.pi * math.pi) * z0))

Julia

function code(z0)
	return Float64(pi - Float64(Float64(pi * Float64(z0 * 0.16666666666666666)) * Float64(Float64(pi * pi) * z0)))
end

MATLAB

function tmp = code(z0)
	tmp = pi - ((pi * (z0 * 0.16666666666666666)) * ((pi * pi) * z0));
end

Wolfram

code[z0_] := N[(Pi - N[(N[(Pi * N[(z0 * 0.16666666666666666), $MachinePrecision]), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * z0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.8% accurate, 1.5× speedup

Math

\[\pi - \left(\left(31.00627668029982 \cdot z0\right) \cdot z0\right) \cdot 0.16666666666666666 \]

FPCore

(FPCore (z0)
  :precision binary64
  (- PI (* (* (* 31.00627668029982 z0) z0) 0.16666666666666666)))

C

double code(double z0) {
	return ((double) M_PI) - (((31.00627668029982 * z0) * z0) * 0.16666666666666666);
}

Java

public static double code(double z0) {
	return Math.PI - (((31.00627668029982 * z0) * z0) * 0.16666666666666666);
}

Python

def code(z0):
	return math.pi - (((31.00627668029982 * z0) * z0) * 0.16666666666666666)

Julia

function code(z0)
	return Float64(pi - Float64(Float64(Float64(31.00627668029982 * z0) * z0) * 0.16666666666666666))
end

MATLAB

function tmp = code(z0)
	tmp = pi - (((31.00627668029982 * z0) * z0) * 0.16666666666666666);
end

Wolfram

code[z0_] := N[(Pi - N[(N[(N[(31.00627668029982 * z0), $MachinePrecision] * z0), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

   \[\pi - \left(\pi \cdot \left(z0 \cdot 0.16666666666666666\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right) \]
2. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right)} \]

   2. *-commutative N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right)} \]

   3. lift-*.f64 N/A

      \[\leadsto \pi - \left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \color{blue}{\left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \pi - \left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \left(\pi \cdot \color{blue}{\left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)}\right) \]

   5. associate-*r* N/A

      \[\leadsto \pi - \left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \color{blue}{\left(\left(\pi \cdot z0\right) \cdot \frac{8333333333333333}{50000000000000000}\right)} \]

   6. associate-*r* N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \left(\pi \cdot z0\right)\right) \cdot \frac{8333333333333333}{50000000000000000}} \]

   7. lower-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\left(\pi \cdot \pi\right) \cdot z0\right) \cdot \left(\pi \cdot z0\right)\right) \cdot \frac{8333333333333333}{50000000000000000}} \]

3. Applied rewrites 99.6%

   \[\leadsto \pi - \color{blue}{\left(\left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot z0\right) \cdot z0\right) \cdot 0.16666666666666666} \]

4. Evaluated real constant 99.8%

   \[\leadsto \pi - \left(\left(\color{blue}{31.00627668029982} \cdot z0\right) \cdot z0\right) \cdot 0.16666666666666666 \]
5. Add Preprocessing

Alternative 2: 99.8% accurate, 2.1× speedup

Math

\[\pi - 5.16771278004997 \cdot \left(z0 \cdot z0\right) \]

FPCore

(FPCore (z0)
  :precision binary64
  (- PI (* 5.16771278004997 (* z0 z0))))

C

double code(double z0) {
	return ((double) M_PI) - (5.16771278004997 * (z0 * z0));
}

Java

public static double code(double z0) {
	return Math.PI - (5.16771278004997 * (z0 * z0));
}

Python

def code(z0):
	return math.pi - (5.16771278004997 * (z0 * z0))

Julia

function code(z0)
	return Float64(pi - Float64(5.16771278004997 * Float64(z0 * z0)))
end

MATLAB

function tmp = code(z0)
	tmp = pi - (5.16771278004997 * (z0 * z0));
end

Wolfram

code[z0_] := N[(Pi - N[(5.16771278004997 * N[(z0 * z0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

   \[\pi - \left(\pi \cdot \left(z0 \cdot 0.16666666666666666\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right) \]
2. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right)} \]

   2. lift-*.f64 N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \color{blue}{\left(\left(\pi \cdot \pi\right) \cdot z0\right)} \]

   3. *-commutative N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \color{blue}{\left(z0 \cdot \left(\pi \cdot \pi\right)\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(z0 \cdot \color{blue}{\left(\pi \cdot \pi\right)}\right) \]

   5. sqr-neg-rev N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(z0 \cdot \color{blue}{\left(\left(\mathsf{neg}\left(\pi\right)\right) \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right)}\right) \]

   6. associate-*r* N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \color{blue}{\left(\left(z0 \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right) \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right)} \]

   7. *-commutative N/A

      \[\leadsto \pi - \left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \color{blue}{\left(\left(\mathsf{neg}\left(\pi\right)\right) \cdot \left(z0 \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right)\right)} \]

   8. associate-*r* N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right) \cdot \left(z0 \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right)} \]

   9. lower-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\pi \cdot \left(z0 \cdot \frac{8333333333333333}{50000000000000000}\right)\right) \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right) \cdot \left(z0 \cdot \left(\mathsf{neg}\left(\pi\right)\right)\right)} \]

3. Applied rewrites 99.7%

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

   1. lift-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\frac{-8333333333333333}{50000000000000000} \cdot z0\right) \cdot \left(\pi \cdot \pi\right)\right) \cdot \left(\left(-z0\right) \cdot \pi\right)} \]

   2. lift-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\left(\frac{-8333333333333333}{50000000000000000} \cdot z0\right) \cdot \left(\pi \cdot \pi\right)\right)} \cdot \left(\left(-z0\right) \cdot \pi\right) \]

   3. associate-*l* N/A

      \[\leadsto \pi - \color{blue}{\left(\frac{-8333333333333333}{50000000000000000} \cdot z0\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot \left(\left(-z0\right) \cdot \pi\right)\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \pi - \color{blue}{\left(\frac{-8333333333333333}{50000000000000000} \cdot z0\right)} \cdot \left(\left(\pi \cdot \pi\right) \cdot \left(\left(-z0\right) \cdot \pi\right)\right) \]

   5. *-commutative N/A

      \[\leadsto \pi - \color{blue}{\left(z0 \cdot \frac{-8333333333333333}{50000000000000000}\right)} \cdot \left(\left(\pi \cdot \pi\right) \cdot \left(\left(-z0\right) \cdot \pi\right)\right) \]

   6. associate-*l* N/A

      \[\leadsto \pi - \color{blue}{z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\left(\pi \cdot \pi\right) \cdot \left(\left(-z0\right) \cdot \pi\right)\right)\right)} \]

   7. lift-*.f64 N/A

      \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\left(\pi \cdot \pi\right) \cdot \color{blue}{\left(\left(-z0\right) \cdot \pi\right)}\right)\right) \]

   8. *-commutative N/A

      \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\left(\pi \cdot \pi\right) \cdot \color{blue}{\left(\pi \cdot \left(-z0\right)\right)}\right)\right) \]

   9. associate-*r* N/A

      \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \color{blue}{\left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot \left(-z0\right)\right)}\right) \]

   10. lift-*.f64 N/A

       \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\color{blue}{\left(\left(\pi \cdot \pi\right) \cdot \pi\right)} \cdot \left(-z0\right)\right)\right) \]

   11. lift-neg.f64 N/A

       \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot \color{blue}{\left(\mathsf{neg}\left(z0\right)\right)}\right)\right) \]

   12. distribute-rgt-neg-out N/A

       \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \color{blue}{\left(\mathsf{neg}\left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot z0\right)\right)}\right) \]

   13. lift-*.f64 N/A

       \[\leadsto \pi - z0 \cdot \left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\mathsf{neg}\left(\color{blue}{\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot z0}\right)\right)\right) \]

   14. distribute-rgt-neg-out N/A

       \[\leadsto \pi - z0 \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{-8333333333333333}{50000000000000000} \cdot \left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot z0\right)\right)\right)} \]

5. Applied rewrites 99.8%

   \[\leadsto \pi - \color{blue}{\left(\left(\left(\pi \cdot \pi\right) \cdot \pi\right) \cdot 0.16666666666666666\right) \cdot \left(z0 \cdot z0\right)} \]

6. Evaluated real constant 99.8%

   \[\leadsto \pi - \color{blue}{5.16771278004997} \cdot \left(z0 \cdot z0\right) \]
7. Add Preprocessing

Alternative 3: 50.6% accurate, 29.0× speedup

Math

\[\pi \]

FPCore

(FPCore (z0)
  :precision binary64
  PI)

C

double code(double z0) {
	return (double) M_PI;
}

Java

public static double code(double z0) {
	return Math.PI;
}

Python

def code(z0):
	return math.pi

Julia

function code(z0)
	return pi
end

MATLAB

function tmp = code(z0)
	tmp = pi;
end

Wolfram

code[z0_] := Pi

Derivation

1. Initial program 99.7%

   \[\pi - \left(\pi \cdot \left(z0 \cdot 0.16666666666666666\right)\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot z0\right) \]

2. Taylor expanded in z0 around 0

   \[\leadsto \color{blue}{\pi} \]
3. Step-by-step derivation

   1. lower-PI.f64 50.6%

      \[\leadsto \pi \]

4. Applied rewrites 50.6%

   \[\leadsto \color{blue}{\pi} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2025250 
(FPCore (z0)
  :name "(- PI (* (* PI (* z0 8333333333333333/50000000000000000)) (* (* PI PI) z0)))"
  :precision binary64
  (- PI (* (* PI (* z0 0.16666666666666666)) (* (* PI PI) z0))))