System.Random.MWC.Distributions:truncatedExp from mwc-random-0.13.3.2

Percentage Accurate: 61.5% → 98.2%

Time: 16.6s

Alternatives: 9

Speedup: 211.0×

• could not determine a ground truth

  1. x = -1.0180061258727939e-223
  2. y = 2.2442461358112313e-241
  3. z = 28844328057272.16
  4. t = 4.339309628878664e-74

Specification

Math

\[\begin{array}{l} \\ x - \frac{\log \left(\left(1 - y\right) + y \cdot e^{z}\right)}{t} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (- x (/ (log (+ (- 1.0 y) (* y (exp z)))) t)))

C

double code(double x, double y, double z, double t) {
	return x - (log(((1.0 - y) + (y * exp(z)))) / t);
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x - (log(((1.0d0 - y) + (y * exp(z)))) / t)
end function

Java

public static double code(double x, double y, double z, double t) {
	return x - (Math.log(((1.0 - y) + (y * Math.exp(z)))) / t);
}

Python

def code(x, y, z, t):
	return x - (math.log(((1.0 - y) + (y * math.exp(z)))) / t)

Julia

function code(x, y, z, t)
	return Float64(x - Float64(log(Float64(Float64(1.0 - y) + Float64(y * exp(z)))) / t))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = x - (log(((1.0 - y) + (y * exp(z)))) / t);
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(N[Log[N[(N[(1.0 - y), $MachinePrecision] + N[(y * N[Exp[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]

Initial Program: 61.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x - \frac{\log \left(\left(1 - y\right) + y \cdot e^{z}\right)}{t} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (- x (/ (log (+ (- 1.0 y) (* y (exp z)))) t)))

C

double code(double x, double y, double z, double t) {
	return x - (log(((1.0 - y) + (y * exp(z)))) / t);
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x - (log(((1.0d0 - y) + (y * exp(z)))) / t)
end function

Java

public static double code(double x, double y, double z, double t) {
	return x - (Math.log(((1.0 - y) + (y * Math.exp(z)))) / t);
}

Python

def code(x, y, z, t):
	return x - (math.log(((1.0 - y) + (y * math.exp(z)))) / t)

Julia

function code(x, y, z, t)
	return Float64(x - Float64(log(Float64(Float64(1.0 - y) + Float64(y * exp(z)))) / t))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = x - (log(((1.0 - y) + (y * exp(z)))) / t);
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(N[Log[N[(N[(1.0 - y), $MachinePrecision] + N[(y * N[Exp[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]

Alternative 1: 98.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x - \frac{\mathsf{log1p}\left(y \cdot \mathsf{expm1}\left(z\right)\right)}{t} \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (- x (/ (log1p (* y (expm1 z))) t)))

C

double code(double x, double y, double z, double t) {
	return x - (log1p((y * expm1(z))) / t);
}

Java

public static double code(double x, double y, double z, double t) {
	return x - (Math.log1p((y * Math.expm1(z))) / t);
}

Python

def code(x, y, z, t):
	return x - (math.log1p((y * math.expm1(z))) / t)

Julia

function code(x, y, z, t)
	return Float64(x - Float64(log1p(Float64(y * expm1(z))) / t))
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(N[Log[1 + N[(y * N[(Exp[z] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 89.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ x - \frac{\frac{1}{t}}{0.5 + \frac{1}{y \cdot \mathsf{expm1}\left(z\right)}} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (- x (/ (/ 1.0 t) (+ 0.5 (/ 1.0 (* y (expm1 z)))))))

C

double code(double x, double y, double z, double t) {
	return x - ((1.0 / t) / (0.5 + (1.0 / (y * expm1(z)))));
}

Java

public static double code(double x, double y, double z, double t) {
	return x - ((1.0 / t) / (0.5 + (1.0 / (y * Math.expm1(z)))));
}

Python

def code(x, y, z, t):
	return x - ((1.0 / t) / (0.5 + (1.0 / (y * math.expm1(z)))))

Julia

function code(x, y, z, t)
	return Float64(x - Float64(Float64(1.0 / t) / Float64(0.5 + Float64(1.0 / Float64(y * expm1(z))))))
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(N[(1.0 / t), $MachinePrecision] / N[(0.5 + N[(1.0 / N[(y * N[(Exp[z] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 87.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -6.5 \cdot 10^{+36}:\\ \;\;\;\;x - \frac{y}{\left(t \cdot -0.5 + \frac{t}{z}\right) - z \cdot \left(t \cdot -0.25 + t \cdot 0.16666666666666666\right)}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{y}{\frac{t}{\mathsf{expm1}\left(z\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -6.5e+36)
   (-
    x
    (/
     y
     (-
      (+ (* t -0.5) (/ t z))
      (* z (+ (* t -0.25) (* t 0.16666666666666666))))))
   (- x (/ y (/ t (expm1 z))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -6.5e+36) {
		tmp = x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))));
	} else {
		tmp = x - (y / (t / expm1(z)));
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -6.5e+36) {
		tmp = x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))));
	} else {
		tmp = x - (y / (t / Math.expm1(z)));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -6.5e+36:
		tmp = x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))))
	else:
		tmp = x - (y / (t / math.expm1(z)))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -6.5e+36)
		tmp = Float64(x - Float64(y / Float64(Float64(Float64(t * -0.5) + Float64(t / z)) - Float64(z * Float64(Float64(t * -0.25) + Float64(t * 0.16666666666666666))))));
	else
		tmp = Float64(x - Float64(y / Float64(t / expm1(z))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -6.5e+36], N[(x - N[(y / N[(N[(N[(t * -0.5), $MachinePrecision] + N[(t / z), $MachinePrecision]), $MachinePrecision] - N[(z * N[(N[(t * -0.25), $MachinePrecision] + N[(t * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(t / N[(Exp[z] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 81.9% accurate, 10.0× speedup

Math

\[\begin{array}{l} \\ x - \frac{y}{\left(t \cdot -0.5 + \frac{t}{z}\right) - z \cdot \left(t \cdot -0.25 + t \cdot 0.16666666666666666\right)} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (-
  x
  (/
   y
   (-
    (+ (* t -0.5) (/ t z))
    (* z (+ (* t -0.25) (* t 0.16666666666666666)))))))

C

double code(double x, double y, double z, double t) {
	return x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))));
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x - (y / (((t * (-0.5d0)) + (t / z)) - (z * ((t * (-0.25d0)) + (t * 0.16666666666666666d0)))))
end function

Java

public static double code(double x, double y, double z, double t) {
	return x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))));
}

Python

def code(x, y, z, t):
	return x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))))

Julia

function code(x, y, z, t)
	return Float64(x - Float64(y / Float64(Float64(Float64(t * -0.5) + Float64(t / z)) - Float64(z * Float64(Float64(t * -0.25) + Float64(t * 0.16666666666666666))))))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = x - (y / (((t * -0.5) + (t / z)) - (z * ((t * -0.25) + (t * 0.16666666666666666)))));
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(y / N[(N[(N[(t * -0.5), $MachinePrecision] + N[(t / z), $MachinePrecision]), $MachinePrecision] - N[(z * N[(N[(t * -0.25), $MachinePrecision] + N[(t * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 81.9% accurate, 14.1× speedup

Math

\[\begin{array}{l} \\ x - \frac{y}{t \cdot \left(\left(z \cdot 0.08333333333333333 + \frac{1}{z}\right) - 0.5\right)} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (- x (/ y (* t (- (+ (* z 0.08333333333333333) (/ 1.0 z)) 0.5)))))

C

double code(double x, double y, double z, double t) {
	return x - (y / (t * (((z * 0.08333333333333333) + (1.0 / z)) - 0.5)));
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x - (y / (t * (((z * 0.08333333333333333d0) + (1.0d0 / z)) - 0.5d0)))
end function

Java

public static double code(double x, double y, double z, double t) {
	return x - (y / (t * (((z * 0.08333333333333333) + (1.0 / z)) - 0.5)));
}

Python

def code(x, y, z, t):
	return x - (y / (t * (((z * 0.08333333333333333) + (1.0 / z)) - 0.5)))

Julia

function code(x, y, z, t)
	return Float64(x - Float64(y / Float64(t * Float64(Float64(Float64(z * 0.08333333333333333) + Float64(1.0 / z)) - 0.5))))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = x - (y / (t * (((z * 0.08333333333333333) + (1.0 / z)) - 0.5)));
end

Wolfram

code[x_, y_, z_, t_] := N[(x - N[(y / N[(t * N[(N[(N[(z * 0.08333333333333333), $MachinePrecision] + N[(1.0 / z), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 82.3% accurate, 16.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -6.8 \cdot 10^{+204}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x - \frac{y}{t \cdot -0.5 + \frac{t}{z}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -6.8e+204) x (- x (/ y (+ (* t -0.5) (/ t z))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -6.8e+204) {
		tmp = x;
	} else {
		tmp = x - (y / ((t * -0.5) + (t / z)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (y <= (-6.8d+204)) then
        tmp = x
    else
        tmp = x - (y / ((t * (-0.5d0)) + (t / z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -6.8e+204) {
		tmp = x;
	} else {
		tmp = x - (y / ((t * -0.5) + (t / z)));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -6.8e+204:
		tmp = x
	else:
		tmp = x - (y / ((t * -0.5) + (t / z)))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -6.8e+204)
		tmp = x;
	else
		tmp = Float64(x - Float64(y / Float64(Float64(t * -0.5) + Float64(t / z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -6.8e+204)
		tmp = x;
	else
		tmp = x - (y / ((t * -0.5) + (t / z)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -6.8e+204], x, N[(x - N[(y / N[(N[(t * -0.5), $MachinePrecision] + N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 81.0% accurate, 23.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{+94}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{z}{t}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -6.8e+94) x (- x (* y (/ z t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.8e+94) {
		tmp = x;
	} else {
		tmp = x - (y * (z / t));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-6.8d+94)) then
        tmp = x
    else
        tmp = x - (y * (z / t))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.8e+94) {
		tmp = x;
	} else {
		tmp = x - (y * (z / t));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -6.8e+94:
		tmp = x
	else:
		tmp = x - (y * (z / t))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -6.8e+94)
		tmp = x;
	else
		tmp = Float64(x - Float64(y * Float64(z / t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -6.8e+94)
		tmp = x;
	else
		tmp = x - (y * (z / t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -6.8e+94], x, N[(x - N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 81.0% accurate, 23.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{+94}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x - \frac{y}{\frac{t}{z}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -6.8e+94) x (- x (/ y (/ t z)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.8e+94) {
		tmp = x;
	} else {
		tmp = x - (y / (t / z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-6.8d+94)) then
        tmp = x
    else
        tmp = x - (y / (t / z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.8e+94) {
		tmp = x;
	} else {
		tmp = x - (y / (t / z));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -6.8e+94:
		tmp = x
	else:
		tmp = x - (y / (t / z))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -6.8e+94)
		tmp = x;
	else
		tmp = Float64(x - Float64(y / Float64(t / z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -6.8e+94)
		tmp = x;
	else
		tmp = x - (y / (t / z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -6.8e+94], x, N[(x - N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 71.3% accurate, 211.0× speedup

Math

\[\begin{array}{l} \\ x \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 x)

C

double code(double x, double y, double z, double t) {
	return x;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x
end function

Java

public static double code(double x, double y, double z, double t) {
	return x;
}

Python

def code(x, y, z, t):
	return x

Julia

function code(x, y, z, t)
	return x
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = x;
end

Wolfram

code[x_, y_, z_, t_] := x

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Developer target: 74.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-0.5}{y \cdot t}\\ \mathbf{if}\;z < -2.8874623088207947 \cdot 10^{+119}:\\ \;\;\;\;\left(x - \frac{t_1}{z \cdot z}\right) - t_1 \cdot \frac{\frac{2}{z}}{z \cdot z}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{\log \left(1 + z \cdot y\right)}{t}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (/ (- 0.5) (* y t))))
   (if (< z -2.8874623088207947e+119)
     (- (- x (/ t_1 (* z z))) (* t_1 (/ (/ 2.0 z) (* z z))))
     (- x (/ (log (+ 1.0 (* z y))) t)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = -0.5 / (y * t);
	double tmp;
	if (z < -2.8874623088207947e+119) {
		tmp = (x - (t_1 / (z * z))) - (t_1 * ((2.0 / z) / (z * z)));
	} else {
		tmp = x - (log((1.0 + (z * y))) / t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -0.5d0 / (y * t)
    if (z < (-2.8874623088207947d+119)) then
        tmp = (x - (t_1 / (z * z))) - (t_1 * ((2.0d0 / z) / (z * z)))
    else
        tmp = x - (log((1.0d0 + (z * y))) / t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = -0.5 / (y * t);
	double tmp;
	if (z < -2.8874623088207947e+119) {
		tmp = (x - (t_1 / (z * z))) - (t_1 * ((2.0 / z) / (z * z)));
	} else {
		tmp = x - (Math.log((1.0 + (z * y))) / t);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = -0.5 / (y * t)
	tmp = 0
	if z < -2.8874623088207947e+119:
		tmp = (x - (t_1 / (z * z))) - (t_1 * ((2.0 / z) / (z * z)))
	else:
		tmp = x - (math.log((1.0 + (z * y))) / t)
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(-0.5) / Float64(y * t))
	tmp = 0.0
	if (z < -2.8874623088207947e+119)
		tmp = Float64(Float64(x - Float64(t_1 / Float64(z * z))) - Float64(t_1 * Float64(Float64(2.0 / z) / Float64(z * z))));
	else
		tmp = Float64(x - Float64(log(Float64(1.0 + Float64(z * y))) / t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = -0.5 / (y * t);
	tmp = 0.0;
	if (z < -2.8874623088207947e+119)
		tmp = (x - (t_1 / (z * z))) - (t_1 * ((2.0 / z) / (z * z)));
	else
		tmp = x - (log((1.0 + (z * y))) / t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[((-0.5) / N[(y * t), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -2.8874623088207947e+119], N[(N[(x - N[(t$95$1 / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * N[(N[(2.0 / z), $MachinePrecision] / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[Log[N[(1.0 + N[(z * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]

Reproduce

herbie shell --seed 2024008 
(FPCore (x y z t)
  :name "System.Random.MWC.Distributions:truncatedExp from mwc-random-0.13.3.2"
  :precision binary64

  :herbie-target
  (if (< z -2.8874623088207947e+119) (- (- x (/ (/ (- 0.5) (* y t)) (* z z))) (* (/ (- 0.5) (* y t)) (/ (/ 2.0 z) (* z z)))) (- x (/ (log (+ 1.0 (* z y))) t)))

  (- x (/ (log (+ (- 1.0 y) (* y (exp z)))) t)))