Disney BSSRDF, sample scattering profile, lower

Percentage Accurate: 61.5% → 99.3%

Time: 24.8s

Alternatives: 15

Speedup: 2.8×

Specification

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* s (log (/ 1.0 (- 1.0 (* 4.0 u))))))

C

float code(float s, float u) {
	return s * logf((1.0f / (1.0f - (4.0f * u))));
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = s * log((1.0e0 / (1.0e0 - (4.0e0 * u))))
end function

Julia

function code(s, u)
	return Float32(s * log(Float32(Float32(1.0) / Float32(Float32(1.0) - Float32(Float32(4.0) * u)))))
end

MATLAB

function tmp = code(s, u)
	tmp = s * log((single(1.0) / (single(1.0) - (single(4.0) * u))));
end

Initial Program: 61.5% accurate, 1.0× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* s (log (/ 1.0 (- 1.0 (* 4.0 u))))))

C

float code(float s, float u) {
	return s * logf((1.0f / (1.0f - (4.0f * u))));
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = s * log((1.0e0 / (1.0e0 - (4.0e0 * u))))
end function

Julia

function code(s, u)
	return Float32(s * log(Float32(Float32(1.0) / Float32(Float32(1.0) - Float32(Float32(4.0) * u)))))
end

MATLAB

function tmp = code(s, u)
	tmp = s * log((single(1.0) / (single(1.0) - (single(4.0) * u))));
end

Alternative 1: 99.3% accurate, 1.0× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[-1 \cdot \left(s \cdot \mathsf{log1p}\left(-4 \cdot u\right)\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* -1.0 (* s (log1p (* -4.0 u)))))

C

float code(float s, float u) {
	return -1.0f * (s * log1pf((-4.0f * u)));
}

Julia

function code(s, u)
	return Float32(Float32(-1.0) * Float32(s * log1p(Float32(Float32(-4.0) * u))))
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

4. Applied rewrites 91.1%

   \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

6. Applied rewrites 91.1%

   \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

7. Taylor expanded in s around 0

   \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

9. Applied rewrites 63.9%

   \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

11. Applied rewrites 99.3%

    \[\leadsto -1 \cdot \left(s \cdot \mathsf{log1p}\left(-4 \cdot u\right)\right) \]
12. Add Preprocessing

Alternative 2: 98.4% accurate, 0.7× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;4 \cdot u \leq 0.014499999582767487:\\ \;\;\;\;s \cdot \mathsf{fma}\left(u \cdot u, \mathsf{fma}\left(u, 21.333333333333332, 8\right), u \cdot 4\right)\\ \mathbf{else}:\\ \;\;\;\;\log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right)\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= (* 4.0 u) 0.014499999582767487)
  (* s (fma (* u u) (fma u 21.333333333333332 8.0) (* u 4.0)))
  (* (log (fma u -4.0 1.0)) (- s))))

C

float code(float s, float u) {
	float tmp;
	if ((4.0f * u) <= 0.014499999582767487f) {
		tmp = s * fmaf((u * u), fmaf(u, 21.333333333333332f, 8.0f), (u * 4.0f));
	} else {
		tmp = logf(fmaf(u, -4.0f, 1.0f)) * -s;
	}
	return tmp;
}

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (Float32(Float32(4.0) * u) <= Float32(0.014499999582767487))
		tmp = Float32(s * fma(Float32(u * u), fma(u, Float32(21.333333333333332), Float32(8.0)), Float32(u * Float32(4.0))));
	else
		tmp = Float32(log(fma(u, Float32(-4.0), Float32(1.0))) * Float32(-s));
	end
	return tmp
end

Derivation

1. Split input into 2 regimes

2. if (*.f32 #s(literal 4 binary32) u) < 0.0144999996

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.3%

      \[\leadsto s \cdot \mathsf{fma}\left(u \cdot u, \mathsf{fma}\left(u, 21.333333333333332, 8\right), u \cdot 4\right) \]

   if 0.0144999996 < (*.f32 #s(literal 4 binary32) u)

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

   7. Taylor expanded in s around 0

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   9. Applied rewrites 63.9%

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   11. Applied rewrites 63.9%

       \[\leadsto \log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 98.3% accurate, 0.7× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;4 \cdot u \leq 0.014499999582767487:\\ \;\;\;\;u \cdot \mathsf{fma}\left(4, s, u \cdot \left(s \cdot \mathsf{fma}\left(u, 21.333333333333332, 8\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right)\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= (* 4.0 u) 0.014499999582767487)
  (* u (fma 4.0 s (* u (* s (fma u 21.333333333333332 8.0)))))
  (* (log (fma u -4.0 1.0)) (- s))))

C

float code(float s, float u) {
	float tmp;
	if ((4.0f * u) <= 0.014499999582767487f) {
		tmp = u * fmaf(4.0f, s, (u * (s * fmaf(u, 21.333333333333332f, 8.0f))));
	} else {
		tmp = logf(fmaf(u, -4.0f, 1.0f)) * -s;
	}
	return tmp;
}

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (Float32(Float32(4.0) * u) <= Float32(0.014499999582767487))
		tmp = Float32(u * fma(Float32(4.0), s, Float32(u * Float32(s * fma(u, Float32(21.333333333333332), Float32(8.0))))));
	else
		tmp = Float32(log(fma(u, Float32(-4.0), Float32(1.0))) * Float32(-s));
	end
	return tmp
end

Derivation

1. Split input into 2 regimes

2. if (*.f32 #s(literal 4 binary32) u) < 0.0144999996

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto u \cdot \left(4 \cdot s + u \cdot \left(8 \cdot s + \frac{64}{3} \cdot \left(s \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.3%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \mathsf{fma}\left(8, s, 21.333333333333332 \cdot \left(s \cdot u\right)\right)\right) \]

   5. Taylor expanded in s around 0

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \left(s \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   7. Applied rewrites 91.3%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \left(s \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   9. Applied rewrites 91.3%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \left(s \cdot \mathsf{fma}\left(u, 21.333333333333332, 8\right)\right)\right) \]

   if 0.0144999996 < (*.f32 #s(literal 4 binary32) u)

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

   7. Taylor expanded in s around 0

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   9. Applied rewrites 63.9%

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   11. Applied rewrites 63.9%

       \[\leadsto \log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 98.1% accurate, 0.8× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;4 \cdot u \leq 0.014499999582767487:\\ \;\;\;\;\left(s \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \cdot u\\ \mathbf{else}:\\ \;\;\;\;\log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right)\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= (* 4.0 u) 0.014499999582767487)
  (* (* s (fma (fma u 21.333333333333332 8.0) u 4.0)) u)
  (* (log (fma u -4.0 1.0)) (- s))))

C

float code(float s, float u) {
	float tmp;
	if ((4.0f * u) <= 0.014499999582767487f) {
		tmp = (s * fmaf(fmaf(u, 21.333333333333332f, 8.0f), u, 4.0f)) * u;
	} else {
		tmp = logf(fmaf(u, -4.0f, 1.0f)) * -s;
	}
	return tmp;
}

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (Float32(Float32(4.0) * u) <= Float32(0.014499999582767487))
		tmp = Float32(Float32(s * fma(fma(u, Float32(21.333333333333332), Float32(8.0)), u, Float32(4.0))) * u);
	else
		tmp = Float32(log(fma(u, Float32(-4.0), Float32(1.0))) * Float32(-s));
	end
	return tmp
end

Derivation

1. Split input into 2 regimes

2. if (*.f32 #s(literal 4 binary32) u) < 0.0144999996

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto u \cdot \left(4 \cdot s + u \cdot \left(8 \cdot s + \frac{64}{3} \cdot \left(s \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.3%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \mathsf{fma}\left(8, s, 21.333333333333332 \cdot \left(s \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.0%

      \[\leadsto \mathsf{fma}\left(u \cdot u, \mathsf{fma}\left(8, s, 21.333333333333332 \cdot \left(s \cdot u\right)\right), 4 \cdot \left(s \cdot u\right)\right) \]

   8. Applied rewrites 91.1%

      \[\leadsto \left(s \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \cdot u \]

   if 0.0144999996 < (*.f32 #s(literal 4 binary32) u)

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

   7. Taylor expanded in s around 0

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   9. Applied rewrites 63.9%

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   11. Applied rewrites 63.9%

       \[\leadsto \log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 97.8% accurate, 0.8× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;4 \cdot u \leq 0.014499999582767487:\\ \;\;\;\;\left(s \cdot u\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\\ \mathbf{else}:\\ \;\;\;\;\log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right)\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= (* 4.0 u) 0.014499999582767487)
  (* (* s u) (fma (fma u 21.333333333333332 8.0) u 4.0))
  (* (log (fma u -4.0 1.0)) (- s))))

C

float code(float s, float u) {
	float tmp;
	if ((4.0f * u) <= 0.014499999582767487f) {
		tmp = (s * u) * fmaf(fmaf(u, 21.333333333333332f, 8.0f), u, 4.0f);
	} else {
		tmp = logf(fmaf(u, -4.0f, 1.0f)) * -s;
	}
	return tmp;
}

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (Float32(Float32(4.0) * u) <= Float32(0.014499999582767487))
		tmp = Float32(Float32(s * u) * fma(fma(u, Float32(21.333333333333332), Float32(8.0)), u, Float32(4.0)));
	else
		tmp = Float32(log(fma(u, Float32(-4.0), Float32(1.0))) * Float32(-s));
	end
	return tmp
end

Derivation

1. Split input into 2 regimes

2. if (*.f32 #s(literal 4 binary32) u) < 0.0144999996

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto u \cdot \left(4 \cdot s + u \cdot \left(8 \cdot s + \frac{64}{3} \cdot \left(s \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.3%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, u \cdot \mathsf{fma}\left(8, s, 21.333333333333332 \cdot \left(s \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.0%

      \[\leadsto \mathsf{fma}\left(u \cdot u, \mathsf{fma}\left(8, s, 21.333333333333332 \cdot \left(s \cdot u\right)\right), 4 \cdot \left(s \cdot u\right)\right) \]

   8. Applied rewrites 91.1%

      \[\leadsto \left(s \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \cdot u \]

   10. Applied rewrites 90.8%

       \[\leadsto \left(s \cdot u\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right) \]

   if 0.0144999996 < (*.f32 #s(literal 4 binary32) u)

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

   7. Taylor expanded in s around 0

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   9. Applied rewrites 63.9%

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   11. Applied rewrites 63.9%

       \[\leadsto \log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 96.9% accurate, 0.9× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;4 \cdot u \leq 0.004000000189989805:\\ \;\;\;\;u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right)\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= (* 4.0 u) 0.004000000189989805)
  (* u (fma 4.0 s (* 8.0 (* s u))))
  (* (log (fma u -4.0 1.0)) (- s))))

C

float code(float s, float u) {
	float tmp;
	if ((4.0f * u) <= 0.004000000189989805f) {
		tmp = u * fmaf(4.0f, s, (8.0f * (s * u)));
	} else {
		tmp = logf(fmaf(u, -4.0f, 1.0f)) * -s;
	}
	return tmp;
}

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (Float32(Float32(4.0) * u) <= Float32(0.004000000189989805))
		tmp = Float32(u * fma(Float32(4.0), s, Float32(Float32(8.0) * Float32(s * u))));
	else
		tmp = Float32(log(fma(u, Float32(-4.0), Float32(1.0))) * Float32(-s));
	end
	return tmp
end

Derivation

1. Split input into 2 regimes

2. if (*.f32 #s(literal 4 binary32) u) < 0.00400000019

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto u \cdot \left(4 \cdot s + 8 \cdot \left(s \cdot u\right)\right) \]

   4. Applied rewrites 86.9%

      \[\leadsto u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right) \]

   if 0.00400000019 < (*.f32 #s(literal 4 binary32) u)

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   2. Taylor expanded in u around 0

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + \frac{64}{3} \cdot u\right)\right)\right) \]

   4. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \left(4 + u \cdot \left(8 + 21.333333333333332 \cdot u\right)\right)\right) \]

   6. Applied rewrites 91.1%

      \[\leadsto s \cdot \left(u \cdot \mathsf{fma}\left(\mathsf{fma}\left(u, 21.333333333333332, 8\right), u, 4\right)\right) \]

   7. Taylor expanded in s around 0

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   9. Applied rewrites 63.9%

      \[\leadsto -1 \cdot \left(s \cdot \log \left(1 + -4 \cdot u\right)\right) \]

   11. Applied rewrites 63.9%

       \[\leadsto \log \left(\mathsf{fma}\left(u, -4, 1\right)\right) \cdot \left(-s\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 86.9% accurate, 1.3× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* u (fma 4.0 s (* 8.0 (* s u)))))

C

float code(float s, float u) {
	return u * fmaf(4.0f, s, (8.0f * (s * u)));
}

Julia

function code(s, u)
	return Float32(u * fma(Float32(4.0), s, Float32(Float32(8.0) * Float32(s * u))))
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto u \cdot \left(4 \cdot s + 8 \cdot \left(s \cdot u\right)\right) \]

4. Applied rewrites 86.9%

   \[\leadsto u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right) \]
5. Add Preprocessing

Alternative 8: 86.7% accurate, 1.6× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\left(s \cdot \mathsf{fma}\left(u, 8, 4\right)\right) \cdot u \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* (* s (fma u 8.0 4.0)) u))

C

float code(float s, float u) {
	return (s * fmaf(u, 8.0f, 4.0f)) * u;
}

Julia

function code(s, u)
	return Float32(Float32(s * fma(u, Float32(8.0), Float32(4.0))) * u)
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto u \cdot \left(4 \cdot s + 8 \cdot \left(s \cdot u\right)\right) \]

4. Applied rewrites 86.9%

   \[\leadsto u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right) \]

6. Applied rewrites 87.2%

   \[\leadsto \mathsf{fma}\left(s, u \cdot 4, \left(s \cdot 8\right) \cdot \left(u \cdot u\right)\right) \]

8. Applied rewrites 86.7%

   \[\leadsto \left(s \cdot \mathsf{fma}\left(u, 8, 4\right)\right) \cdot u \]
9. Add Preprocessing

Alternative 9: 86.4% accurate, 1.6× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\left(s \cdot u\right) \cdot \mathsf{fma}\left(u, 8, 4\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* (* s u) (fma u 8.0 4.0)))

C

float code(float s, float u) {
	return (s * u) * fmaf(u, 8.0f, 4.0f);
}

Julia

function code(s, u)
	return Float32(Float32(s * u) * fma(u, Float32(8.0), Float32(4.0)))
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto u \cdot \left(4 \cdot s + 8 \cdot \left(s \cdot u\right)\right) \]

4. Applied rewrites 86.9%

   \[\leadsto u \cdot \mathsf{fma}\left(4, s, 8 \cdot \left(s \cdot u\right)\right) \]

6. Applied rewrites 87.2%

   \[\leadsto \mathsf{fma}\left(s, u \cdot 4, \left(s \cdot 8\right) \cdot \left(u \cdot u\right)\right) \]

8. Applied rewrites 86.7%

   \[\leadsto \left(s \cdot \mathsf{fma}\left(u, 8, 4\right)\right) \cdot u \]

10. Applied rewrites 86.4%

    \[\leadsto \left(s \cdot u\right) \cdot \mathsf{fma}\left(u, 8, 4\right) \]
11. Add Preprocessing

Alternative 10: 73.8% accurate, 2.8× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[s \cdot \left(u \cdot 4\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* s (* u 4.0)))

C

float code(float s, float u) {
	return s * (u * 4.0f);
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = s * (u * 4.0e0)
end function

Julia

function code(s, u)
	return Float32(s * Float32(u * Float32(4.0)))
end

MATLAB

function tmp = code(s, u)
	tmp = s * (u * single(4.0));
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto s \cdot \left(u \cdot \left(4 + 8 \cdot u\right)\right) \]

4. Applied rewrites 86.7%

   \[\leadsto s \cdot \left(u \cdot \left(4 + 8 \cdot u\right)\right) \]

5. Taylor expanded in u around 0

   \[\leadsto s \cdot \left(u \cdot 4\right) \]

7. Applied rewrites 73.8%

   \[\leadsto s \cdot \left(u \cdot 4\right) \]
8. Add Preprocessing

Alternative 11: 73.6% accurate, 2.8× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[4 \cdot \left(s \cdot u\right) \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* 4.0 (* s u)))

C

float code(float s, float u) {
	return 4.0f * (s * u);
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = 4.0e0 * (s * u)
end function

Julia

function code(s, u)
	return Float32(Float32(4.0) * Float32(s * u))
end

MATLAB

function tmp = code(s, u)
	tmp = single(4.0) * (s * u);
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

2. Taylor expanded in u around 0

   \[\leadsto 4 \cdot \left(s \cdot u\right) \]

4. Applied rewrites 73.6%

   \[\leadsto 4 \cdot \left(s \cdot u\right) \]
5. Add Preprocessing

Alternative 12: 22.0% accurate, 2.6× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;s \leq 4.307599612825561 \cdot 10^{-29}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;s + s\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= s 4.307599612825561e-29) 0.0 (+ s s)))

C

float code(float s, float u) {
	float tmp;
	if (s <= 4.307599612825561e-29f) {
		tmp = 0.0f;
	} else {
		tmp = s + s;
	}
	return tmp;
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    real(4) :: tmp
    if (s <= 4.307599612825561e-29) then
        tmp = 0.0e0
    else
        tmp = s + s
    end if
    code = tmp
end function

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (s <= Float32(4.307599612825561e-29))
		tmp = Float32(0.0);
	else
		tmp = Float32(s + s);
	end
	return tmp
end

MATLAB

function tmp_2 = code(s, u)
	tmp = single(0.0);
	if (s <= single(4.307599612825561e-29))
		tmp = single(0.0);
	else
		tmp = s + s;
	end
	tmp_2 = tmp;
end

Derivation

1. Split input into 2 regimes

2. if s < 4.30759961e-29

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   3. Applied rewrites 16.5%

      \[\leadsto 0 \]

   if 4.30759961e-29 < s

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   3. Applied rewrites 17.3%

      \[\leadsto s \cdot 2 \]

   5. Applied rewrites 17.3%

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

Alternative 13: 20.8% accurate, 4.8× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[s \cdot 0.015625 \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* s 0.015625))

C

float code(float s, float u) {
	return s * 0.015625f;
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = s * 0.015625e0
end function

Julia

function code(s, u)
	return Float32(s * Float32(0.015625))
end

MATLAB

function tmp = code(s, u)
	tmp = s * single(0.015625);
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

3. Applied rewrites 20.8%

   \[\leadsto s \cdot 0.015625 \]
4. Add Preprocessing

Alternative 14: 20.3% accurate, 4.0× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[\begin{array}{l} \mathbf{if}\;s \leq 1.235573164014442 \cdot 10^{-17}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;u\\ \end{array} \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (if (<= s 1.235573164014442e-17) 0.0 u))

C

float code(float s, float u) {
	float tmp;
	if (s <= 1.235573164014442e-17f) {
		tmp = 0.0f;
	} else {
		tmp = u;
	}
	return tmp;
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    real(4) :: tmp
    if (s <= 1.235573164014442e-17) then
        tmp = 0.0e0
    else
        tmp = u
    end if
    code = tmp
end function

Julia

function code(s, u)
	tmp = Float32(0.0)
	if (s <= Float32(1.235573164014442e-17))
		tmp = Float32(0.0);
	else
		tmp = u;
	end
	return tmp
end

MATLAB

function tmp_2 = code(s, u)
	tmp = single(0.0);
	if (s <= single(1.235573164014442e-17))
		tmp = single(0.0);
	else
		tmp = u;
	end
	tmp_2 = tmp;
end

Derivation

1. Split input into 2 regimes

2. if s < 1.23557316e-17

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   3. Applied rewrites 16.5%

      \[\leadsto 0 \]

   if 1.23557316e-17 < s

   1. Initial program 61.5%

      \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

   3. Applied rewrites 11.9%

      \[\leadsto 1 \cdot u \]

   5. Applied rewrites 11.9%

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

Alternative 15: 16.5% accurate, 19.4× speedup

\[\left(0 \leq s \land s \leq 256\right) \land \left(2.328306437 \cdot 10^{-10} \leq u \land u \leq 0.25\right)\]

Math

\[0 \]

FPCore

(FPCore (s u)
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0))
     (and (<= 2.328306437e-10 u) (<= u 0.25)))
  0.0)

C

float code(float s, float u) {
	return 0.0f;
}

Fortran

real(4) function code(s, u)
use fmin_fmax_functions
    real(4), intent (in) :: s
    real(4), intent (in) :: u
    code = 0.0e0
end function

Julia

function code(s, u)
	return Float32(0.0)
end

MATLAB

function tmp = code(s, u)
	tmp = single(0.0);
end

Derivation

1. Initial program 61.5%

   \[s \cdot \log \left(\frac{1}{1 - 4 \cdot u}\right) \]

3. Applied rewrites 16.5%

   \[\leadsto 0 \]
4. Add Preprocessing

Reproduce

herbie shell --seed 2026089 +o generate:egglog
(FPCore (s u)
  :name "Disney BSSRDF, sample scattering profile, lower"
  :precision binary32
  :pre (and (and (<= 0.0 s) (<= s 256.0)) (and (<= 2.328306437e-10 u) (<= u 0.25)))
  (* s (log (/ 1.0 (- 1.0 (* 4.0 u))))))