ab-angle->ABCF D

Percentage Accurate: 82.4% → 99.7%

Time: 46.9s

Alternatives: 3

Speedup: 1.0×

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

Specification

Math

\[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

FPCore

(FPCore (a b)
  :precision binary64
  :pre TRUE
  (- (* (* (* a a) b) b)))

C

double code(double a, double b) {
	return -(((a * a) * b) * b);
}

Fortran

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

Java

public static double code(double a, double b) {
	return -(((a * a) * b) * b);
}

Python

def code(a, b):
	return -(((a * a) * b) * b)

Julia

function code(a, b)
	return Float64(-Float64(Float64(Float64(a * a) * b) * b))
end

MATLAB

function tmp = code(a, b)
	tmp = -(((a * a) * b) * b);
end

Wolfram

code[a_, b_] := (-N[(N[(N[(a * a), $MachinePrecision] * b), $MachinePrecision] * b), $MachinePrecision])

ReFlow

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

Initial Program: 82.4% accurate, 1.0× speedup

Math

\[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

FPCore

(FPCore (a b)
  :precision binary64
  :pre TRUE
  (- (* (* (* a a) b) b)))

C

double code(double a, double b) {
	return -(((a * a) * b) * b);
}

Fortran

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

Java

public static double code(double a, double b) {
	return -(((a * a) * b) * b);
}

Python

def code(a, b):
	return -(((a * a) * b) * b)

Julia

function code(a, b)
	return Float64(-Float64(Float64(Float64(a * a) * b) * b))
end

MATLAB

function tmp = code(a, b)
	tmp = -(((a * a) * b) * b);
end

Wolfram

code[a_, b_] := (-N[(N[(N[(a * a), $MachinePrecision] * b), $MachinePrecision] * b), $MachinePrecision])

ReFlow

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

Alternative 1: 99.7% accurate, 1.0× speedup

Math

\[\left(-a \cdot b\right) \cdot \left(a \cdot b\right) \]

FPCore

(FPCore (a b)
  :precision binary64
  :pre TRUE
  (* (- (* a b)) (* a b)))

C

double code(double a, double b) {
	return -(a * b) * (a * b);
}

Fortran

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

Java

public static double code(double a, double b) {
	return -(a * b) * (a * b);
}

Python

def code(a, b):
	return -(a * b) * (a * b)

Julia

function code(a, b)
	return Float64(Float64(-Float64(a * b)) * Float64(a * b))
end

MATLAB

function tmp = code(a, b)
	tmp = -(a * b) * (a * b);
end

Wolfram

code[a_, b_] := N[((-N[(a * b), $MachinePrecision]) * N[(a * b), $MachinePrecision]), $MachinePrecision]

ReFlow

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

Derivation

1. Initial program 82.4%

   \[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

3. Applied rewrites 99.7%

   \[\leadsto \left(-a \cdot b\right) \cdot \left(a \cdot b\right) \]
4. Add Preprocessing

Alternative 2: 97.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\left|a\right|, \left|b\right|\right)\\ t_1 := \mathsf{max}\left(\left|a\right|, \left|b\right|\right)\\ t_2 := t\_0 \cdot t\_1\\ \mathbf{if}\;t\_0 \leq 6.580653175437961 \cdot 10^{-184}:\\ \;\;\;\;t\_0 \cdot \left(t\_1 \cdot \left(-t\_2\right)\right)\\ \mathbf{else}:\\ \;\;\;\;-\left(t\_0 \cdot t\_2\right) \cdot t\_1\\ \end{array} \]

FPCore

(FPCore (a b)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (fmin (fabs a) (fabs b)))
       (t_1 (fmax (fabs a) (fabs b)))
       (t_2 (* t_0 t_1)))
  (if (<= t_0 6.580653175437961e-184)
    (* t_0 (* t_1 (- t_2)))
    (- (* (* t_0 t_2) t_1)))))

C

double code(double a, double b) {
	double t_0 = fmin(fabs(a), fabs(b));
	double t_1 = fmax(fabs(a), fabs(b));
	double t_2 = t_0 * t_1;
	double tmp;
	if (t_0 <= 6.580653175437961e-184) {
		tmp = t_0 * (t_1 * -t_2);
	} else {
		tmp = -((t_0 * t_2) * t_1);
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
use fmin_fmax_functions
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = fmin(abs(a), abs(b))
    t_1 = fmax(abs(a), abs(b))
    t_2 = t_0 * t_1
    if (t_0 <= 6.580653175437961d-184) then
        tmp = t_0 * (t_1 * -t_2)
    else
        tmp = -((t_0 * t_2) * t_1)
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = fmin(Math.abs(a), Math.abs(b));
	double t_1 = fmax(Math.abs(a), Math.abs(b));
	double t_2 = t_0 * t_1;
	double tmp;
	if (t_0 <= 6.580653175437961e-184) {
		tmp = t_0 * (t_1 * -t_2);
	} else {
		tmp = -((t_0 * t_2) * t_1);
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = fmin(math.fabs(a), math.fabs(b))
	t_1 = fmax(math.fabs(a), math.fabs(b))
	t_2 = t_0 * t_1
	tmp = 0
	if t_0 <= 6.580653175437961e-184:
		tmp = t_0 * (t_1 * -t_2)
	else:
		tmp = -((t_0 * t_2) * t_1)
	return tmp

Julia

function code(a, b)
	t_0 = fmin(abs(a), abs(b))
	t_1 = fmax(abs(a), abs(b))
	t_2 = Float64(t_0 * t_1)
	tmp = 0.0
	if (t_0 <= 6.580653175437961e-184)
		tmp = Float64(t_0 * Float64(t_1 * Float64(-t_2)));
	else
		tmp = Float64(-Float64(Float64(t_0 * t_2) * t_1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = min(abs(a), abs(b));
	t_1 = max(abs(a), abs(b));
	t_2 = t_0 * t_1;
	tmp = 0.0;
	if (t_0 <= 6.580653175437961e-184)
		tmp = t_0 * (t_1 * -t_2);
	else
		tmp = -((t_0 * t_2) * t_1);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[Min[N[Abs[a], $MachinePrecision], N[Abs[b], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[a], $MachinePrecision], N[Abs[b], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 * t$95$1), $MachinePrecision]}, If[LessEqual[t$95$0, 6.580653175437961e-184], N[(t$95$0 * N[(t$95$1 * (-t$95$2)), $MachinePrecision]), $MachinePrecision], (-N[(N[(t$95$0 * t$95$2), $MachinePrecision] * t$95$1), $MachinePrecision])]]]]

ReFlow

f(a, b):
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(a, b: real): real =
	LET tmp = IF ((abs(a)) < (abs(b))) THEN (abs(a)) ELSE (abs(b)) ENDIF IN
	LET t_0 = tmp IN
		LET tmp_1 = IF ((abs(a)) > (abs(b))) THEN (abs(a)) ELSE (abs(b)) ENDIF IN
		LET t_1 = tmp_1 IN
			LET t_2 = (t_0 * t_1) IN
				LET tmp_2 = IF (t_0 <= (6580653175437961130972315507035316039922052352214427415602883917303577306908167843261101333977352445741999890370571693156360685975903822368447221195269477525483941385406300821766125308814118449361006089885061212554973432008766510200778526960623710544485438428125839386444199040355138899994550125162709451305605458029968780076651215964718388915448941700891493845257793716167470693081408622299581374250924692848730125573753504285561761522928281298305819291272200644016265869140625e-661)) THEN (t_0 * (t_1 * (- t_2))) ELSE (- ((t_0 * t_2) * t_1)) ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if a < 6.5806531754379611e-184

   1. Initial program 82.4%

      \[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

   3. Applied rewrites 81.9%

      \[\leadsto a \cdot \left(\left(-a\right) \cdot \left(b \cdot b\right)\right) \]

   5. Applied rewrites 94.3%

      \[\leadsto a \cdot \left(b \cdot \left(-a \cdot b\right)\right) \]

   if 6.5806531754379611e-184 < a

   1. Initial program 82.4%

      \[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

   3. Applied rewrites 93.9%

      \[\leadsto -\left(a \cdot \left(a \cdot b\right)\right) \cdot b \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 94.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\left|a\right|, b\right)\\ t_1 := \mathsf{max}\left(\left|a\right|, b\right)\\ -\left(t\_0 \cdot \left(t\_0 \cdot t\_1\right)\right) \cdot t\_1 \end{array} \]

FPCore

(FPCore (a b)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (fmin (fabs a) b)) (t_1 (fmax (fabs a) b)))
  (- (* (* t_0 (* t_0 t_1)) t_1))))

C

double code(double a, double b) {
	double t_0 = fmin(fabs(a), b);
	double t_1 = fmax(fabs(a), b);
	return -((t_0 * (t_0 * t_1)) * t_1);
}

Fortran

real(8) function code(a, b)
use fmin_fmax_functions
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    t_0 = fmin(abs(a), b)
    t_1 = fmax(abs(a), b)
    code = -((t_0 * (t_0 * t_1)) * t_1)
end function

Java

public static double code(double a, double b) {
	double t_0 = fmin(Math.abs(a), b);
	double t_1 = fmax(Math.abs(a), b);
	return -((t_0 * (t_0 * t_1)) * t_1);
}

Python

def code(a, b):
	t_0 = fmin(math.fabs(a), b)
	t_1 = fmax(math.fabs(a), b)
	return -((t_0 * (t_0 * t_1)) * t_1)

Julia

function code(a, b)
	t_0 = fmin(abs(a), b)
	t_1 = fmax(abs(a), b)
	return Float64(-Float64(Float64(t_0 * Float64(t_0 * t_1)) * t_1))
end

MATLAB

function tmp = code(a, b)
	t_0 = min(abs(a), b);
	t_1 = max(abs(a), b);
	tmp = -((t_0 * (t_0 * t_1)) * t_1);
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[Min[N[Abs[a], $MachinePrecision], b], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[a], $MachinePrecision], b], $MachinePrecision]}, (-N[(N[(t$95$0 * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision])]]

ReFlow

f(a, b):
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(a, b: real): real =
	LET tmp = IF ((abs(a)) < b) THEN (abs(a)) ELSE b ENDIF IN
	LET t_0 = tmp IN
		LET tmp_1 = IF ((abs(a)) > b) THEN (abs(a)) ELSE b ENDIF IN
		LET t_1 = tmp_1 IN
	- ((t_0 * (t_0 * t_1)) * t_1)
END code

Derivation

1. Initial program 82.4%

   \[-\left(\left(a \cdot a\right) \cdot b\right) \cdot b \]

3. Applied rewrites 93.9%

   \[\leadsto -\left(a \cdot \left(a \cdot b\right)\right) \cdot b \]
4. Add Preprocessing

Reproduce

herbie shell --seed 2026074 +o generate:egglog
(FPCore (a b)
  :name "ab-angle->ABCF D"
  :precision binary64
  (- (* (* (* a a) b) b)))