inverse-esp

Percentage Accurate: 99.8% → 99.8%

Time: 1.7min

Alternatives: 6

Speedup: 1.0×

Specification

\[ecc > 0 \land ecc < 1\]

Math

\[ecc \cdot \sin phip \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (* ecc (sin phip)))

C

double code(double phip, double ecc) {
	return ecc * sin(phip);
}

Fortran

real(8) function code(phip, ecc)
use fmin_fmax_functions
    real(8), intent (in) :: phip
    real(8), intent (in) :: ecc
    code = ecc * sin(phip)
end function

Java

public static double code(double phip, double ecc) {
	return ecc * Math.sin(phip);
}

Python

def code(phip, ecc):
	return ecc * math.sin(phip)

Julia

function code(phip, ecc)
	return Float64(ecc * sin(phip))
end

MATLAB

function tmp = code(phip, ecc)
	tmp = ecc * sin(phip);
end

Wolfram

code[phip_, ecc_] := N[(ecc * N[Sin[phip], $MachinePrecision]), $MachinePrecision]

ReFlow

f(phip, ecc):
	phip in [-inf, +inf],
	ecc in [0, 1]
code: THEORY
BEGIN
f(phip, ecc: real): real =
	ecc * (sin(phip))
END code

Initial Program: 99.8% accurate, 1.0× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[ecc \cdot \sin phip \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (* ecc (sin phip)))

C

double code(double phip, double ecc) {
	return ecc * sin(phip);
}

Fortran

real(8) function code(phip, ecc)
use fmin_fmax_functions
    real(8), intent (in) :: phip
    real(8), intent (in) :: ecc
    code = ecc * sin(phip)
end function

Java

public static double code(double phip, double ecc) {
	return ecc * Math.sin(phip);
}

Python

def code(phip, ecc):
	return ecc * math.sin(phip)

Julia

function code(phip, ecc)
	return Float64(ecc * sin(phip))
end

MATLAB

function tmp = code(phip, ecc)
	tmp = ecc * sin(phip);
end

Wolfram

code[phip_, ecc_] := N[(ecc * N[Sin[phip], $MachinePrecision]), $MachinePrecision]

ReFlow

f(phip, ecc):
	phip in [-inf, +inf],
	ecc in [0, 1]
code: THEORY
BEGIN
f(phip, ecc: real): real =
	ecc * (sin(phip))
END code

Alternative 1: 60.0% accurate, 0.4× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[\begin{array}{l} t_0 := \sin \left(\left|phip\right|\right)\\ \mathsf{copysign}\left(1, phip\right) \cdot \begin{array}{l} \mathbf{if}\;t\_0 \leq -0.02:\\ \;\;\;\;-ecc\\ \mathbf{elif}\;t\_0 \leq 4 \cdot 10^{-7}:\\ \;\;\;\;ecc \cdot \left|phip\right|\\ \mathbf{else}:\\ \;\;\;\;ecc\\ \end{array} \end{array} \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (let* ((t_0 (sin (fabs phip))))
  (*
   (copysign 1.0 phip)
   (if (<= t_0 -0.02)
     (- ecc)
     (if (<= t_0 4e-7) (* ecc (fabs phip)) ecc)))))

C

double code(double phip, double ecc) {
	double t_0 = sin(fabs(phip));
	double tmp;
	if (t_0 <= -0.02) {
		tmp = -ecc;
	} else if (t_0 <= 4e-7) {
		tmp = ecc * fabs(phip);
	} else {
		tmp = ecc;
	}
	return copysign(1.0, phip) * tmp;
}

Java

public static double code(double phip, double ecc) {
	double t_0 = Math.sin(Math.abs(phip));
	double tmp;
	if (t_0 <= -0.02) {
		tmp = -ecc;
	} else if (t_0 <= 4e-7) {
		tmp = ecc * Math.abs(phip);
	} else {
		tmp = ecc;
	}
	return Math.copySign(1.0, phip) * tmp;
}

Python

def code(phip, ecc):
	t_0 = math.sin(math.fabs(phip))
	tmp = 0
	if t_0 <= -0.02:
		tmp = -ecc
	elif t_0 <= 4e-7:
		tmp = ecc * math.fabs(phip)
	else:
		tmp = ecc
	return math.copysign(1.0, phip) * tmp

Julia

function code(phip, ecc)
	t_0 = sin(abs(phip))
	tmp = 0.0
	if (t_0 <= -0.02)
		tmp = Float64(-ecc);
	elseif (t_0 <= 4e-7)
		tmp = Float64(ecc * abs(phip));
	else
		tmp = ecc;
	end
	return Float64(copysign(1.0, phip) * tmp)
end

MATLAB

function tmp_2 = code(phip, ecc)
	t_0 = sin(abs(phip));
	tmp = 0.0;
	if (t_0 <= -0.02)
		tmp = -ecc;
	elseif (t_0 <= 4e-7)
		tmp = ecc * abs(phip);
	else
		tmp = ecc;
	end
	tmp_2 = (sign(phip) * abs(1.0)) * tmp;
end

Wolfram

code[phip_, ecc_] := Block[{t$95$0 = N[Sin[N[Abs[phip], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[phip]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$0, -0.02], (-ecc), If[LessEqual[t$95$0, 4e-7], N[(ecc * N[Abs[phip], $MachinePrecision]), $MachinePrecision], ecc]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (sin.f64 phip) < -0.02

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 9.2%

      \[\leadsto ecc \cdot -1 \]

   10. Applied rewrites 9.2%

       \[\leadsto -ecc \]

   if -0.02 < (sin.f64 phip) < 3.9999999999999998e-7

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   if 3.9999999999999998e-7 < (sin.f64 phip)

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 9.1%

      \[\leadsto ecc \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 2: 36.1% accurate, 0.5× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[\begin{array}{l} t_0 := \sin \left(\left|phip\right|\right)\\ \mathsf{copysign}\left(1, phip\right) \cdot \begin{array}{l} \mathbf{if}\;t\_0 \leq -0.02:\\ \;\;\;\;-ecc\\ \mathbf{elif}\;t\_0 \leq 2 \cdot 10^{-28}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;ecc\\ \end{array} \end{array} \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (let* ((t_0 (sin (fabs phip))))
  (*
   (copysign 1.0 phip)
   (if (<= t_0 -0.02) (- ecc) (if (<= t_0 2e-28) 0.0 ecc)))))

C

double code(double phip, double ecc) {
	double t_0 = sin(fabs(phip));
	double tmp;
	if (t_0 <= -0.02) {
		tmp = -ecc;
	} else if (t_0 <= 2e-28) {
		tmp = 0.0;
	} else {
		tmp = ecc;
	}
	return copysign(1.0, phip) * tmp;
}

Java

public static double code(double phip, double ecc) {
	double t_0 = Math.sin(Math.abs(phip));
	double tmp;
	if (t_0 <= -0.02) {
		tmp = -ecc;
	} else if (t_0 <= 2e-28) {
		tmp = 0.0;
	} else {
		tmp = ecc;
	}
	return Math.copySign(1.0, phip) * tmp;
}

Python

def code(phip, ecc):
	t_0 = math.sin(math.fabs(phip))
	tmp = 0
	if t_0 <= -0.02:
		tmp = -ecc
	elif t_0 <= 2e-28:
		tmp = 0.0
	else:
		tmp = ecc
	return math.copysign(1.0, phip) * tmp

Julia

function code(phip, ecc)
	t_0 = sin(abs(phip))
	tmp = 0.0
	if (t_0 <= -0.02)
		tmp = Float64(-ecc);
	elseif (t_0 <= 2e-28)
		tmp = 0.0;
	else
		tmp = ecc;
	end
	return Float64(copysign(1.0, phip) * tmp)
end

MATLAB

function tmp_2 = code(phip, ecc)
	t_0 = sin(abs(phip));
	tmp = 0.0;
	if (t_0 <= -0.02)
		tmp = -ecc;
	elseif (t_0 <= 2e-28)
		tmp = 0.0;
	else
		tmp = ecc;
	end
	tmp_2 = (sign(phip) * abs(1.0)) * tmp;
end

Wolfram

code[phip_, ecc_] := Block[{t$95$0 = N[Sin[N[Abs[phip], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[phip]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$0, -0.02], (-ecc), If[LessEqual[t$95$0, 2e-28], 0.0, ecc]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (sin.f64 phip) < -0.02

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 9.2%

      \[\leadsto ecc \cdot -1 \]

   10. Applied rewrites 9.2%

       \[\leadsto -ecc \]

   if -0.02 < (sin.f64 phip) < 1.9999999999999999e-28

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 28.1%

      \[\leadsto 0 \]

   if 1.9999999999999999e-28 < (sin.f64 phip)

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 9.1%

      \[\leadsto ecc \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 32.3% accurate, 0.8× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[\mathsf{copysign}\left(1, phip\right) \cdot \begin{array}{l} \mathbf{if}\;\sin \left(\left|phip\right|\right) \leq 2 \cdot 10^{-28}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;ecc\\ \end{array} \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (* (copysign 1.0 phip) (if (<= (sin (fabs phip)) 2e-28) 0.0 ecc)))

C

double code(double phip, double ecc) {
	double tmp;
	if (sin(fabs(phip)) <= 2e-28) {
		tmp = 0.0;
	} else {
		tmp = ecc;
	}
	return copysign(1.0, phip) * tmp;
}

Java

public static double code(double phip, double ecc) {
	double tmp;
	if (Math.sin(Math.abs(phip)) <= 2e-28) {
		tmp = 0.0;
	} else {
		tmp = ecc;
	}
	return Math.copySign(1.0, phip) * tmp;
}

Python

def code(phip, ecc):
	tmp = 0
	if math.sin(math.fabs(phip)) <= 2e-28:
		tmp = 0.0
	else:
		tmp = ecc
	return math.copysign(1.0, phip) * tmp

Julia

function code(phip, ecc)
	tmp = 0.0
	if (sin(abs(phip)) <= 2e-28)
		tmp = 0.0;
	else
		tmp = ecc;
	end
	return Float64(copysign(1.0, phip) * tmp)
end

MATLAB

function tmp_2 = code(phip, ecc)
	tmp = 0.0;
	if (sin(abs(phip)) <= 2e-28)
		tmp = 0.0;
	else
		tmp = ecc;
	end
	tmp_2 = (sign(phip) * abs(1.0)) * tmp;
end

Wolfram

code[phip_, ecc_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[phip]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Sin[N[Abs[phip], $MachinePrecision]], $MachinePrecision], 2e-28], 0.0, ecc]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if (sin.f64 phip) < 1.9999999999999999e-28

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 28.1%

      \[\leadsto 0 \]

   if 1.9999999999999999e-28 < (sin.f64 phip)

   1. Initial program 99.8%

      \[ecc \cdot \sin phip \]

   2. Taylor expanded in phip around 0

      \[\leadsto ecc \cdot phip \]

   4. Applied rewrites 51.7%

      \[\leadsto ecc \cdot phip \]

   6. Applied rewrites 51.7%

      \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

   8. Applied rewrites 9.1%

      \[\leadsto ecc \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 28.1% accurate, 37.6× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[0 \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  0.0)

C

double code(double phip, double ecc) {
	return 0.0;
}

Fortran

real(8) function code(phip, ecc)
use fmin_fmax_functions
    real(8), intent (in) :: phip
    real(8), intent (in) :: ecc
    code = 0.0d0
end function

Java

public static double code(double phip, double ecc) {
	return 0.0;
}

Python

def code(phip, ecc):
	return 0.0

Julia

function code(phip, ecc)
	return 0.0
end

MATLAB

function tmp = code(phip, ecc)
	tmp = 0.0;
end

Wolfram

code[phip_, ecc_] := 0.0

ReFlow

f(phip, ecc):
	phip in [-inf, +inf],
	ecc in [0, 1]
code: THEORY
BEGIN
f(phip, ecc: real): real =
	0
END code

Derivation

1. Initial program 99.8%

   \[ecc \cdot \sin phip \]

2. Taylor expanded in phip around 0

   \[\leadsto ecc \cdot phip \]

4. Applied rewrites 51.7%

   \[\leadsto ecc \cdot phip \]

6. Applied rewrites 51.7%

   \[\leadsto ecc \cdot \frac{1}{\frac{2}{phip + phip}} \]

8. Applied rewrites 28.1%

   \[\leadsto 0 \]
9. Add Preprocessing

Alternative 5: 3.6% accurate, 37.6× speedup

\[ecc > 0 \land ecc < 1\]

Math

\[-0.08333333333333333 \]

FPCore

(FPCore (phip ecc)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  -0.08333333333333333)

C

double code(double phip, double ecc) {
	return -0.08333333333333333;
}

Fortran

real(8) function code(phip, ecc)
use fmin_fmax_functions
    real(8), intent (in) :: phip
    real(8), intent (in) :: ecc
    code = -0.08333333333333333d0
end function

Java

public static double code(double phip, double ecc) {
	return -0.08333333333333333;
}

Python

def code(phip, ecc):
	return -0.08333333333333333

Julia

function code(phip, ecc)
	return -0.08333333333333333
end

MATLAB

function tmp = code(phip, ecc)
	tmp = -0.08333333333333333;
end

Wolfram

code[phip_, ecc_] := -0.08333333333333333

ReFlow

f(phip, ecc):
	phip in [-inf, +inf],
	ecc in [0, 1]
code: THEORY
BEGIN
f(phip, ecc: real): real =
	-8333333333333332870740406406184774823486804962158203125e-56
END code

Derivation

1. Initial program 99.8%

   \[ecc \cdot \sin phip \]

2. Taylor expanded in phip around 0

   \[\leadsto phip \cdot \left(ecc + \frac{-1}{6} \cdot \left(ecc \cdot {phip}^{2}\right)\right) \]

4. Applied rewrites 51.2%

   \[\leadsto phip \cdot \left(ecc + -0.16666666666666666 \cdot \left(ecc \cdot {phip}^{2}\right)\right) \]

6. Applied rewrites 51.2%

   \[\leadsto \mathsf{fma}\left(\left(-0.16666666666666666 \cdot phip\right) \cdot ecc, phip \cdot phip, ecc \cdot phip\right) \]

8. Applied rewrites 3.6%

   \[\leadsto -0.08333333333333333 \]
9. Add Preprocessing

Reproduce

herbie shell --seed 2026050 +o generate:egglog
(FPCore (phip ecc)
  :name "inverse-esp"
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (* ecc (sin phip)))