Logistic distribution

Percentage Accurate: 99.5% → 99.5%

Time: 29.2s

Alternatives: 13

Speedup: 1.4×

Specification

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := e^{\frac{-\left|x\right|}{s}}\\ t_1 := 1 + t\_0\\ \frac{t\_0}{\left(s \cdot t\_1\right) \cdot t\_1} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (exp (/ (- (fabs x)) s))) (t_1 (+ 1.0 t_0)))
  (/ t_0 (* (* s t_1) t_1))))

C

float code(float x, float s) {
	float t_0 = expf((-fabsf(x) / s));
	float t_1 = 1.0f + t_0;
	return t_0 / ((s * t_1) * t_1);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    real(4) :: t_1
    t_0 = exp((-abs(x) / s))
    t_1 = 1.0e0 + t_0
    code = t_0 / ((s * t_1) * t_1)
end function

Julia

function code(x, s)
	t_0 = exp(Float32(Float32(-abs(x)) / s))
	t_1 = Float32(Float32(1.0) + t_0)
	return Float32(t_0 / Float32(Float32(s * t_1) * t_1))
end

MATLAB

function tmp = code(x, s)
	t_0 = exp((-abs(x) / s));
	t_1 = single(1.0) + t_0;
	tmp = t_0 / ((s * t_1) * t_1);
end

Initial Program: 99.5% accurate, 1.0× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := e^{\frac{-\left|x\right|}{s}}\\ t_1 := 1 + t\_0\\ \frac{t\_0}{\left(s \cdot t\_1\right) \cdot t\_1} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (exp (/ (- (fabs x)) s))) (t_1 (+ 1.0 t_0)))
  (/ t_0 (* (* s t_1) t_1))))

C

float code(float x, float s) {
	float t_0 = expf((-fabsf(x) / s));
	float t_1 = 1.0f + t_0;
	return t_0 / ((s * t_1) * t_1);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    real(4) :: t_1
    t_0 = exp((-abs(x) / s))
    t_1 = 1.0e0 + t_0
    code = t_0 / ((s * t_1) * t_1)
end function

Julia

function code(x, s)
	t_0 = exp(Float32(Float32(-abs(x)) / s))
	t_1 = Float32(Float32(1.0) + t_0)
	return Float32(t_0 / Float32(Float32(s * t_1) * t_1))
end

MATLAB

function tmp = code(x, s)
	t_0 = exp((-abs(x) / s));
	t_1 = single(1.0) + t_0;
	tmp = t_0 / ((s * t_1) * t_1);
end

Alternative 1: 99.5% accurate, 1.4× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := \frac{\left|x\right|}{s}\\ \frac{1}{\left(e^{-t\_0} - -1\right) \cdot \left(s \cdot \left(e^{t\_0} + 1\right)\right)} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (/ (fabs x) s)))
  (/ 1.0 (* (- (exp (- t_0)) -1.0) (* s (+ (exp t_0) 1.0))))))

C

float code(float x, float s) {
	float t_0 = fabsf(x) / s;
	return 1.0f / ((expf(-t_0) - -1.0f) * (s * (expf(t_0) + 1.0f)));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    t_0 = abs(x) / s
    code = 1.0e0 / ((exp(-t_0) - (-1.0e0)) * (s * (exp(t_0) + 1.0e0)))
end function

Julia

function code(x, s)
	t_0 = Float32(abs(x) / s)
	return Float32(Float32(1.0) / Float32(Float32(exp(Float32(-t_0)) - Float32(-1.0)) * Float32(s * Float32(exp(t_0) + Float32(1.0)))))
end

MATLAB

function tmp = code(x, s)
	t_0 = abs(x) / s;
	tmp = single(1.0) / ((exp(-t_0) - single(-1.0)) * (s * (exp(t_0) + single(1.0))));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

3. Applied rewrites 99.5%

   \[\leadsto \frac{1}{\frac{{\left(e^{-\frac{\left|x\right|}{s}} - -1\right)}^{2} \cdot s}{e^{-\frac{\left|x\right|}{s}}}} \]

5. Applied rewrites 99.5%

   \[\leadsto \frac{1}{\left(e^{-\frac{\left|x\right|}{s}} - -1\right) \cdot \left(s \cdot \left(e^{\frac{\left|x\right|}{s}} + 1\right)\right)} \]
6. Add Preprocessing

Alternative 2: 99.5% accurate, 1.4× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := \frac{\left|x\right|}{s}\\ \frac{1}{\left(e^{t\_0} + 1\right) \cdot \mathsf{fma}\left(s, e^{-t\_0}, s\right)} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (/ (fabs x) s)))
  (/ 1.0 (* (+ (exp t_0) 1.0) (fma s (exp (- t_0)) s)))))

C

float code(float x, float s) {
	float t_0 = fabsf(x) / s;
	return 1.0f / ((expf(t_0) + 1.0f) * fmaf(s, expf(-t_0), s));
}

Julia

function code(x, s)
	t_0 = Float32(abs(x) / s)
	return Float32(Float32(1.0) / Float32(Float32(exp(t_0) + Float32(1.0)) * fma(s, exp(Float32(-t_0)), s)))
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

3. Applied rewrites 99.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

5. Applied rewrites 99.5%

   \[\leadsto \frac{1}{\left(e^{\frac{\left|x\right|}{s}} + 1\right) \cdot \mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right)} \]
6. Add Preprocessing

Alternative 3: 95.1% accurate, 1.4× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := e^{\frac{-\left|x\right|}{s}}\\ \frac{t\_0}{\left(2 \cdot s\right) \cdot \left(1 + t\_0\right)} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (exp (/ (- (fabs x)) s))))
  (/ t_0 (* (* 2.0 s) (+ 1.0 t_0)))))

C

float code(float x, float s) {
	float t_0 = expf((-fabsf(x) / s));
	return t_0 / ((2.0f * s) * (1.0f + t_0));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    t_0 = exp((-abs(x) / s))
    code = t_0 / ((2.0e0 * s) * (1.0e0 + t_0))
end function

Julia

function code(x, s)
	t_0 = exp(Float32(Float32(-abs(x)) / s))
	return Float32(t_0 / Float32(Float32(Float32(2.0) * s) * Float32(Float32(1.0) + t_0)))
end

MATLAB

function tmp = code(x, s)
	t_0 = exp((-abs(x) / s));
	tmp = t_0 / ((single(2.0) * s) * (single(1.0) + t_0));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]
5. Add Preprocessing

Alternative 4: 95.1% accurate, 1.4× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{e^{\frac{-\left|x\right|}{s}}}{\mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right) \cdot 2} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/
 (exp (/ (- (fabs x)) s))
 (* (fma s (exp (- (/ (fabs x) s))) s) 2.0)))

C

float code(float x, float s) {
	return expf((-fabsf(x) / s)) / (fmaf(s, expf(-(fabsf(x) / s)), s) * 2.0f);
}

Julia

function code(x, s)
	return Float32(exp(Float32(Float32(-abs(x)) / s)) / Float32(fma(s, exp(Float32(-Float32(abs(x) / s))), s) * Float32(2.0)))
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

3. Applied rewrites 99.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right) \cdot 2} \]

6. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\mathsf{fma}\left(s, e^{-\frac{\left|x\right|}{s}}, s\right) \cdot 2} \]
7. Add Preprocessing

Alternative 5: 94.8% accurate, 1.6× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := \sqrt{\left|x\right|}\\ \frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - t\_0 \cdot \frac{t\_0}{s}\right)} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (sqrt (fabs x))))
  (/ (exp (/ (- (fabs x)) s)) (* (+ s s) (- 2.0 (* t_0 (/ t_0 s)))))))

C

float code(float x, float s) {
	float t_0 = sqrtf(fabsf(x));
	return expf((-fabsf(x) / s)) / ((s + s) * (2.0f - (t_0 * (t_0 / s))));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    t_0 = sqrt(abs(x))
    code = exp((-abs(x) / s)) / ((s + s) * (2.0e0 - (t_0 * (t_0 / s))))
end function

Julia

function code(x, s)
	t_0 = sqrt(abs(x))
	return Float32(exp(Float32(Float32(-abs(x)) / s)) / Float32(Float32(s + s) * Float32(Float32(2.0) - Float32(t_0 * Float32(t_0 / s)))))
end

MATLAB

function tmp = code(x, s)
	t_0 = sqrt(abs(x));
	tmp = exp((-abs(x) / s)) / ((s + s) * (single(2.0) - (t_0 * (t_0 / s))));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

5. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

7. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

9. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]

11. Applied rewrites 94.6%

    \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - \sqrt{\left|x\right|} \cdot \frac{\sqrt{\left|x\right|}}{s}\right)} \]
12. Add Preprocessing

Alternative 6: 94.8% accurate, 1.9× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ (exp (/ (- (fabs x)) s)) (* (+ s s) (- 2.0 (/ (fabs x) s)))))

C

float code(float x, float s) {
	return expf((-fabsf(x) / s)) / ((s + s) * (2.0f - (fabsf(x) / s)));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = exp((-abs(x) / s)) / ((s + s) * (2.0e0 - (abs(x) / s)))
end function

Julia

function code(x, s)
	return Float32(exp(Float32(Float32(-abs(x)) / s)) / Float32(Float32(s + s) * Float32(Float32(2.0) - Float32(abs(x) / s))))
end

MATLAB

function tmp = code(x, s)
	tmp = exp((-abs(x) / s)) / ((s + s) * (single(2.0) - (abs(x) / s)));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

5. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

7. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

9. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]
10. Add Preprocessing

Alternative 7: 94.8% accurate, 2.0× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\begin{array}{l} t_0 := \sqrt{\left|x\right|}\\ \frac{e^{\frac{-t\_0 \cdot t\_0}{s}}}{4 \cdot s} \end{array} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (let* ((t_0 (sqrt (fabs x))))
  (/ (exp (/ (- (* t_0 t_0)) s)) (* 4.0 s))))

C

float code(float x, float s) {
	float t_0 = sqrtf(fabsf(x));
	return expf((-(t_0 * t_0) / s)) / (4.0f * s);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    real(4) :: t_0
    t_0 = sqrt(abs(x))
    code = exp((-(t_0 * t_0) / s)) / (4.0e0 * s)
end function

Julia

function code(x, s)
	t_0 = sqrt(abs(x))
	return Float32(exp(Float32(Float32(-Float32(t_0 * t_0)) / s)) / Float32(Float32(4.0) * s))
end

MATLAB

function tmp = code(x, s)
	t_0 = sqrt(abs(x));
	tmp = exp((-(t_0 * t_0) / s)) / (single(4.0) * s);
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

4. Applied rewrites 94.8%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

6. Applied rewrites 94.8%

   \[\leadsto \frac{e^{\frac{-\sqrt{\left|x\right|} \cdot \sqrt{\left|x\right|}}{s}}}{4 \cdot s} \]
7. Add Preprocessing

Alternative 8: 94.6% accurate, 2.2× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{{0.3678794503211975}^{\left(\frac{\left|x\right|}{s}\right)}}{4 \cdot s} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ (pow 0.3678794503211975 (/ (fabs x) s)) (* 4.0 s)))

C

float code(float x, float s) {
	return powf(0.3678794503211975f, (fabsf(x) / s)) / (4.0f * s);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = (0.3678794503211975e0 ** (abs(x) / s)) / (4.0e0 * s)
end function

Julia

function code(x, s)
	return Float32((Float32(0.3678794503211975) ^ Float32(abs(x) / s)) / Float32(Float32(4.0) * s))
end

MATLAB

function tmp = code(x, s)
	tmp = (single(0.3678794503211975) ^ (abs(x) / s)) / (single(4.0) * s);
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

4. Applied rewrites 94.8%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

6. Applied rewrites 94.8%

   \[\leadsto \frac{{\left(e^{-1}\right)}^{\left(\frac{\left|x\right|}{s}\right)}}{4 \cdot s} \]

7. Evaluated real constant 94.8%

   \[\leadsto \frac{{0.3678794503211975}^{\left(\frac{\left|x\right|}{s}\right)}}{4 \cdot s} \]
8. Add Preprocessing

Alternative 9: 94.6% accurate, 2.7× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ (exp (/ (- (fabs x)) s)) (* 4.0 s)))

C

float code(float x, float s) {
	return expf((-fabsf(x) / s)) / (4.0f * s);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = exp((-abs(x) / s)) / (4.0e0 * s)
end function

Julia

function code(x, s)
	return Float32(exp(Float32(Float32(-abs(x)) / s)) / Float32(Float32(4.0) * s))
end

MATLAB

function tmp = code(x, s)
	tmp = exp((-abs(x) / s)) / (single(4.0) * s);
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]

4. Applied rewrites 94.8%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{4 \cdot s} \]
5. Add Preprocessing

Alternative 10: 50.7% accurate, 3.2× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{1}{\left(2 \cdot s\right) \cdot \frac{\left(s + s\right) - \left|x\right|}{s}} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ 1.0 (* (* 2.0 s) (/ (- (+ s s) (fabs x)) s))))

C

float code(float x, float s) {
	return 1.0f / ((2.0f * s) * (((s + s) - fabsf(x)) / s));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = 1.0e0 / ((2.0e0 * s) * (((s + s) - abs(x)) / s))
end function

Julia

function code(x, s)
	return Float32(Float32(1.0) / Float32(Float32(Float32(2.0) * s) * Float32(Float32(Float32(s + s) - abs(x)) / s)))
end

MATLAB

function tmp = code(x, s)
	tmp = single(1.0) / ((single(2.0) * s) * (((s + s) - abs(x)) / s));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

5. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

7. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

8. Taylor expanded in s around inf

   \[\leadsto \frac{1}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

10. Applied rewrites 50.7%

    \[\leadsto \frac{1}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

12. Applied rewrites 50.7%

    \[\leadsto \frac{1}{\left(2 \cdot s\right) \cdot \frac{\left(s + s\right) - \left|x\right|}{s}} \]
13. Add Preprocessing

Alternative 11: 50.7% accurate, 3.7× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{1}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ 1.0 (* (+ s s) (- 2.0 (/ (fabs x) s)))))

C

float code(float x, float s) {
	return 1.0f / ((s + s) * (2.0f - (fabsf(x) / s)));
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = 1.0e0 / ((s + s) * (2.0e0 - (abs(x) / s)))
end function

Julia

function code(x, s)
	return Float32(Float32(1.0) / Float32(Float32(s + s) * Float32(Float32(2.0) - Float32(abs(x) / s))))
end

MATLAB

function tmp = code(x, s)
	tmp = single(1.0) / ((s + s) * (single(2.0) - (abs(x) / s)));
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

4. Applied rewrites 95.1%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

5. Taylor expanded in s around inf

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

7. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(2 \cdot s\right) \cdot \left(2 + -1 \cdot \frac{\left|x\right|}{s}\right)} \]

9. Applied rewrites 94.6%

   \[\leadsto \frac{e^{\frac{-\left|x\right|}{s}}}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]

10. Taylor expanded in s around inf

    \[\leadsto \frac{1}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]

12. Applied rewrites 50.7%

    \[\leadsto \frac{1}{\left(s + s\right) \cdot \left(2 - \frac{\left|x\right|}{s}\right)} \]
13. Add Preprocessing

Alternative 12: 27.3% accurate, 8.5× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{0.125}{0.5 \cdot s} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ 0.125 (* 0.5 s)))

C

float code(float x, float s) {
	return 0.125f / (0.5f * s);
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = 0.125e0 / (0.5e0 * s)
end function

Julia

function code(x, s)
	return Float32(Float32(0.125) / Float32(Float32(0.5) * s))
end

MATLAB

function tmp = code(x, s)
	tmp = single(0.125) / (single(0.5) * s);
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{\frac{1}{4}}{s} \]

4. Applied rewrites 27.3%

   \[\leadsto \frac{0.25}{s} \]

6. Applied rewrites 27.3%

   \[\leadsto \frac{0.25}{2 \cdot \left(0.5 \cdot s\right)} \]

8. Applied rewrites 27.3%

   \[\leadsto \frac{0.125}{0.5 \cdot s} \]
9. Add Preprocessing

Alternative 13: 27.3% accurate, 13.8× speedup

\[0 \leq s \land s \leq 1.0651631\]

Math

\[\frac{0.25}{s} \]

FPCore

(FPCore (x s)
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ 0.25 s))

C

float code(float x, float s) {
	return 0.25f / s;
}

Fortran

real(4) function code(x, s)
use fmin_fmax_functions
    real(4), intent (in) :: x
    real(4), intent (in) :: s
    code = 0.25e0 / s
end function

Julia

function code(x, s)
	return Float32(Float32(0.25) / s)
end

MATLAB

function tmp = code(x, s)
	tmp = single(0.25) / s;
end

Derivation

1. Initial program 99.5%

   \[\frac{e^{\frac{-\left|x\right|}{s}}}{\left(s \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)\right) \cdot \left(1 + e^{\frac{-\left|x\right|}{s}}\right)} \]

2. Taylor expanded in s around inf

   \[\leadsto \frac{\frac{1}{4}}{s} \]

4. Applied rewrites 27.3%

   \[\leadsto \frac{0.25}{s} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026089 +o generate:egglog
(FPCore (x s)
  :name "Logistic distribution"
  :precision binary32
  :pre (and (<= 0.0 s) (<= s 1.0651631))
  (/ (exp (/ (- (fabs x)) s)) (* (* s (+ 1.0 (exp (/ (- (fabs x)) s)))) (+ 1.0 (exp (/ (- (fabs x)) s))))))