forward-v

Percentage Accurate: 30.5% → 99.7%

Time: 1.9min

Alternatives: 8

Speedup: 4.4×

Specification

Math

\[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (* 0.5 (* ArB (log (/ (- 1.0 U) (+ 1.0 U))))))

C

double code(double U, double ArB) {
	return 0.5 * (ArB * log(((1.0 - U) / (1.0 + U))));
}

Fortran

real(8) function code(u, arb)
use fmin_fmax_functions
    real(8), intent (in) :: u
    real(8), intent (in) :: arb
    code = 0.5d0 * (arb * log(((1.0d0 - u) / (1.0d0 + u))))
end function

Java

public static double code(double U, double ArB) {
	return 0.5 * (ArB * Math.log(((1.0 - U) / (1.0 + U))));
}

Python

def code(U, ArB):
	return 0.5 * (ArB * math.log(((1.0 - U) / (1.0 + U))))

Julia

function code(U, ArB)
	return Float64(0.5 * Float64(ArB * log(Float64(Float64(1.0 - U) / Float64(1.0 + U)))))
end

MATLAB

function tmp = code(U, ArB)
	tmp = 0.5 * (ArB * log(((1.0 - U) / (1.0 + U))));
end

Wolfram

code[U_, ArB_] := N[(0.5 * N[(ArB * N[Log[N[(N[(1.0 - U), $MachinePrecision] / N[(1.0 + U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(5e-1) * (ArB * (ln((((1) - U) / ((1) + U)))))
END code

Initial Program: 30.5% accurate, 1.0× speedup

Math

\[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (* 0.5 (* ArB (log (/ (- 1.0 U) (+ 1.0 U))))))

C

double code(double U, double ArB) {
	return 0.5 * (ArB * log(((1.0 - U) / (1.0 + U))));
}

Fortran

real(8) function code(u, arb)
use fmin_fmax_functions
    real(8), intent (in) :: u
    real(8), intent (in) :: arb
    code = 0.5d0 * (arb * log(((1.0d0 - u) / (1.0d0 + u))))
end function

Java

public static double code(double U, double ArB) {
	return 0.5 * (ArB * Math.log(((1.0 - U) / (1.0 + U))));
}

Python

def code(U, ArB):
	return 0.5 * (ArB * math.log(((1.0 - U) / (1.0 + U))))

Julia

function code(U, ArB)
	return Float64(0.5 * Float64(ArB * log(Float64(Float64(1.0 - U) / Float64(1.0 + U)))))
end

MATLAB

function tmp = code(U, ArB)
	tmp = 0.5 * (ArB * log(((1.0 - U) / (1.0 + U))));
end

Wolfram

code[U_, ArB_] := N[(0.5 * N[(ArB * N[Log[N[(N[(1.0 - U), $MachinePrecision] / N[(1.0 + U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(5e-1) * (ArB * (ln((((1) - U) / ((1) + U)))))
END code

Alternative 1: 99.7% accurate, 0.7× speedup

Math

\[\left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (*
 (-
  (*
   (* U U)
   (*
    (fma
     (fma -0.14285714285714285 (* U U) -0.2)
     (* U U)
     -0.3333333333333333)
    ArB))
  ArB)
 U))

C

double code(double U, double ArB) {
	return (((U * U) * (fma(fma(-0.14285714285714285, (U * U), -0.2), (U * U), -0.3333333333333333) * ArB)) - ArB) * U;
}

Julia

function code(U, ArB)
	return Float64(Float64(Float64(Float64(U * U) * Float64(fma(fma(-0.14285714285714285, Float64(U * U), -0.2), Float64(U * U), -0.3333333333333333) * ArB)) - ArB) * U)
end

Wolfram

code[U_, ArB_] := N[(N[(N[(N[(U * U), $MachinePrecision] * N[(N[(N[(-0.14285714285714285 * N[(U * U), $MachinePrecision] + -0.2), $MachinePrecision] * N[(U * U), $MachinePrecision] + -0.3333333333333333), $MachinePrecision] * ArB), $MachinePrecision]), $MachinePrecision] - ArB), $MachinePrecision] * U), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(((U * U) * ((((((-142857142857142849212692681248881854116916656494140625e-54) * (U * U)) + (-200000000000000011102230246251565404236316680908203125e-54)) * (U * U)) + (-333333333333333314829616256247390992939472198486328125e-54)) * ArB)) - ArB) * U
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{3} \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{5} \cdot ArB + \frac{-1}{7} \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

4. Applied rewrites 99.7%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.3333333333333333, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.2, ArB, -0.14285714285714285 \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

6. Applied rewrites 99.7%

   \[\leadsto U \cdot \left(\left(U \cdot U\right) \cdot \mathsf{fma}\left(ArB \cdot \left(U \cdot U\right), \mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), -0.3333333333333333 \cdot ArB\right) - ArB\right) \]

8. Applied rewrites 99.7%

   \[\leadsto \left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]
9. Add Preprocessing

Alternative 2: 99.7% accurate, 0.7× speedup

Math

\[\left(ArB \cdot \mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right), U \cdot U, -1\right)\right) \cdot U \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (*
 (*
  ArB
  (fma
   (fma
    (fma -0.14285714285714285 (* U U) -0.2)
    (* U U)
    -0.3333333333333333)
   (* U U)
   -1.0))
 U))

C

double code(double U, double ArB) {
	return (ArB * fma(fma(fma(-0.14285714285714285, (U * U), -0.2), (U * U), -0.3333333333333333), (U * U), -1.0)) * U;
}

Julia

function code(U, ArB)
	return Float64(Float64(ArB * fma(fma(fma(-0.14285714285714285, Float64(U * U), -0.2), Float64(U * U), -0.3333333333333333), Float64(U * U), -1.0)) * U)
end

Wolfram

code[U_, ArB_] := N[(N[(ArB * N[(N[(N[(-0.14285714285714285 * N[(U * U), $MachinePrecision] + -0.2), $MachinePrecision] * N[(U * U), $MachinePrecision] + -0.3333333333333333), $MachinePrecision] * N[(U * U), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * U), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(ArB * (((((((-142857142857142849212692681248881854116916656494140625e-54) * (U * U)) + (-200000000000000011102230246251565404236316680908203125e-54)) * (U * U)) + (-333333333333333314829616256247390992939472198486328125e-54)) * (U * U)) + (-1))) * U
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{3} \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{5} \cdot ArB + \frac{-1}{7} \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

4. Applied rewrites 99.7%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.3333333333333333, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.2, ArB, -0.14285714285714285 \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

6. Applied rewrites 99.7%

   \[\leadsto U \cdot \left(\left(U \cdot U\right) \cdot \mathsf{fma}\left(ArB \cdot \left(U \cdot U\right), \mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), -0.3333333333333333 \cdot ArB\right) - ArB\right) \]

8. Applied rewrites 99.7%

   \[\leadsto \left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]

10. Applied rewrites 99.7%

    \[\leadsto \left(ArB \cdot \mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right), U \cdot U, -1\right)\right) \cdot U \]
11. Add Preprocessing

Alternative 3: 99.6% accurate, 0.9× speedup

Math

\[\left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(-0.2, U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (*
 (- (* (* U U) (* (fma -0.2 (* U U) -0.3333333333333333) ArB)) ArB)
 U))

C

double code(double U, double ArB) {
	return (((U * U) * (fma(-0.2, (U * U), -0.3333333333333333) * ArB)) - ArB) * U;
}

Julia

function code(U, ArB)
	return Float64(Float64(Float64(Float64(U * U) * Float64(fma(-0.2, Float64(U * U), -0.3333333333333333) * ArB)) - ArB) * U)
end

Wolfram

code[U_, ArB_] := N[(N[(N[(N[(U * U), $MachinePrecision] * N[(N[(-0.2 * N[(U * U), $MachinePrecision] + -0.3333333333333333), $MachinePrecision] * ArB), $MachinePrecision]), $MachinePrecision] - ArB), $MachinePrecision] * U), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(((U * U) * ((((-200000000000000011102230246251565404236316680908203125e-54) * (U * U)) + (-333333333333333314829616256247390992939472198486328125e-54)) * ArB)) - ArB) * U
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{3} \cdot ArB + {U}^{2} \cdot \left(\frac{-1}{5} \cdot ArB + \frac{-1}{7} \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

4. Applied rewrites 99.7%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.3333333333333333, ArB, {U}^{2} \cdot \mathsf{fma}\left(-0.2, ArB, -0.14285714285714285 \cdot \left(ArB \cdot {U}^{2}\right)\right)\right)\right) \]

6. Applied rewrites 99.7%

   \[\leadsto U \cdot \left(\left(U \cdot U\right) \cdot \mathsf{fma}\left(ArB \cdot \left(U \cdot U\right), \mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), -0.3333333333333333 \cdot ArB\right) - ArB\right) \]

8. Applied rewrites 99.7%

   \[\leadsto \left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(-0.14285714285714285, U \cdot U, -0.2\right), U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]

9. Taylor expanded in U around 0

   \[\leadsto \left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(\frac{-1}{5}, U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]

11. Applied rewrites 99.6%

    \[\leadsto \left(\left(U \cdot U\right) \cdot \left(\mathsf{fma}\left(-0.2, U \cdot U, -0.3333333333333333\right) \cdot ArB\right) - ArB\right) \cdot U \]
12. Add Preprocessing

Alternative 4: 99.5% accurate, 1.2× speedup

Math

\[\left(\left(U \cdot U\right) \cdot U\right) \cdot \left(-0.3333333333333333 \cdot ArB\right) - ArB \cdot U \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (- (* (* (* U U) U) (* -0.3333333333333333 ArB)) (* ArB U)))

C

double code(double U, double ArB) {
	return (((U * U) * U) * (-0.3333333333333333 * ArB)) - (ArB * U);
}

Fortran

real(8) function code(u, arb)
use fmin_fmax_functions
    real(8), intent (in) :: u
    real(8), intent (in) :: arb
    code = (((u * u) * u) * ((-0.3333333333333333d0) * arb)) - (arb * u)
end function

Java

public static double code(double U, double ArB) {
	return (((U * U) * U) * (-0.3333333333333333 * ArB)) - (ArB * U);
}

Python

def code(U, ArB):
	return (((U * U) * U) * (-0.3333333333333333 * ArB)) - (ArB * U)

Julia

function code(U, ArB)
	return Float64(Float64(Float64(Float64(U * U) * U) * Float64(-0.3333333333333333 * ArB)) - Float64(ArB * U))
end

MATLAB

function tmp = code(U, ArB)
	tmp = (((U * U) * U) * (-0.3333333333333333 * ArB)) - (ArB * U);
end

Wolfram

code[U_, ArB_] := N[(N[(N[(N[(U * U), $MachinePrecision] * U), $MachinePrecision] * N[(-0.3333333333333333 * ArB), $MachinePrecision]), $MachinePrecision] - N[(ArB * U), $MachinePrecision]), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(((U * U) * U) * ((-333333333333333314829616256247390992939472198486328125e-54) * ArB)) - (ArB * U)
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + \frac{-1}{3} \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

4. Applied rewrites 99.5%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, -0.3333333333333333 \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

6. Applied rewrites 99.5%

   \[\leadsto \left(\left(U \cdot U\right) \cdot U\right) \cdot \left(-0.3333333333333333 \cdot ArB\right) - ArB \cdot U \]
7. Add Preprocessing

Alternative 5: 99.5% accurate, 1.5× speedup

Math

\[\mathsf{fma}\left(-0.3333333333333333, U \cdot U, -1\right) \cdot \left(ArB \cdot U\right) \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (* (fma -0.3333333333333333 (* U U) -1.0) (* ArB U)))

C

double code(double U, double ArB) {
	return fma(-0.3333333333333333, (U * U), -1.0) * (ArB * U);
}

Julia

function code(U, ArB)
	return Float64(fma(-0.3333333333333333, Float64(U * U), -1.0) * Float64(ArB * U))
end

Wolfram

code[U_, ArB_] := N[(N[(-0.3333333333333333 * N[(U * U), $MachinePrecision] + -1.0), $MachinePrecision] * N[(ArB * U), $MachinePrecision]), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	(((-333333333333333314829616256247390992939472198486328125e-54) * (U * U)) + (-1)) * (ArB * U)
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + \frac{-1}{3} \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

4. Applied rewrites 99.5%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, -0.3333333333333333 \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

6. Applied rewrites 99.5%

   \[\leadsto U \cdot \left(ArB \cdot \mathsf{fma}\left(-0.3333333333333333, U \cdot U, -1\right)\right) \]

8. Applied rewrites 99.5%

   \[\leadsto \mathsf{fma}\left(-0.3333333333333333, U \cdot U, -1\right) \cdot \left(ArB \cdot U\right) \]
9. Add Preprocessing

Alternative 6: 99.5% accurate, 1.5× speedup

Math

\[U \cdot \left(ArB \cdot \mathsf{fma}\left(-0.3333333333333333, U \cdot U, -1\right)\right) \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (* U (* ArB (fma -0.3333333333333333 (* U U) -1.0))))

C

double code(double U, double ArB) {
	return U * (ArB * fma(-0.3333333333333333, (U * U), -1.0));
}

Julia

function code(U, ArB)
	return Float64(U * Float64(ArB * fma(-0.3333333333333333, Float64(U * U), -1.0)))
end

Wolfram

code[U_, ArB_] := N[(U * N[(ArB * N[(-0.3333333333333333 * N[(U * U), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	U * (ArB * (((-333333333333333314829616256247390992939472198486328125e-54) * (U * U)) + (-1)))
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto U \cdot \left(-1 \cdot ArB + \frac{-1}{3} \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

4. Applied rewrites 99.5%

   \[\leadsto U \cdot \mathsf{fma}\left(-1, ArB, -0.3333333333333333 \cdot \left(ArB \cdot {U}^{2}\right)\right) \]

6. Applied rewrites 99.5%

   \[\leadsto U \cdot \left(ArB \cdot \mathsf{fma}\left(-0.3333333333333333, U \cdot U, -1\right)\right) \]
7. Add Preprocessing

Alternative 7: 99.0% accurate, 4.4× speedup

Math

\[-ArB \cdot U \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (- (* ArB U)))

C

double code(double U, double ArB) {
	return -(ArB * U);
}

Fortran

real(8) function code(u, arb)
use fmin_fmax_functions
    real(8), intent (in) :: u
    real(8), intent (in) :: arb
    code = -(arb * u)
end function

Java

public static double code(double U, double ArB) {
	return -(ArB * U);
}

Python

def code(U, ArB):
	return -(ArB * U)

Julia

function code(U, ArB)
	return Float64(-Float64(ArB * U))
end

MATLAB

function tmp = code(U, ArB)
	tmp = -(ArB * U);
end

Wolfram

code[U_, ArB_] := (-N[(ArB * U), $MachinePrecision])

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	- (ArB * U)
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around 0

   \[\leadsto -1 \cdot \left(ArB \cdot U\right) \]

4. Applied rewrites 99.0%

   \[\leadsto -1 \cdot \left(ArB \cdot U\right) \]

6. Applied rewrites 99.0%

   \[\leadsto -ArB \cdot U \]
7. Add Preprocessing

Alternative 8: 1.9% accurate, 4.6× speedup

Math

\[\frac{ArB}{U} \]

FPCore

(FPCore (U ArB)
  :precision binary64
  :pre TRUE
  (/ ArB U))

C

double code(double U, double ArB) {
	return ArB / U;
}

Fortran

real(8) function code(u, arb)
use fmin_fmax_functions
    real(8), intent (in) :: u
    real(8), intent (in) :: arb
    code = arb / u
end function

Java

public static double code(double U, double ArB) {
	return ArB / U;
}

Python

def code(U, ArB):
	return ArB / U

Julia

function code(U, ArB)
	return Float64(ArB / U)
end

MATLAB

function tmp = code(U, ArB)
	tmp = ArB / U;
end

Wolfram

code[U_, ArB_] := N[(ArB / U), $MachinePrecision]

ReFlow

f(U, ArB):
	U in [-inf, +inf],
	ArB in [-inf, +inf]
code: THEORY
BEGIN
f(U, ArB: real): real =
	ArB / U
END code

Derivation

1. Initial program 30.5%

   \[0.5 \cdot \left(ArB \cdot \log \left(\frac{1 - U}{1 + U}\right)\right) \]

2. Taylor expanded in U around inf

   \[\leadsto \frac{ArB}{U} \]

4. Applied rewrites 1.9%

   \[\leadsto \frac{ArB}{U} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026050 +o generate:egglog
(FPCore (U ArB)
  :name "forward-v"
  :precision binary64
  (* 0.5 (* ArB (log (/ (- 1.0 U) (+ 1.0 U))))))