Logistic distribution

Average Error: 0.1 → 0.1

Time: 6.6s

Precision: binary64

Cost: 39232

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

Math

\[\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)} \]

↓

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

FPCore

(FPCore (x s)
 :precision binary64
 (/
  (exp (/ (- (fabs x)) s))
  (* (* s (+ 1.0 (exp (/ (- (fabs x)) s)))) (+ 1.0 (exp (/ (- (fabs x)) s))))))

↓

(FPCore (x s)
 :precision binary64
 (let* ((t_0 (exp (/ (fabs x) (- s)))))
   (/ t_0 (* s (exp (* (log1p t_0) 2.0))))))

C

double code(double x, double s) {
	return exp((-fabs(x) / s)) / ((s * (1.0 + exp((-fabs(x) / s)))) * (1.0 + exp((-fabs(x) / s))));
}

↓

double code(double x, double s) {
	double t_0 = exp((fabs(x) / -s));
	return t_0 / (s * exp((log1p(t_0) * 2.0)));
}

Java

public static double code(double x, double s) {
	return Math.exp((-Math.abs(x) / s)) / ((s * (1.0 + Math.exp((-Math.abs(x) / s)))) * (1.0 + Math.exp((-Math.abs(x) / s))));
}

↓

public static double code(double x, double s) {
	double t_0 = Math.exp((Math.abs(x) / -s));
	return t_0 / (s * Math.exp((Math.log1p(t_0) * 2.0)));
}

Python

def code(x, s):
	return math.exp((-math.fabs(x) / s)) / ((s * (1.0 + math.exp((-math.fabs(x) / s)))) * (1.0 + math.exp((-math.fabs(x) / s))))

↓

def code(x, s):
	t_0 = math.exp((math.fabs(x) / -s))
	return t_0 / (s * math.exp((math.log1p(t_0) * 2.0)))

Julia

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

↓

function code(x, s)
	t_0 = exp(Float64(abs(x) / Float64(-s)))
	return Float64(t_0 / Float64(s * exp(Float64(log1p(t_0) * 2.0))))
end

Wolfram

code[x_, s_] := N[(N[Exp[N[((-N[Abs[x], $MachinePrecision]) / s), $MachinePrecision]], $MachinePrecision] / N[(N[(s * N[(1.0 + N[Exp[N[((-N[Abs[x], $MachinePrecision]) / s), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[Exp[N[((-N[Abs[x], $MachinePrecision]) / s), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

↓

code[x_, s_] := Block[{t$95$0 = N[Exp[N[(N[Abs[x], $MachinePrecision] / (-s)), $MachinePrecision]], $MachinePrecision]}, N[(t$95$0 / N[(s * N[Exp[N[(N[Log[1 + t$95$0], $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 0.1

   \[\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. Simplified 0.1

   \[\leadsto \color{blue}{\frac{e^{\frac{\left|x\right|}{-s}}}{s \cdot e^{\mathsf{log1p}\left(e^{\frac{\left|x\right|}{-s}}\right) \cdot 2}}} \]
   Proof

Alternatives

Alternative 1
Error	0.1
Cost	32768

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

Alternative 2
Error	7.6
Cost	13448

\[\begin{array}{l} t_0 := \frac{e^{-\frac{\left|x\right|}{s}}}{s}\\ \mathbf{if}\;x \leq -3.4 \cdot 10^{-179}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 10^{-189}:\\ \;\;\;\;\frac{0.25}{s}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \]

Alternative 3
Error	0.9
Cost	13312

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

Alternative 4
Error	47.1
Cost	192

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

Reproduce

herbie shell --seed 2023010 
(FPCore (x s)
  :name "Logistic distribution"
  :precision binary64
  :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))))))