Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 20.4s

Alternatives: 20

Speedup: 1.0×

• Could not converge on a ground truth

  1. NdChar = 2.1723684192323003e+47
  2. Ec = 5.577049301942995e-102
  3. Vef = 1.5103902566313906e+110
  4. EDonor = 2.0193482885531936e+248
  5. mu = 4.470471738141577e-182
  6. KbT = 1.4674103887009946e+59
  7. NaChar = -9.731503300366666e+246
  8. Ev = 5.799106156722755e-75
  9. EAccept = 6.355181224999473e+253

Specification

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
  (/ NaChar (exp (log1p (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / exp(log1p(exp(((Vef + (Ev + (EAccept - mu))) / KbT)))));
}

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / Math.exp(Math.log1p(Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / math.exp(math.log1p(math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / exp(log1p(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))))
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[Exp[N[Log[1 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. add-exp-log 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   2. log1p-define 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

6. Applied egg-rr 100.0%

   \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

7. Final simplification 100.0%

   \[\leadsto \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}} \]
8. Add Preprocessing

Alternative 2: 78.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ \mathbf{if}\;Vef \leq -4.4 \cdot 10^{+47} \lor \neg \left(Vef \leq 5.8 \cdot 10^{+119}\right):\\ \;\;\;\;t\_0 + \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{e^{\frac{-mu}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))))
   (if (or (<= Vef -4.4e+47) (not (<= Vef 5.8e+119)))
     (+ t_0 (/ NaChar (+ (exp (/ Vef KbT)) 1.0)))
     (+ t_0 (/ NaChar (+ (exp (/ (- mu) KbT)) 1.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0);
	double tmp;
	if ((Vef <= -4.4e+47) || !(Vef <= 5.8e+119)) {
		tmp = t_0 + (NaChar / (exp((Vef / KbT)) + 1.0));
	} else {
		tmp = t_0 + (NaChar / (exp((-mu / KbT)) + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0)
    if ((vef <= (-4.4d+47)) .or. (.not. (vef <= 5.8d+119))) then
        tmp = t_0 + (nachar / (exp((vef / kbt)) + 1.0d0))
    else
        tmp = t_0 + (nachar / (exp((-mu / kbt)) + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0);
	double tmp;
	if ((Vef <= -4.4e+47) || !(Vef <= 5.8e+119)) {
		tmp = t_0 + (NaChar / (Math.exp((Vef / KbT)) + 1.0));
	} else {
		tmp = t_0 + (NaChar / (Math.exp((-mu / KbT)) + 1.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)
	tmp = 0
	if (Vef <= -4.4e+47) or not (Vef <= 5.8e+119):
		tmp = t_0 + (NaChar / (math.exp((Vef / KbT)) + 1.0))
	else:
		tmp = t_0 + (NaChar / (math.exp((-mu / KbT)) + 1.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0))
	tmp = 0.0
	if ((Vef <= -4.4e+47) || !(Vef <= 5.8e+119))
		tmp = Float64(t_0 + Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(exp(Float64(Float64(-mu) / KbT)) + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0);
	tmp = 0.0;
	if ((Vef <= -4.4e+47) || ~((Vef <= 5.8e+119)))
		tmp = t_0 + (NaChar / (exp((Vef / KbT)) + 1.0));
	else
		tmp = t_0 + (NaChar / (exp((-mu / KbT)) + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[Vef, -4.4e+47], N[Not[LessEqual[Vef, 5.8e+119]], $MachinePrecision]], N[(t$95$0 + N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if Vef < -4.3999999999999999e47 or 5.80000000000000014e119 < Vef

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 90.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]

   if -4.3999999999999999e47 < Vef < 5.80000000000000014e119

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 77.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{-1 \cdot \frac{mu}{KbT}}}} \]
   6. Step-by-step derivation

      1. associate-*r/ 77.7%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{-1 \cdot mu}{KbT}}}} \]

      2. mul-1-neg 77.7%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\color{blue}{-mu}}{KbT}}} \]

   7. Simplified 77.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{-mu}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 82.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -4.4 \cdot 10^{+47} \lor \neg \left(Vef \leq 5.8 \cdot 10^{+119}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{-mu}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
  (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0)) + (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Final simplification 100.0%

   \[\leadsto \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} \]
6. Add Preprocessing

Alternative 4: 72.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -8.2 \cdot 10^{+39}:\\ \;\;\;\;\frac{NaChar}{{e}^{\left(\frac{EAccept + \left(\left(Vef + Ev\right) - mu\right)}{KbT}\right)} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -8.2e+39)
   (/ NaChar (+ (pow E (/ (+ EAccept (- (+ Vef Ev) mu)) KbT)) 1.0))
   (+
    (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
    (/ NaChar (+ (exp (/ Vef KbT)) 1.0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -8.2e+39) {
		tmp = NaChar / (pow(((double) M_E), ((EAccept + ((Vef + Ev) - mu)) / KbT)) + 1.0);
	} else {
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((Vef / KbT)) + 1.0));
	}
	return tmp;
}

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -8.2e+39) {
		tmp = NaChar / (Math.pow(Math.E, ((EAccept + ((Vef + Ev) - mu)) / KbT)) + 1.0);
	} else {
		tmp = (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (Math.exp((Vef / KbT)) + 1.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -8.2e+39:
		tmp = NaChar / (math.pow(math.e, ((EAccept + ((Vef + Ev) - mu)) / KbT)) + 1.0)
	else:
		tmp = (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp((Vef / KbT)) + 1.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -8.2e+39)
		tmp = Float64(NaChar / Float64((exp(1) ^ Float64(Float64(EAccept + Float64(Float64(Vef + Ev) - mu)) / KbT)) + 1.0));
	else
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -8.2e+39)
		tmp = NaChar / ((2.71828182845904523536 ^ ((EAccept + ((Vef + Ev) - mu)) / KbT)) + 1.0);
	else
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((Vef / KbT)) + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -8.2e+39], N[(NaChar / N[(N[Power[E, N[(N[(EAccept + N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -8.20000000000000008e39

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 76.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]
   6. Step-by-step derivation

      1. *-un-lft-identity 76.1%

         \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{1 \cdot \frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

      2. exp-prod 76.1%

         \[\leadsto \frac{NaChar}{1 + \color{blue}{{\left(e^{1}\right)}^{\left(\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}\right)}}} \]

      3. associate--l+ 76.1%

         \[\leadsto \frac{NaChar}{1 + {\left(e^{1}\right)}^{\left(\frac{\color{blue}{EAccept + \left(\left(Ev + Vef\right) - mu\right)}}{KbT}\right)}} \]

      4. +-commutative 76.1%

         \[\leadsto \frac{NaChar}{1 + {\left(e^{1}\right)}^{\left(\frac{EAccept + \left(\color{blue}{\left(Vef + Ev\right)} - mu\right)}{KbT}\right)}} \]

   7. Applied egg-rr 76.1%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{{\left(e^{1}\right)}^{\left(\frac{EAccept + \left(\left(Vef + Ev\right) - mu\right)}{KbT}\right)}}} \]

   if -8.20000000000000008e39 < NaChar

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 79.9%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 78.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -8.2 \cdot 10^{+39}:\\ \;\;\;\;\frac{NaChar}{{e}^{\left(\frac{EAccept + \left(\left(Vef + Ev\right) - mu\right)}{KbT}\right)} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 70.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -6.2 \cdot 10^{+50} \lor \neg \left(NaChar \leq 6.4 \cdot 10^{-49}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -6.2e+50) (not (<= NaChar 6.4e-49)))
   (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))
   (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -6.2e+50) || !(NaChar <= 6.4e-49)) {
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	} else {
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-6.2d+50)) .or. (.not. (nachar <= 6.4d-49))) then
        tmp = nachar / (exp((((eaccept + (vef + ev)) - mu) / kbt)) + 1.0d0)
    else
        tmp = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -6.2e+50) || !(NaChar <= 6.4e-49)) {
		tmp = NaChar / (Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	} else {
		tmp = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -6.2e+50) or not (NaChar <= 6.4e-49):
		tmp = NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0)
	else:
		tmp = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -6.2e+50) || !(NaChar <= 6.4e-49))
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0));
	else
		tmp = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -6.2e+50) || ~((NaChar <= 6.4e-49)))
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	else
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -6.2e+50], N[Not[LessEqual[NaChar, 6.4e-49]], $MachinePrecision]], N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -6.20000000000000006e50 or 6.40000000000000005e-49 < NaChar

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 72.6%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -6.20000000000000006e50 < NaChar < 6.40000000000000005e-49

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around inf 76.2%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -6.2 \cdot 10^{+50} \lor \neg \left(NaChar \leq 6.4 \cdot 10^{-49}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 62.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.4 \cdot 10^{+71} \lor \neg \left(KbT \leq 1.55 \cdot 10^{+142}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.4e+71) (not (<= KbT 1.55e+142)))
   (+ (/ NdChar (+ (exp (/ EDonor KbT)) 1.0)) (/ NaChar 2.0))
   (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -3.4e+71) || !(KbT <= 1.55e+142)) {
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	} else {
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-3.4d+71)) .or. (.not. (kbt <= 1.55d+142))) then
        tmp = (ndchar / (exp((edonor / kbt)) + 1.0d0)) + (nachar / 2.0d0)
    else
        tmp = nachar / (exp((((eaccept + (vef + ev)) - mu) / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -3.4e+71) || !(KbT <= 1.55e+142)) {
		tmp = (NdChar / (Math.exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	} else {
		tmp = NaChar / (Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.4e+71) or not (KbT <= 1.55e+142):
		tmp = (NdChar / (math.exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0)
	else:
		tmp = NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -3.4e+71) || !(KbT <= 1.55e+142))
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0)) + Float64(NaChar / 2.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -3.4e+71) || ~((KbT <= 1.55e+142)))
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	else
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.4e+71], N[Not[LessEqual[KbT, 1.55e+142]], $MachinePrecision]], N[(N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.3999999999999998e71 or 1.55e142 < KbT

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing
   5. Step-by-step derivation

      1. add-exp-log 99.9%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

      2. log1p-define 99.9%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   6. Applied egg-rr 99.9%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   7. Taylor expanded in KbT around inf 80.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   8. Taylor expanded in EDonor around inf 68.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{\color{blue}{EDonor}}{KbT}}} + \frac{NaChar}{2} \]

   if -3.3999999999999998e71 < KbT < 1.55e142

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 67.8%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 67.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.4 \cdot 10^{+71} \lor \neg \left(KbT \leq 1.55 \cdot 10^{+142}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 39.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{if}\;KbT \leq -1.45 \cdot 10^{+48}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -8.4 \cdot 10^{-117}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 1.45 \cdot 10^{+110}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar 2.0)
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
            (/ Ec KbT))))))
   (if (<= KbT -1.45e+48)
     t_0
     (if (<= KbT -8.4e-117)
       (/
        NaChar
        (*
         mu
         (+
          (/ (+ (+ 2.0 (/ EAccept KbT)) (+ (/ Vef KbT) (/ Ev KbT))) mu)
          (/ -1.0 KbT))))
       (if (<= KbT 1.45e+110) (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -1.45e+48) {
		tmp = t_0;
	} else if (KbT <= -8.4e-117) {
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	} else if (KbT <= 1.45e+110) {
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / 2.0d0) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt)))
    if (kbt <= (-1.45d+48)) then
        tmp = t_0
    else if (kbt <= (-8.4d-117)) then
        tmp = nachar / (mu * ((((2.0d0 + (eaccept / kbt)) + ((vef / kbt) + (ev / kbt))) / mu) + ((-1.0d0) / kbt)))
    else if (kbt <= 1.45d+110) then
        tmp = nachar / (exp((eaccept / kbt)) + 1.0d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -1.45e+48) {
		tmp = t_0;
	} else if (KbT <= -8.4e-117) {
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	} else if (KbT <= 1.45e+110) {
		tmp = NaChar / (Math.exp((EAccept / KbT)) + 1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)))
	tmp = 0
	if KbT <= -1.45e+48:
		tmp = t_0
	elif KbT <= -8.4e-117:
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)))
	elif KbT <= 1.45e+110:
		tmp = NaChar / (math.exp((EAccept / KbT)) + 1.0)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))))
	tmp = 0.0
	if (KbT <= -1.45e+48)
		tmp = t_0;
	elseif (KbT <= -8.4e-117)
		tmp = Float64(NaChar / Float64(mu * Float64(Float64(Float64(Float64(2.0 + Float64(EAccept / KbT)) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT))) / mu) + Float64(-1.0 / KbT))));
	elseif (KbT <= 1.45e+110)
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	tmp = 0.0;
	if (KbT <= -1.45e+48)
		tmp = t_0;
	elseif (KbT <= -8.4e-117)
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	elseif (KbT <= 1.45e+110)
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.45e+48], t$95$0, If[LessEqual[KbT, -8.4e-117], N[(NaChar / N[(mu * N[(N[(N[(N[(2.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.45e+110], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.4499999999999999e48 or 1.45e110 < KbT

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing
   5. Step-by-step derivation

      1. add-exp-log 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

      2. log1p-define 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   6. Applied egg-rr 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   7. Taylor expanded in KbT around inf 73.3%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   8. Taylor expanded in KbT around inf 50.4%

      \[\leadsto \frac{NdChar}{\color{blue}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}} + \frac{NaChar}{2} \]

   if -1.4499999999999999e48 < KbT < -8.3999999999999996e-117

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 77.0%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 27.4%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in mu around -inf 41.7%

      \[\leadsto \frac{NaChar}{\color{blue}{-1 \cdot \left(mu \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)\right)}} \]
   8. Step-by-step derivation

      1. associate-*r* 41.7%

         \[\leadsto \frac{NaChar}{\color{blue}{\left(-1 \cdot mu\right) \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)}} \]

      2. mul-1-neg 41.7%

         \[\leadsto \frac{NaChar}{\color{blue}{\left(-mu\right)} \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)} \]

      3. +-commutative 41.7%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \color{blue}{\left(\frac{1}{KbT} + -1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}} \]

      4. mul-1-neg 41.7%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} + \color{blue}{\left(-\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}\right)} \]

      5. unsub-neg 41.7%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \color{blue}{\left(\frac{1}{KbT} - \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}} \]

      6. associate-+r+ 41.7%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\color{blue}{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}}{mu}\right)} \]

      7. +-commutative 41.7%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\left(2 + \frac{EAccept}{KbT}\right) + \color{blue}{\left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}}{mu}\right)} \]

   9. Simplified 41.7%

      \[\leadsto \frac{NaChar}{\color{blue}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu}\right)}} \]

   if -8.3999999999999996e-117 < KbT < 1.45e110

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 65.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in EAccept around inf 35.7%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 41.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.45 \cdot 10^{+48}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq -8.4 \cdot 10^{-117}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 1.45 \cdot 10^{+110}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 44.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.6 \cdot 10^{+36} \lor \neg \left(KbT \leq 9.5 \cdot 10^{+136}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -9.6e+36) (not (<= KbT 9.5e+136)))
   (+ (/ NdChar (+ (exp (/ EDonor KbT)) 1.0)) (/ NaChar 2.0))
   (/ NaChar (+ (exp (/ Vef KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.6e+36) || !(KbT <= 9.5e+136)) {
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	} else {
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-9.6d+36)) .or. (.not. (kbt <= 9.5d+136))) then
        tmp = (ndchar / (exp((edonor / kbt)) + 1.0d0)) + (nachar / 2.0d0)
    else
        tmp = nachar / (exp((vef / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.6e+36) || !(KbT <= 9.5e+136)) {
		tmp = (NdChar / (Math.exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	} else {
		tmp = NaChar / (Math.exp((Vef / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -9.6e+36) or not (KbT <= 9.5e+136):
		tmp = (NdChar / (math.exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0)
	else:
		tmp = NaChar / (math.exp((Vef / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -9.6e+36) || !(KbT <= 9.5e+136))
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0)) + Float64(NaChar / 2.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -9.6e+36) || ~((KbT <= 9.5e+136)))
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / 2.0);
	else
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -9.6e+36], N[Not[LessEqual[KbT, 9.5e+136]], $MachinePrecision]], N[(N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -9.5999999999999997e36 or 9.49999999999999907e136 < KbT

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing
   5. Step-by-step derivation

      1. add-exp-log 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

      2. log1p-define 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   6. Applied egg-rr 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   7. Taylor expanded in KbT around inf 76.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   8. Taylor expanded in EDonor around inf 62.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{\color{blue}{EDonor}}{KbT}}} + \frac{NaChar}{2} \]

   if -9.5999999999999997e36 < KbT < 9.49999999999999907e136

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.6%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Vef around inf 47.2%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 52.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.6 \cdot 10^{+36} \lor \neg \left(KbT \leq 9.5 \cdot 10^{+136}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 45.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -1.3 \cdot 10^{+19} \lor \neg \left(Vef \leq 2.8 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -1.3e+19) (not (<= Vef 2.8e+46)))
   (/ NaChar (+ (exp (/ Vef KbT)) 1.0))
   (+ (/ NdChar 2.0) (/ NaChar (+ (exp (/ Ev KbT)) 1.0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -1.3e+19) || !(Vef <= 2.8e+46)) {
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (exp((Ev / KbT)) + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((vef <= (-1.3d+19)) .or. (.not. (vef <= 2.8d+46))) then
        tmp = nachar / (exp((vef / kbt)) + 1.0d0)
    else
        tmp = (ndchar / 2.0d0) + (nachar / (exp((ev / kbt)) + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -1.3e+19) || !(Vef <= 2.8e+46)) {
		tmp = NaChar / (Math.exp((Vef / KbT)) + 1.0);
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (Math.exp((Ev / KbT)) + 1.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (Vef <= -1.3e+19) or not (Vef <= 2.8e+46):
		tmp = NaChar / (math.exp((Vef / KbT)) + 1.0)
	else:
		tmp = (NdChar / 2.0) + (NaChar / (math.exp((Ev / KbT)) + 1.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((Vef <= -1.3e+19) || !(Vef <= 2.8e+46))
		tmp = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0));
	else
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((Vef <= -1.3e+19) || ~((Vef <= 2.8e+46)))
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	else
		tmp = (NdChar / 2.0) + (NaChar / (exp((Ev / KbT)) + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -1.3e+19], N[Not[LessEqual[Vef, 2.8e+46]], $MachinePrecision]], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -1.3e19 or 2.80000000000000018e46 < Vef

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 64.7%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Vef around inf 58.1%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]

   if -1.3e19 < Vef < 2.80000000000000018e46

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 54.7%

      \[\leadsto \frac{NdChar}{\color{blue}{2}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in Ev around inf 42.4%

      \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 50.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1.3 \cdot 10^{+19} \lor \neg \left(Vef \leq 2.8 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 40.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -2800000000:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -2800000000.0)
   (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
   (/ NaChar (+ (exp (/ Vef KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -2800000000.0) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else {
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ev <= (-2800000000.0d0)) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else
        tmp = nachar / (exp((vef / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -2800000000.0) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else {
		tmp = NaChar / (Math.exp((Vef / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -2800000000.0:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	else:
		tmp = NaChar / (math.exp((Vef / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -2800000000.0)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -2800000000.0)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	else
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -2800000000.0], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Ev < -2.8e9

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 64.8%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Ev around inf 52.6%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   if -2.8e9 < Ev

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 59.5%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Vef around inf 43.5%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 45.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -2800000000:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 38.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -1.45:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -1.45)
   (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
   (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -1.45) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else {
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ev <= (-1.45d0)) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else
        tmp = nachar / (exp((eaccept / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -1.45) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else {
		tmp = NaChar / (Math.exp((EAccept / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -1.45:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	else:
		tmp = NaChar / (math.exp((EAccept / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -1.45)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -1.45)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	else
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -1.45], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Ev < -1.44999999999999996

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 66.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Ev around inf 54.4%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   if -1.44999999999999996 < Ev

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 59.2%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in EAccept around inf 32.9%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 37.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -1.45:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 31.9% accurate, 6.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -6.6 \cdot 10^{+49}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-43}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -6.6e+49)
   (+
    (/ NaChar 2.0)
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) (/ Ec KbT))))
   (if (<= KbT 1.9e-43)
     (/
      NaChar
      (*
       mu
       (+
        (/ (+ (+ 2.0 (/ EAccept KbT)) (+ (/ Vef KbT) (/ Ev KbT))) mu)
        (/ -1.0 KbT))))
     (* 0.5 (+ NdChar NaChar)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -6.6e+49) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	} else if (KbT <= 1.9e-43) {
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-6.6d+49)) then
        tmp = (nachar / 2.0d0) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt)))
    else if (kbt <= 1.9d-43) then
        tmp = nachar / (mu * ((((2.0d0 + (eaccept / kbt)) + ((vef / kbt) + (ev / kbt))) / mu) + ((-1.0d0) / kbt)))
    else
        tmp = 0.5d0 * (ndchar + nachar)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -6.6e+49) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	} else if (KbT <= 1.9e-43) {
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -6.6e+49:
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)))
	elif KbT <= 1.9e-43:
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)))
	else:
		tmp = 0.5 * (NdChar + NaChar)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -6.6e+49)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))));
	elseif (KbT <= 1.9e-43)
		tmp = Float64(NaChar / Float64(mu * Float64(Float64(Float64(Float64(2.0 + Float64(EAccept / KbT)) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT))) / mu) + Float64(-1.0 / KbT))));
	else
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -6.6e+49)
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	elseif (KbT <= 1.9e-43)
		tmp = NaChar / (mu * ((((2.0 + (EAccept / KbT)) + ((Vef / KbT) + (Ev / KbT))) / mu) + (-1.0 / KbT)));
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -6.6e+49], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.9e-43], N[(NaChar / N[(mu * N[(N[(N[(N[(2.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -6.5999999999999997e49

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing
   5. Step-by-step derivation

      1. add-exp-log 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

      2. log1p-define 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   6. Applied egg-rr 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   7. Taylor expanded in KbT around inf 73.1%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   8. Taylor expanded in KbT around inf 45.9%

      \[\leadsto \frac{NdChar}{\color{blue}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}} + \frac{NaChar}{2} \]

   if -6.5999999999999997e49 < KbT < 1.89999999999999985e-43

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.3%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 19.9%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in mu around -inf 28.0%

      \[\leadsto \frac{NaChar}{\color{blue}{-1 \cdot \left(mu \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)\right)}} \]
   8. Step-by-step derivation

      1. associate-*r* 28.0%

         \[\leadsto \frac{NaChar}{\color{blue}{\left(-1 \cdot mu\right) \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)}} \]

      2. mul-1-neg 28.0%

         \[\leadsto \frac{NaChar}{\color{blue}{\left(-mu\right)} \cdot \left(-1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu} + \frac{1}{KbT}\right)} \]

      3. +-commutative 28.0%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \color{blue}{\left(\frac{1}{KbT} + -1 \cdot \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}} \]

      4. mul-1-neg 28.0%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} + \color{blue}{\left(-\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}\right)} \]

      5. unsub-neg 28.0%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \color{blue}{\left(\frac{1}{KbT} - \frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)}{mu}\right)}} \]

      6. associate-+r+ 28.0%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\color{blue}{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}}{mu}\right)} \]

      7. +-commutative 28.0%

         \[\leadsto \frac{NaChar}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\left(2 + \frac{EAccept}{KbT}\right) + \color{blue}{\left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}}{mu}\right)} \]

   9. Simplified 28.0%

      \[\leadsto \frac{NaChar}{\color{blue}{\left(-mu\right) \cdot \left(\frac{1}{KbT} - \frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu}\right)}} \]

   if 1.89999999999999985e-43 < KbT

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 39.8%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 39.8%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 39.8%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 34.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -6.6 \cdot 10^{+49}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-43}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{\left(2 + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 32.3% accurate, 8.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -950:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 2.3 \cdot 10^{-42}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -950.0)
   (+
    (/ NaChar 2.0)
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) (/ Ec KbT))))
   (if (<= KbT 2.3e-42)
     (/ NaChar (+ 2.0 (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))
     (* 0.5 (+ NdChar NaChar)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -950.0) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	} else if (KbT <= 2.3e-42) {
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-950.0d0)) then
        tmp = (nachar / 2.0d0) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt)))
    else if (kbt <= 2.3d-42) then
        tmp = nachar / (2.0d0 + (((eaccept + (vef + ev)) - mu) / kbt))
    else
        tmp = 0.5d0 * (ndchar + nachar)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -950.0) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	} else if (KbT <= 2.3e-42) {
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -950.0:
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)))
	elif KbT <= 2.3e-42:
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT))
	else:
		tmp = 0.5 * (NdChar + NaChar)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -950.0)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))));
	elseif (KbT <= 2.3e-42)
		tmp = Float64(NaChar / Float64(2.0 + Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)));
	else
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -950.0)
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	elseif (KbT <= 2.3e-42)
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -950.0], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.3e-42], N[(NaChar / N[(2.0 + N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -950

   1. Initial program 99.9%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing
   5. Step-by-step derivation

      1. add-exp-log 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\log \left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

      2. log1p-define 100.0%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{e^{\color{blue}{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   6. Applied egg-rr 100.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{e^{\mathsf{log1p}\left(e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}}} \]

   7. Taylor expanded in KbT around inf 68.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   8. Taylor expanded in KbT around inf 40.9%

      \[\leadsto \frac{NdChar}{\color{blue}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}} + \frac{NaChar}{2} \]

   if -950 < KbT < 2.30000000000000004e-42

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 20.8%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in KbT around -inf 28.1%

      \[\leadsto \frac{NaChar}{\color{blue}{2 + -1 \cdot \frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}}} \]
   8. Step-by-step derivation

      1. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 + \color{blue}{\left(-\frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}\right)}} \]

      2. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{\color{blue}{2 - \frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}}} \]

      3. sub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) + \left(--1 \cdot mu\right)}}{KbT}} \]

      4. +-commutative 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) + -1 \cdot EAccept\right)} + \left(--1 \cdot mu\right)}{KbT}} \]

      5. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) + \color{blue}{\left(-EAccept\right)}\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      6. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) - EAccept\right)} + \left(--1 \cdot mu\right)}{KbT}} \]

      7. +-commutative 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\color{blue}{\left(-1 \cdot Vef + -1 \cdot Ev\right)} - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      8. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(-1 \cdot Vef + \color{blue}{\left(-Ev\right)}\right) - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      9. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\color{blue}{\left(-1 \cdot Vef - Ev\right)} - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      10. mul-1-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\color{blue}{\left(-Vef\right)} - Ev\right) - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      11. mul-1-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + \left(-\color{blue}{\left(-mu\right)}\right)}{KbT}} \]

      12. remove-double-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + \color{blue}{mu}}{KbT}} \]

   9. Simplified 28.1%

      \[\leadsto \frac{NaChar}{\color{blue}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + mu}{KbT}}} \]

   if 2.30000000000000004e-42 < KbT

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 39.8%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 39.8%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 39.8%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 34.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -950:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 2.3 \cdot 10^{-42}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 32.6% accurate, 9.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -12500000 \lor \neg \left(KbT \leq 5 \cdot 10^{-41}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -12500000.0) (not (<= KbT 5e-41)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ 2.0 (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -12500000.0) || !(KbT <= 5e-41)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-12500000.0d0)) .or. (.not. (kbt <= 5d-41))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / (2.0d0 + (((eaccept + (vef + ev)) - mu) / kbt))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -12500000.0) || !(KbT <= 5e-41)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -12500000.0) or not (KbT <= 5e-41):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -12500000.0) || !(KbT <= 5e-41))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(2.0 + Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -12500000.0) || ~((KbT <= 5e-41)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -12500000.0], N[Not[LessEqual[KbT, 5e-41]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(2.0 + N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.25e7 or 4.9999999999999996e-41 < KbT

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 39.6%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 39.6%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 39.6%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   if -1.25e7 < KbT < 4.9999999999999996e-41

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 20.8%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in KbT around -inf 28.1%

      \[\leadsto \frac{NaChar}{\color{blue}{2 + -1 \cdot \frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}}} \]
   8. Step-by-step derivation

      1. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 + \color{blue}{\left(-\frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}\right)}} \]

      2. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{\color{blue}{2 - \frac{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) - -1 \cdot mu}{KbT}}} \]

      3. sub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(-1 \cdot EAccept + \left(-1 \cdot Ev + -1 \cdot Vef\right)\right) + \left(--1 \cdot mu\right)}}{KbT}} \]

      4. +-commutative 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) + -1 \cdot EAccept\right)} + \left(--1 \cdot mu\right)}{KbT}} \]

      5. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) + \color{blue}{\left(-EAccept\right)}\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      6. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\color{blue}{\left(\left(-1 \cdot Ev + -1 \cdot Vef\right) - EAccept\right)} + \left(--1 \cdot mu\right)}{KbT}} \]

      7. +-commutative 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\color{blue}{\left(-1 \cdot Vef + -1 \cdot Ev\right)} - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      8. mul-1-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(-1 \cdot Vef + \color{blue}{\left(-Ev\right)}\right) - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      9. unsub-neg 28.1%

         \[\leadsto \frac{NaChar}{2 - \frac{\left(\color{blue}{\left(-1 \cdot Vef - Ev\right)} - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      10. mul-1-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\color{blue}{\left(-Vef\right)} - Ev\right) - EAccept\right) + \left(--1 \cdot mu\right)}{KbT}} \]

      11. mul-1-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + \left(-\color{blue}{\left(-mu\right)}\right)}{KbT}} \]

      12. remove-double-neg 28.1%

          \[\leadsto \frac{NaChar}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + \color{blue}{mu}}{KbT}} \]

   9. Simplified 28.1%

      \[\leadsto \frac{NaChar}{\color{blue}{2 - \frac{\left(\left(\left(-Vef\right) - Ev\right) - EAccept\right) + mu}{KbT}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 34.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -12500000 \lor \neg \left(KbT \leq 5 \cdot 10^{-41}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 30.2% accurate, 13.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -580000000 \lor \neg \left(KbT \leq 1.2 \cdot 10^{-42}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -580000000.0) (not (<= KbT 1.2e-42)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ (/ Vef KbT) 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -580000000.0) || !(KbT <= 1.2e-42)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / ((Vef / KbT) + 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-580000000.0d0)) .or. (.not. (kbt <= 1.2d-42))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / ((vef / kbt) + 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -580000000.0) || !(KbT <= 1.2e-42)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / ((Vef / KbT) + 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -580000000.0) or not (KbT <= 1.2e-42):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / ((Vef / KbT) + 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -580000000.0) || !(KbT <= 1.2e-42))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -580000000.0) || ~((KbT <= 1.2e-42)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / ((Vef / KbT) + 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -580000000.0], N[Not[LessEqual[KbT, 1.2e-42]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -5.8e8 or 1.20000000000000001e-42 < KbT

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 39.6%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 39.6%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 39.6%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   if -5.8e8 < KbT < 1.20000000000000001e-42

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in Vef around inf 47.9%

      \[\leadsto \frac{NaChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} \]

   7. Taylor expanded in Vef around 0 26.3%

      \[\leadsto \frac{NaChar}{\color{blue}{2 + \frac{Vef}{KbT}}} \]
   8. Step-by-step derivation

      1. +-commutative 26.3%

         \[\leadsto \frac{NaChar}{\color{blue}{\frac{Vef}{KbT} + 2}} \]

   9. Simplified 26.3%

      \[\leadsto \frac{NaChar}{\color{blue}{\frac{Vef}{KbT} + 2}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 33.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -580000000 \lor \neg \left(KbT \leq 1.2 \cdot 10^{-42}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 29.2% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -320 \lor \neg \left(KbT \leq 3.6 \cdot 10^{-42}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -320.0) (not (<= KbT 3.6e-42)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (/ Vef KbT))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -320.0) || !(KbT <= 3.6e-42)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (Vef / KbT);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-320.0d0)) .or. (.not. (kbt <= 3.6d-42))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / (vef / kbt)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -320.0) || !(KbT <= 3.6e-42)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (Vef / KbT);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -320.0) or not (KbT <= 3.6e-42):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (Vef / KbT)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -320.0) || !(KbT <= 3.6e-42))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Vef / KbT));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -320.0) || ~((KbT <= 3.6e-42)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (Vef / KbT);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -320.0], N[Not[LessEqual[KbT, 3.6e-42]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -320 or 3.6000000000000002e-42 < KbT

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 39.6%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 39.6%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 39.6%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   if -320 < KbT < 3.6000000000000002e-42

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 20.8%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in Vef around inf 24.3%

      \[\leadsto \frac{NaChar}{\color{blue}{\frac{Vef}{KbT}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 32.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -320 \lor \neg \left(KbT \leq 3.6 \cdot 10^{-42}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 23.0% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -4.2 \cdot 10^{-45} \lor \neg \left(NaChar \leq 1.65 \cdot 10^{-48}\right):\\ \;\;\;\;NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -4.2e-45) (not (<= NaChar 1.65e-48)))
   (* NaChar 0.5)
   (* NdChar 0.5)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -4.2e-45) || !(NaChar <= 1.65e-48)) {
		tmp = NaChar * 0.5;
	} else {
		tmp = NdChar * 0.5;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-4.2d-45)) .or. (.not. (nachar <= 1.65d-48))) then
        tmp = nachar * 0.5d0
    else
        tmp = ndchar * 0.5d0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -4.2e-45) || !(NaChar <= 1.65e-48)) {
		tmp = NaChar * 0.5;
	} else {
		tmp = NdChar * 0.5;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -4.2e-45) or not (NaChar <= 1.65e-48):
		tmp = NaChar * 0.5
	else:
		tmp = NdChar * 0.5
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -4.2e-45) || !(NaChar <= 1.65e-48))
		tmp = Float64(NaChar * 0.5);
	else
		tmp = Float64(NdChar * 0.5);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -4.2e-45) || ~((NaChar <= 1.65e-48)))
		tmp = NaChar * 0.5;
	else
		tmp = NdChar * 0.5;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -4.2e-45], N[Not[LessEqual[NaChar, 1.65e-48]], $MachinePrecision]], N[(NaChar * 0.5), $MachinePrecision], N[(NdChar * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -4.1999999999999999e-45 or 1.65e-48 < NaChar

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 20.8%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 20.8%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 20.8%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   8. Taylor expanded in NaChar around inf 19.2%

      \[\leadsto 0.5 \cdot \color{blue}{NaChar} \]

   if -4.1999999999999999e-45 < NaChar < 1.65e-48

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 30.7%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 30.7%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 30.7%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   8. Taylor expanded in NaChar around 0 28.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} \]
   9. Step-by-step derivation

      1. *-commutative 28.0%

         \[\leadsto \color{blue}{NdChar \cdot 0.5} \]

   10. Simplified 28.0%

       \[\leadsto \color{blue}{NdChar \cdot 0.5} \]
3. Recombined 2 regimes into one program.

4. Final simplification 22.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -4.2 \cdot 10^{-45} \lor \neg \left(NaChar \leq 1.65 \cdot 10^{-48}\right):\\ \;\;\;\;NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 27.7% accurate, 22.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -1.6 \cdot 10^{+149}:\\ \;\;\;\;KbT \cdot \frac{NaChar}{Vef}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Vef -1.6e+149) (* KbT (/ NaChar Vef)) (* 0.5 (+ NdChar NaChar))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -1.6e+149) {
		tmp = KbT * (NaChar / Vef);
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (vef <= (-1.6d+149)) then
        tmp = kbt * (nachar / vef)
    else
        tmp = 0.5d0 * (ndchar + nachar)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -1.6e+149) {
		tmp = KbT * (NaChar / Vef);
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Vef <= -1.6e+149:
		tmp = KbT * (NaChar / Vef)
	else:
		tmp = 0.5 * (NdChar + NaChar)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Vef <= -1.6e+149)
		tmp = Float64(KbT * Float64(NaChar / Vef));
	else
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Vef <= -1.6e+149)
		tmp = KbT * (NaChar / Vef);
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Vef, -1.6e+149], N[(KbT * N[(NaChar / Vef), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -1.6000000000000001e149

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 83.5%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   6. Taylor expanded in KbT around inf 40.7%

      \[\leadsto \frac{NaChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}} \]

   7. Taylor expanded in Vef around inf 38.0%

      \[\leadsto \color{blue}{\frac{KbT \cdot NaChar}{Vef}} \]
   8. Step-by-step derivation

      1. associate-/l* 39.3%

         \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{Vef}} \]

   9. Simplified 39.3%

      \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{Vef}} \]

   if -1.6000000000000001e149 < Vef

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 27.1%

      \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
   6. Step-by-step derivation

      1. distribute-lft-out 27.1%

         \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

   7. Simplified 27.1%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 28.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1.6 \cdot 10^{+149}:\\ \;\;\;\;KbT \cdot \frac{NaChar}{Vef}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 27.7% accurate, 45.8× speedup

Math

\[\begin{array}{l} \\ 0.5 \cdot \left(NdChar + NaChar\right) \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (* 0.5 (+ NdChar NaChar)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return 0.5 * (NdChar + NaChar);
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = 0.5d0 * (ndchar + nachar)
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return 0.5 * (NdChar + NaChar);
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return 0.5 * (NdChar + NaChar)

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(0.5 * Float64(NdChar + NaChar))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.5 * (NdChar + NaChar);
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in KbT around inf 24.9%

   \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
6. Step-by-step derivation

   1. distribute-lft-out 24.9%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

7. Simplified 24.9%

   \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

8. Final simplification 24.9%

   \[\leadsto 0.5 \cdot \left(NdChar + NaChar\right) \]
9. Add Preprocessing

Alternative 20: 18.0% accurate, 76.3× speedup

Math

\[\begin{array}{l} \\ NaChar \cdot 0.5 \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (* NaChar 0.5))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return NaChar * 0.5;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = nachar * 0.5d0
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return NaChar * 0.5;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return NaChar * 0.5

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(NaChar * 0.5)
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = NaChar * 0.5;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NaChar * 0.5), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in KbT around inf 24.9%

   \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
6. Step-by-step derivation

   1. distribute-lft-out 24.9%

      \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

7. Simplified 24.9%

   \[\leadsto \color{blue}{0.5 \cdot \left(NaChar + NdChar\right)} \]

8. Taylor expanded in NaChar around inf 16.9%

   \[\leadsto 0.5 \cdot \color{blue}{NaChar} \]

9. Final simplification 16.9%

   \[\leadsto NaChar \cdot 0.5 \]
10. Add Preprocessing

Reproduce

herbie shell --seed 2024177 
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
  :name "Bulmash initializePoisson"
  :precision binary64
  (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))