Average Error: 0.2 → 0.0
Time: 1.2s
Precision: binary64
Cost: 320
\[\left(d1 \cdot 10 + d1 \cdot d2\right) + d1 \cdot 20 \]
↓
\[d1 \cdot \left(d2 + 30\right) \]
(FPCore (d1 d2) :precision binary64 (+ (+ (* d1 10.0) (* d1 d2)) (* d1 20.0)))
↓
(FPCore (d1 d2) :precision binary64 (* d1 (+ d2 30.0)))
double code(double d1, double d2) {
	return ((d1 * 10.0) + (d1 * d2)) + (d1 * 20.0);
}
↓
double code(double d1, double d2) {
	return d1 * (d2 + 30.0);
}

real(8) function code(d1, d2)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    code = ((d1 * 10.0d0) + (d1 * d2)) + (d1 * 20.0d0)
end function
↓
real(8) function code(d1, d2)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    code = d1 * (d2 + 30.0d0)
end function

public static double code(double d1, double d2) {
	return ((d1 * 10.0) + (d1 * d2)) + (d1 * 20.0);
}
↓
public static double code(double d1, double d2) {
	return d1 * (d2 + 30.0);
}

def code(d1, d2):
	return ((d1 * 10.0) + (d1 * d2)) + (d1 * 20.0)
↓
def code(d1, d2):
	return d1 * (d2 + 30.0)

function code(d1, d2)
	return Float64(Float64(Float64(d1 * 10.0) + Float64(d1 * d2)) + Float64(d1 * 20.0))
end
↓
function code(d1, d2)
	return Float64(d1 * Float64(d2 + 30.0))
end

function tmp = code(d1, d2)
	tmp = ((d1 * 10.0) + (d1 * d2)) + (d1 * 20.0);
end
↓
function tmp = code(d1, d2)
	tmp = d1 * (d2 + 30.0);
end

code[d1_, d2_] := N[(N[(N[(d1 * 10.0), $MachinePrecision] + N[(d1 * d2), $MachinePrecision]), $MachinePrecision] + N[(d1 * 20.0), $MachinePrecision]), $MachinePrecision]
↓
code[d1_, d2_] := N[(d1 * N[(d2 + 30.0), $MachinePrecision]), $MachinePrecision]

\left(d1 \cdot 10 + d1 \cdot d2\right) + d1 \cdot 20
↓
d1 \cdot \left(d2 + 30\right)

Error

Try it out

Your Program's Arguments

Results

Enter valid numbers for all inputs

Target

Original0.2
Target0.0
Herbie0.0
\[d1 \cdot \left(30 + d2\right) \]

Derivation

  1. Initial program 0.2

    \[\left(d1 \cdot 10 + d1 \cdot d2\right) + d1 \cdot 20 \]

  2. Simplified0.0

    \[\leadsto \color{blue}{d1 \cdot \left(d2 + 30\right)} \]
    Proof
    (*.f64 d1 (+.f64 d2 30)): 0 points increase in error, 0 points decrease in error
    (*.f64 d1 (+.f64 d2 (Rewrite<= metadata-eval (+.f64 10 20)))): 0 points increase in error, 0 points decrease in error
    (*.f64 d1 (Rewrite<= associate-+l+_binary64 (+.f64 (+.f64 d2 10) 20))): 1 points increase in error, 0 points decrease in error
    (*.f64 d1 (+.f64 (Rewrite<= +-commutative_binary64 (+.f64 10 d2)) 20)): 0 points increase in error, 0 points decrease in error
    (Rewrite<= distribute-lft-out_binary64 (+.f64 (*.f64 d1 (+.f64 10 d2)) (*.f64 d1 20))): 41 points increase in error, 0 points decrease in error
    (+.f64 (Rewrite<= distribute-lft-out_binary64 (+.f64 (*.f64 d1 10) (*.f64 d1 d2))) (*.f64 d1 20)): 1 points increase in error, 2 points decrease in error

  3. Final simplification0.0

    \[\leadsto d1 \cdot \left(d2 + 30\right) \]

Reproduce

herbie shell --seed 2022296 
(FPCore (d1 d2)
  :name "FastMath test2"
  :precision binary64

  :herbie-target
  (* d1 (+ 30.0 d2))

  (+ (+ (* d1 10.0) (* d1 d2)) (* d1 20.0)))