Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A

Percentage Accurate: 99.4% → 99.8%

Time: 5.3s

Alternatives: 19

Speedup: 1.0×

• 55.0% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(((x * (5e-1)) - y) * (sqrt((z * (2))))) * (exp(((t * t) / (2))))
END code

Initial Program: 99.4% accurate, 1.0× speedup

Math

\[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(((x * (5e-1)) - y) * (sqrt((z * (2))))) * (exp(((t * t) / (2))))
END code

Alternative 1: 99.8% accurate, 0.9× speedup

Math

\[\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) (exp (/ (* t t) 2.0))))

C

double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * exp(((t * t) / 2.0));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * exp(((t * t) / 2.0d0))
end function

Java

public static double code(double x, double y, double z, double t) {
	return (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * Math.exp(((t * t) / 2.0));
}

Python

def code(x, y, z, t):
	return (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * math.exp(((t * t) / 2.0))

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * exp(Float64(Float64(t * t) / 2.0)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * exp(((t * t) / 2.0));
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (exp(((t * t) / (2))))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

2. Taylor expanded in z around inf

   \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
3. Step-by-step derivation

4. Applied rewrites 99.3%

   \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
5. Add Preprocessing

Alternative 2: 99.6% accurate, 1.0× speedup

Math

\[\left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (* (sqrt (exp (* t t))) (* (sqrt z) (- (* 0.5 x) y))) (sqrt 2.0)))

C

double code(double x, double y, double z, double t) {
	return (sqrt(exp((t * t))) * (sqrt(z) * ((0.5 * x) - y))) * sqrt(2.0);
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (sqrt(exp((t * t))) * (sqrt(z) * ((0.5d0 * x) - y))) * sqrt(2.0d0)
end function

Java

public static double code(double x, double y, double z, double t) {
	return (Math.sqrt(Math.exp((t * t))) * (Math.sqrt(z) * ((0.5 * x) - y))) * Math.sqrt(2.0);
}

Python

def code(x, y, z, t):
	return (math.sqrt(math.exp((t * t))) * (math.sqrt(z) * ((0.5 * x) - y))) * math.sqrt(2.0)

Julia

function code(x, y, z, t)
	return Float64(Float64(sqrt(exp(Float64(t * t))) * Float64(sqrt(z) * Float64(Float64(0.5 * x) - y))) * sqrt(2.0))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (sqrt(exp((t * t))) * (sqrt(z) * ((0.5 * x) - y))) * sqrt(2.0);
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(N[Sqrt[N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[z], $MachinePrecision] * N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	((sqrt((exp((t * t))))) * ((sqrt(z)) * (((5e-1) * x) - y))) * (sqrt((2)))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.2%

   \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]
4. Add Preprocessing

Alternative 3: 99.4% accurate, 1.1× speedup

Math

\[\sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (sqrt (* (exp (* t t)) z)) (* (sqrt 2.0) (- (* 0.5 x) y))))

C

double code(double x, double y, double z, double t) {
	return sqrt((exp((t * t)) * z)) * (sqrt(2.0) * ((0.5 * x) - y));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = sqrt((exp((t * t)) * z)) * (sqrt(2.0d0) * ((0.5d0 * x) - y))
end function

Java

public static double code(double x, double y, double z, double t) {
	return Math.sqrt((Math.exp((t * t)) * z)) * (Math.sqrt(2.0) * ((0.5 * x) - y));
}

Python

def code(x, y, z, t):
	return math.sqrt((math.exp((t * t)) * z)) * (math.sqrt(2.0) * ((0.5 * x) - y))

Julia

function code(x, y, z, t)
	return Float64(sqrt(Float64(exp(Float64(t * t)) * z)) * Float64(sqrt(2.0) * Float64(Float64(0.5 * x) - y)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = sqrt((exp((t * t)) * z)) * (sqrt(2.0) * ((0.5 * x) - y));
end

Wolfram

code[x_, y_, z_, t_] := N[(N[Sqrt[N[(N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision] * z), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] * N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(sqrt(((exp((t * t))) * z))) * ((sqrt((2))) * (((5e-1) * x) - y))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.6%

   \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]
4. Add Preprocessing

Alternative 4: 99.3% accurate, 1.1× speedup

Math

\[\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z + z} \cdot \left(0.5 \cdot x - y\right)\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (sqrt (exp (* t t))) (* (sqrt (+ z z)) (- (* 0.5 x) y))))

C

double code(double x, double y, double z, double t) {
	return sqrt(exp((t * t))) * (sqrt((z + z)) * ((0.5 * x) - y));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = sqrt(exp((t * t))) * (sqrt((z + z)) * ((0.5d0 * x) - y))
end function

Java

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

Python

def code(x, y, z, t):
	return math.sqrt(math.exp((t * t))) * (math.sqrt((z + z)) * ((0.5 * x) - y))

Julia

function code(x, y, z, t)
	return Float64(sqrt(exp(Float64(t * t))) * Float64(sqrt(Float64(z + z)) * Float64(Float64(0.5 * x) - y)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = sqrt(exp((t * t))) * (sqrt((z + z)) * ((0.5 * x) - y));
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(sqrt((exp((t * t))))) * ((sqrt((z + z))) * (((5e-1) * x) - y))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.4%

   \[\leadsto \sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z + z} \cdot \left(0.5 \cdot x - y\right)\right) \]
4. Add Preprocessing

Alternative 5: 99.2% accurate, 1.1× speedup

Math

\[\sqrt{e^{t \cdot t} \cdot \left(z + z\right)} \cdot \left(0.5 \cdot x - y\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (sqrt (* (exp (* t t)) (+ z z))) (- (* 0.5 x) y)))

C

double code(double x, double y, double z, double t) {
	return sqrt((exp((t * t)) * (z + z))) * ((0.5 * x) - y);
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = sqrt((exp((t * t)) * (z + z))) * ((0.5d0 * x) - y)
end function

Java

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

Python

def code(x, y, z, t):
	return math.sqrt((math.exp((t * t)) * (z + z))) * ((0.5 * x) - y)

Julia

function code(x, y, z, t)
	return Float64(sqrt(Float64(exp(Float64(t * t)) * Float64(z + z))) * Float64(Float64(0.5 * x) - y))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = sqrt((exp((t * t)) * (z + z))) * ((0.5 * x) - y);
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(sqrt(((exp((t * t))) * (z + z)))) * (((5e-1) * x) - y)
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.8%

   \[\leadsto \sqrt{e^{t \cdot t} \cdot \left(z + z\right)} \cdot \left(0.5 \cdot x - y\right) \]
4. Add Preprocessing

Alternative 6: 87.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := e^{t \cdot t}\\ \mathbf{if}\;t \cdot t \leq 4.1080164924754315 \cdot 10^{-6}:\\ \;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1\\ \mathbf{elif}\;t \cdot t \leq 1.0266858210649011 \cdot 10^{+112}:\\ \;\;\;\;\left(\left(0.7071067811865476 \cdot x\right) \cdot \sqrt{t\_1}\right) \cdot \sqrt{z}\\ \mathbf{else}:\\ \;\;\;\;\sqrt{t\_1 \cdot z} \cdot \left(-1.4142135623730951 \cdot y\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (exp (* t t))))
  (if (<= (* t t) 4.1080164924754315e-6)
    (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) 1.0)
    (if (<= (* t t) 1.0266858210649011e+112)
      (* (* (* 0.7071067811865476 x) (sqrt t_1)) (sqrt z))
      (* (sqrt (* t_1 z)) (- (* 1.4142135623730951 y)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = exp((t * t));
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 1.0266858210649011e+112) {
		tmp = ((0.7071067811865476 * x) * sqrt(t_1)) * sqrt(z);
	} else {
		tmp = sqrt((t_1 * z)) * -(1.4142135623730951 * y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 = exp((t * t))
    if ((t * t) <= 4.1080164924754315d-6) then
        tmp = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * 1.0d0
    else if ((t * t) <= 1.0266858210649011d+112) then
        tmp = ((0.7071067811865476d0 * x) * sqrt(t_1)) * sqrt(z)
    else
        tmp = sqrt((t_1 * z)) * -(1.4142135623730951d0 * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = Math.exp((t * t));
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 1.0266858210649011e+112) {
		tmp = ((0.7071067811865476 * x) * Math.sqrt(t_1)) * Math.sqrt(z);
	} else {
		tmp = Math.sqrt((t_1 * z)) * -(1.4142135623730951 * y);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = math.exp((t * t))
	tmp = 0
	if (t * t) <= 4.1080164924754315e-6:
		tmp = (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * 1.0
	elif (t * t) <= 1.0266858210649011e+112:
		tmp = ((0.7071067811865476 * x) * math.sqrt(t_1)) * math.sqrt(z)
	else:
		tmp = math.sqrt((t_1 * z)) * -(1.4142135623730951 * y)
	return tmp

Julia

function code(x, y, z, t)
	t_1 = exp(Float64(t * t))
	tmp = 0.0
	if (Float64(t * t) <= 4.1080164924754315e-6)
		tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * 1.0);
	elseif (Float64(t * t) <= 1.0266858210649011e+112)
		tmp = Float64(Float64(Float64(0.7071067811865476 * x) * sqrt(t_1)) * sqrt(z));
	else
		tmp = Float64(sqrt(Float64(t_1 * z)) * Float64(-Float64(1.4142135623730951 * y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = exp((t * t));
	tmp = 0.0;
	if ((t * t) <= 4.1080164924754315e-6)
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	elseif ((t * t) <= 1.0266858210649011e+112)
		tmp = ((0.7071067811865476 * x) * sqrt(t_1)) * sqrt(z);
	else
		tmp = sqrt((t_1 * z)) * -(1.4142135623730951 * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 4.1080164924754315e-6], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(z * N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[(t * t), $MachinePrecision], 1.0266858210649011e+112], N[(N[(N[(0.7071067811865476 * x), $MachinePrecision] * N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Sqrt[z], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(t$95$1 * z), $MachinePrecision]], $MachinePrecision] * (-N[(1.4142135623730951 * y), $MachinePrecision])), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (exp((t * t))) IN
		LET tmp_1 = IF ((t * t) <= (10266858210649011454806441507485580389034571876438678428507155303351037329774948747417579518533684222212878368768)) THEN ((((70710678118654757273731092936941422522068023681640625e-53) * x) * (sqrt(t_1))) * (sqrt(z))) ELSE ((sqrt((t_1 * z))) * (- ((14142135623730951454746218587388284504413604736328125e-52) * y))) ENDIF IN
		LET tmp = IF ((t * t) <= (41080164924754315413876239182489058521241531707346439361572265625e-70)) THEN ((((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (1)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 t t) < 4.1080164924754315e-6

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in z around inf

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
   3. Step-by-step derivation

   4. Applied rewrites 99.3%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

   5. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]

   if 4.1080164924754315e-6 < (*.f64 t t) < 1.0266858210649011e112

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.6%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

   4. Taylor expanded in x around inf

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\frac{1}{2} \cdot \left(x \cdot \sqrt{2}\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.5 \cdot \left(x \cdot \sqrt{2}\right)\right) \]

   8. Applied rewrites 64.4%

      \[\leadsto \left(\left(\sqrt{0.5} \cdot x\right) \cdot \sqrt{e^{t \cdot t}}\right) \cdot \sqrt{z} \]

   9. Evaluated real constant 64.4%

      \[\leadsto \left(\left(0.7071067811865476 \cdot x\right) \cdot \sqrt{e^{t \cdot t}}\right) \cdot \sqrt{z} \]

   if 1.0266858210649011e112 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.6%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

   4. Taylor expanded in x around 0

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1 \cdot \left(y \cdot \sqrt{2}\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1 \cdot \left(y \cdot \sqrt{2}\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-\sqrt{2} \cdot y\right) \]

   9. Evaluated real constant 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1.4142135623730951 \cdot y\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 85.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := \sqrt{e^{t \cdot t} \cdot z}\\ \mathbf{if}\;t \cdot t \leq 4.1080164924754315 \cdot 10^{-6}:\\ \;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1\\ \mathbf{elif}\;t \cdot t \leq 1.0266858210649011 \cdot 10^{+112}:\\ \;\;\;\;t\_1 \cdot \left(0.7071067811865476 \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1 \cdot \left(-1.4142135623730951 \cdot y\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (sqrt (* (exp (* t t)) z))))
  (if (<= (* t t) 4.1080164924754315e-6)
    (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) 1.0)
    (if (<= (* t t) 1.0266858210649011e+112)
      (* t_1 (* 0.7071067811865476 x))
      (* t_1 (- (* 1.4142135623730951 y)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = sqrt((exp((t * t)) * z));
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 1.0266858210649011e+112) {
		tmp = t_1 * (0.7071067811865476 * x);
	} else {
		tmp = t_1 * -(1.4142135623730951 * y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 = sqrt((exp((t * t)) * z))
    if ((t * t) <= 4.1080164924754315d-6) then
        tmp = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * 1.0d0
    else if ((t * t) <= 1.0266858210649011d+112) then
        tmp = t_1 * (0.7071067811865476d0 * x)
    else
        tmp = t_1 * -(1.4142135623730951d0 * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = Math.sqrt((Math.exp((t * t)) * z));
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 1.0266858210649011e+112) {
		tmp = t_1 * (0.7071067811865476 * x);
	} else {
		tmp = t_1 * -(1.4142135623730951 * y);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = math.sqrt((math.exp((t * t)) * z))
	tmp = 0
	if (t * t) <= 4.1080164924754315e-6:
		tmp = (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * 1.0
	elif (t * t) <= 1.0266858210649011e+112:
		tmp = t_1 * (0.7071067811865476 * x)
	else:
		tmp = t_1 * -(1.4142135623730951 * y)
	return tmp

Julia

function code(x, y, z, t)
	t_1 = sqrt(Float64(exp(Float64(t * t)) * z))
	tmp = 0.0
	if (Float64(t * t) <= 4.1080164924754315e-6)
		tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * 1.0);
	elseif (Float64(t * t) <= 1.0266858210649011e+112)
		tmp = Float64(t_1 * Float64(0.7071067811865476 * x));
	else
		tmp = Float64(t_1 * Float64(-Float64(1.4142135623730951 * y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = sqrt((exp((t * t)) * z));
	tmp = 0.0;
	if ((t * t) <= 4.1080164924754315e-6)
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	elseif ((t * t) <= 1.0266858210649011e+112)
		tmp = t_1 * (0.7071067811865476 * x);
	else
		tmp = t_1 * -(1.4142135623730951 * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision] * z), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 4.1080164924754315e-6], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(z * N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[(t * t), $MachinePrecision], 1.0266858210649011e+112], N[(t$95$1 * N[(0.7071067811865476 * x), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * (-N[(1.4142135623730951 * y), $MachinePrecision])), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (sqrt(((exp((t * t))) * z))) IN
		LET tmp_1 = IF ((t * t) <= (10266858210649011454806441507485580389034571876438678428507155303351037329774948747417579518533684222212878368768)) THEN (t_1 * ((70710678118654757273731092936941422522068023681640625e-53) * x)) ELSE (t_1 * (- ((14142135623730951454746218587388284504413604736328125e-52) * y))) ENDIF IN
		LET tmp = IF ((t * t) <= (41080164924754315413876239182489058521241531707346439361572265625e-70)) THEN ((((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (1)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 t t) < 4.1080164924754315e-6

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in z around inf

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
   3. Step-by-step derivation

   4. Applied rewrites 99.3%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

   5. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]

   if 4.1080164924754315e-6 < (*.f64 t t) < 1.0266858210649011e112

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.6%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

   4. Taylor expanded in x around inf

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\frac{1}{2} \cdot \left(x \cdot \sqrt{2}\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.5 \cdot \left(x \cdot \sqrt{2}\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{0.5} \cdot x\right) \]

   9. Evaluated real constant 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.7071067811865476 \cdot x\right) \]

   if 1.0266858210649011e112 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.6%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

   4. Taylor expanded in x around 0

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1 \cdot \left(y \cdot \sqrt{2}\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1 \cdot \left(y \cdot \sqrt{2}\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-\sqrt{2} \cdot y\right) \]

   9. Evaluated real constant 61.9%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(-1.4142135623730951 \cdot y\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 85.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \cdot t \leq 4.1080164924754315 \cdot 10^{-6}:\\ \;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1\\ \mathbf{else}:\\ \;\;\;\;\sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.7071067811865476 \cdot x\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (* t t) 4.1080164924754315e-6)
  (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) 1.0)
  (* (sqrt (* (exp (* t t)) z)) (* 0.7071067811865476 x))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	} else {
		tmp = sqrt((exp((t * t)) * z)) * (0.7071067811865476 * x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((t * t) <= 4.1080164924754315d-6) then
        tmp = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * 1.0d0
    else
        tmp = sqrt((exp((t * t)) * z)) * (0.7071067811865476d0 * x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 4.1080164924754315e-6) {
		tmp = (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * 1.0;
	} else {
		tmp = Math.sqrt((Math.exp((t * t)) * z)) * (0.7071067811865476 * x);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t * t) <= 4.1080164924754315e-6:
		tmp = (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * 1.0
	else:
		tmp = math.sqrt((math.exp((t * t)) * z)) * (0.7071067811865476 * x)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(t * t) <= 4.1080164924754315e-6)
		tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * 1.0);
	else
		tmp = Float64(sqrt(Float64(exp(Float64(t * t)) * z)) * Float64(0.7071067811865476 * x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t * t) <= 4.1080164924754315e-6)
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	else
		tmp = sqrt((exp((t * t)) * z)) * (0.7071067811865476 * x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(t * t), $MachinePrecision], 4.1080164924754315e-6], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(z * N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(N[Sqrt[N[(N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision] * z), $MachinePrecision]], $MachinePrecision] * N[(0.7071067811865476 * x), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp = IF ((t * t) <= (41080164924754315413876239182489058521241531707346439361572265625e-70)) THEN ((((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (1)) ELSE ((sqrt(((exp((t * t))) * z))) * ((70710678118654757273731092936941422522068023681640625e-53) * x)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 t t) < 4.1080164924754315e-6

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in z around inf

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
   3. Step-by-step derivation

   4. Applied rewrites 99.3%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

   5. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]

   if 4.1080164924754315e-6 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.6%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{2} \cdot \left(0.5 \cdot x - y\right)\right) \]

   4. Taylor expanded in x around inf

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\frac{1}{2} \cdot \left(x \cdot \sqrt{2}\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.5 \cdot \left(x \cdot \sqrt{2}\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(\sqrt{0.5} \cdot x\right) \]

   9. Evaluated real constant 64.4%

      \[\leadsto \sqrt{e^{t \cdot t} \cdot z} \cdot \left(0.7071067811865476 \cdot x\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 65.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_1 := 0.5 \cdot x - y\\ \mathbf{if}\;t \cdot t \leq 1755011869.03156:\\ \;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1\\ \mathbf{elif}\;t \cdot t \leq 2.4574458190906532 \cdot 10^{+216}:\\ \;\;\;\;z \cdot \left(\sqrt{\sqrt{\frac{4}{z \cdot z}}} \cdot t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;\sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* 0.5 x) y)))
  (if (<= (* t t) 1755011869.03156)
    (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) 1.0)
    (if (<= (* t t) 2.4574458190906532e+216)
      (* z (* (sqrt (sqrt (/ 4.0 (* z z)))) t_1))
      (* (sqrt (sqrt (* (* z z) 4.0))) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if ((t * t) <= 1755011869.03156) {
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 2.4574458190906532e+216) {
		tmp = z * (sqrt(sqrt((4.0 / (z * z)))) * t_1);
	} else {
		tmp = sqrt(sqrt(((z * z) * 4.0))) * t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 * x) - y
    if ((t * t) <= 1755011869.03156d0) then
        tmp = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * 1.0d0
    else if ((t * t) <= 2.4574458190906532d+216) then
        tmp = z * (sqrt(sqrt((4.0d0 / (z * z)))) * t_1)
    else
        tmp = sqrt(sqrt(((z * z) * 4.0d0))) * t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if ((t * t) <= 1755011869.03156) {
		tmp = (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * 1.0;
	} else if ((t * t) <= 2.4574458190906532e+216) {
		tmp = z * (Math.sqrt(Math.sqrt((4.0 / (z * z)))) * t_1);
	} else {
		tmp = Math.sqrt(Math.sqrt(((z * z) * 4.0))) * t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (0.5 * x) - y
	tmp = 0
	if (t * t) <= 1755011869.03156:
		tmp = (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * 1.0
	elif (t * t) <= 2.4574458190906532e+216:
		tmp = z * (math.sqrt(math.sqrt((4.0 / (z * z)))) * t_1)
	else:
		tmp = math.sqrt(math.sqrt(((z * z) * 4.0))) * t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(0.5 * x) - y)
	tmp = 0.0
	if (Float64(t * t) <= 1755011869.03156)
		tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * 1.0);
	elseif (Float64(t * t) <= 2.4574458190906532e+216)
		tmp = Float64(z * Float64(sqrt(sqrt(Float64(4.0 / Float64(z * z)))) * t_1));
	else
		tmp = Float64(sqrt(sqrt(Float64(Float64(z * z) * 4.0))) * t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (0.5 * x) - y;
	tmp = 0.0;
	if ((t * t) <= 1755011869.03156)
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	elseif ((t * t) <= 2.4574458190906532e+216)
		tmp = z * (sqrt(sqrt((4.0 / (z * z)))) * t_1);
	else
		tmp = sqrt(sqrt(((z * z) * 4.0))) * t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 1755011869.03156], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(z * N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[(t * t), $MachinePrecision], 2.4574458190906532e+216], N[(z * N[(N[Sqrt[N[Sqrt[N[(4.0 / N[(z * z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[Sqrt[N[(N[(z * z), $MachinePrecision] * 4.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * t$95$1), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (((5e-1) * x) - y) IN
		LET tmp_1 = IF ((t * t) <= (2457445819090653177308667355088145898019030675927467811653518382647988405825950998420423055980483716770693985791149200494808698124604765101736677601503386952736954035656381678013342237074971895356639464304816380968960)) THEN (z * ((sqrt((sqrt(((4) / (z * z)))))) * t_1)) ELSE ((sqrt((sqrt(((z * z) * (4)))))) * t_1) ENDIF IN
		LET tmp = IF ((t * t) <= (175501186903155994415283203125e-20)) THEN ((((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (1)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 t t) < 1755011869.0315599

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in z around inf

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
   3. Step-by-step derivation

   4. Applied rewrites 99.3%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

   5. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]

   if 1755011869.0315599 < (*.f64 t t) < 2.4574458190906532e216

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 56.7%

      \[\leadsto z \cdot \left(\sqrt{\frac{2}{z}} \cdot \left(0.5 \cdot x - y\right)\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 40.5%

       \[\leadsto z \cdot \left(\sqrt{\sqrt{\frac{4}{z \cdot z}}} \cdot \left(0.5 \cdot x - y\right)\right) \]

   if 2.4574458190906532e216 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 57.1%

      \[\leadsto \sqrt{z + z} \cdot \left(0.5 \cdot x - y\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 45.5%

       \[\leadsto \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot \left(0.5 \cdot x - y\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 64.3% accurate, 1.3× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \cdot t \leq 632957.7392377976:\\ \;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1\\ \mathbf{else}:\\ \;\;\;\;\sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot \left(0.5 \cdot x - y\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (* t t) 632957.7392377976)
  (* (* (- (* x 0.5) y) (* z (sqrt (/ 2.0 z)))) 1.0)
  (* (sqrt (sqrt (* (* z z) 4.0))) (- (* 0.5 x) y))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 632957.7392377976) {
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	} else {
		tmp = sqrt(sqrt(((z * z) * 4.0))) * ((0.5 * x) - y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((t * t) <= 632957.7392377976d0) then
        tmp = (((x * 0.5d0) - y) * (z * sqrt((2.0d0 / z)))) * 1.0d0
    else
        tmp = sqrt(sqrt(((z * z) * 4.0d0))) * ((0.5d0 * x) - y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 632957.7392377976) {
		tmp = (((x * 0.5) - y) * (z * Math.sqrt((2.0 / z)))) * 1.0;
	} else {
		tmp = Math.sqrt(Math.sqrt(((z * z) * 4.0))) * ((0.5 * x) - y);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t * t) <= 632957.7392377976:
		tmp = (((x * 0.5) - y) * (z * math.sqrt((2.0 / z)))) * 1.0
	else:
		tmp = math.sqrt(math.sqrt(((z * z) * 4.0))) * ((0.5 * x) - y)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(t * t) <= 632957.7392377976)
		tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * Float64(z * sqrt(Float64(2.0 / z)))) * 1.0);
	else
		tmp = Float64(sqrt(sqrt(Float64(Float64(z * z) * 4.0))) * Float64(Float64(0.5 * x) - y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t * t) <= 632957.7392377976)
		tmp = (((x * 0.5) - y) * (z * sqrt((2.0 / z)))) * 1.0;
	else
		tmp = sqrt(sqrt(((z * z) * 4.0))) * ((0.5 * x) - y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(t * t), $MachinePrecision], 632957.7392377976], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(z * N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(N[Sqrt[N[Sqrt[N[(N[(z * z), $MachinePrecision] * 4.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp = IF ((t * t) <= (632957739237797562964260578155517578125e-33)) THEN ((((x * (5e-1)) - y) * (z * (sqrt(((2) / z))))) * (1)) ELSE ((sqrt((sqrt(((z * z) * (4)))))) * (((5e-1) * x) - y)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 t t) < 632957.73923779756

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in z around inf

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]
   3. Step-by-step derivation

   4. Applied rewrites 99.3%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot e^{\frac{t \cdot t}{2}} \]

   5. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \left(z \cdot \sqrt{\frac{2}{z}}\right)\right) \cdot 1 \]

   if 632957.73923779756 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 57.1%

      \[\leadsto \sqrt{z + z} \cdot \left(0.5 \cdot x - y\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 45.5%

       \[\leadsto \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot \left(0.5 \cdot x - y\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 64.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := 0.5 \cdot x - y\\ \mathbf{if}\;t \cdot t \leq 632957.7392377976:\\ \;\;\;\;1.4142135623730951 \cdot \left(\sqrt{z} \cdot t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;\sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* 0.5 x) y)))
  (if (<= (* t t) 632957.7392377976)
    (* 1.4142135623730951 (* (sqrt z) t_1))
    (* (sqrt (sqrt (* (* z z) 4.0))) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if ((t * t) <= 632957.7392377976) {
		tmp = 1.4142135623730951 * (sqrt(z) * t_1);
	} else {
		tmp = sqrt(sqrt(((z * z) * 4.0))) * t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 * x) - y
    if ((t * t) <= 632957.7392377976d0) then
        tmp = 1.4142135623730951d0 * (sqrt(z) * t_1)
    else
        tmp = sqrt(sqrt(((z * z) * 4.0d0))) * t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if ((t * t) <= 632957.7392377976) {
		tmp = 1.4142135623730951 * (Math.sqrt(z) * t_1);
	} else {
		tmp = Math.sqrt(Math.sqrt(((z * z) * 4.0))) * t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (0.5 * x) - y
	tmp = 0
	if (t * t) <= 632957.7392377976:
		tmp = 1.4142135623730951 * (math.sqrt(z) * t_1)
	else:
		tmp = math.sqrt(math.sqrt(((z * z) * 4.0))) * t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(0.5 * x) - y)
	tmp = 0.0
	if (Float64(t * t) <= 632957.7392377976)
		tmp = Float64(1.4142135623730951 * Float64(sqrt(z) * t_1));
	else
		tmp = Float64(sqrt(sqrt(Float64(Float64(z * z) * 4.0))) * t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (0.5 * x) - y;
	tmp = 0.0;
	if ((t * t) <= 632957.7392377976)
		tmp = 1.4142135623730951 * (sqrt(z) * t_1);
	else
		tmp = sqrt(sqrt(((z * z) * 4.0))) * t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 632957.7392377976], N[(1.4142135623730951 * N[(N[Sqrt[z], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[Sqrt[N[(N[(z * z), $MachinePrecision] * 4.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * t$95$1), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (((5e-1) * x) - y) IN
		LET tmp = IF ((t * t) <= (632957739237797562964260578155517578125e-33)) THEN ((14142135623730951454746218587388284504413604736328125e-52) * ((sqrt(z)) * t_1)) ELSE ((sqrt((sqrt(((z * z) * (4)))))) * t_1) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 t t) < 632957.73923779756

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   if 632957.73923779756 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 57.1%

      \[\leadsto \sqrt{z + z} \cdot \left(0.5 \cdot x - y\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 45.5%

       \[\leadsto \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}} \cdot \left(0.5 \cdot x - y\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 61.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := 0.5 \cdot x - y\\ \mathbf{if}\;\left|t\right| \leq 1.1027093305479828 \cdot 10^{-5}:\\ \;\;\;\;1.4142135623730951 \cdot \left(\sqrt{z} \cdot t\_1\right)\\ \mathbf{elif}\;\left|t\right| \leq 4.474364829663385 \cdot 10^{+201}:\\ \;\;\;\;z \cdot \left(\sqrt{\frac{2}{z}} \cdot t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;\left(\left(-y\right) \cdot \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}}\right) \cdot 1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* 0.5 x) y)))
  (if (<= (fabs t) 1.1027093305479828e-5)
    (* 1.4142135623730951 (* (sqrt z) t_1))
    (if (<= (fabs t) 4.474364829663385e+201)
      (* z (* (sqrt (/ 2.0 z)) t_1))
      (* (* (- y) (sqrt (sqrt (* (* z z) 4.0)))) 1.0)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if (fabs(t) <= 1.1027093305479828e-5) {
		tmp = 1.4142135623730951 * (sqrt(z) * t_1);
	} else if (fabs(t) <= 4.474364829663385e+201) {
		tmp = z * (sqrt((2.0 / z)) * t_1);
	} else {
		tmp = (-y * sqrt(sqrt(((z * z) * 4.0)))) * 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 * x) - y
    if (abs(t) <= 1.1027093305479828d-5) then
        tmp = 1.4142135623730951d0 * (sqrt(z) * t_1)
    else if (abs(t) <= 4.474364829663385d+201) then
        tmp = z * (sqrt((2.0d0 / z)) * t_1)
    else
        tmp = (-y * sqrt(sqrt(((z * z) * 4.0d0)))) * 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (0.5 * x) - y;
	double tmp;
	if (Math.abs(t) <= 1.1027093305479828e-5) {
		tmp = 1.4142135623730951 * (Math.sqrt(z) * t_1);
	} else if (Math.abs(t) <= 4.474364829663385e+201) {
		tmp = z * (Math.sqrt((2.0 / z)) * t_1);
	} else {
		tmp = (-y * Math.sqrt(Math.sqrt(((z * z) * 4.0)))) * 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (0.5 * x) - y
	tmp = 0
	if math.fabs(t) <= 1.1027093305479828e-5:
		tmp = 1.4142135623730951 * (math.sqrt(z) * t_1)
	elif math.fabs(t) <= 4.474364829663385e+201:
		tmp = z * (math.sqrt((2.0 / z)) * t_1)
	else:
		tmp = (-y * math.sqrt(math.sqrt(((z * z) * 4.0)))) * 1.0
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(0.5 * x) - y)
	tmp = 0.0
	if (abs(t) <= 1.1027093305479828e-5)
		tmp = Float64(1.4142135623730951 * Float64(sqrt(z) * t_1));
	elseif (abs(t) <= 4.474364829663385e+201)
		tmp = Float64(z * Float64(sqrt(Float64(2.0 / z)) * t_1));
	else
		tmp = Float64(Float64(Float64(-y) * sqrt(sqrt(Float64(Float64(z * z) * 4.0)))) * 1.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (0.5 * x) - y;
	tmp = 0.0;
	if (abs(t) <= 1.1027093305479828e-5)
		tmp = 1.4142135623730951 * (sqrt(z) * t_1);
	elseif (abs(t) <= 4.474364829663385e+201)
		tmp = z * (sqrt((2.0 / z)) * t_1);
	else
		tmp = (-y * sqrt(sqrt(((z * z) * 4.0)))) * 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[N[Abs[t], $MachinePrecision], 1.1027093305479828e-5], N[(1.4142135623730951 * N[(N[Sqrt[z], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[t], $MachinePrecision], 4.474364829663385e+201], N[(z * N[(N[Sqrt[N[(2.0 / z), $MachinePrecision]], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[((-y) * N[Sqrt[N[Sqrt[N[(N[(z * z), $MachinePrecision] * 4.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (((5e-1) * x) - y) IN
		LET tmp_1 = IF ((abs(t)) <= (4474364829663384951486692412963541539371906816605566155961446367851561752594808933299332477565730359815103013809966581455738159590200780606732505486042793018792063375612673779602415612957969241570541568)) THEN (z * ((sqrt(((2) / z))) * t_1)) ELSE (((- y) * (sqrt((sqrt(((z * z) * (4))))))) * (1)) ENDIF IN
		LET tmp = IF ((abs(t)) <= (11027093305479827663640075841033905135191162116825580596923828125e-69)) THEN ((14142135623730951454746218587388284504413604736328125e-52) * ((sqrt(z)) * t_1)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < 1.1027093305479828e-5

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   if 1.1027093305479828e-5 < t < 4.474364829663385e201

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 56.7%

      \[\leadsto z \cdot \left(\sqrt{\frac{2}{z}} \cdot \left(0.5 \cdot x - y\right)\right) \]

   if 4.474364829663385e201 < t

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   3. Step-by-step derivation

   4. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]

   5. Taylor expanded in x around 0

      \[\leadsto \left(\left(-1 \cdot y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 29.7%

      \[\leadsto \left(\left(-1 \cdot y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 29.7%

      \[\leadsto \left(\left(-y\right) \cdot \sqrt{z + z}\right) \cdot 1 \]
   10. Step-by-step derivation

   11. Applied rewrites 27.7%

       \[\leadsto \left(\left(-y\right) \cdot \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}}\right) \cdot 1 \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 13: 59.1% accurate, 1.4× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \cdot t \leq 1.1652898637328667 \cdot 10^{+167}:\\ \;\;\;\;1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(\left(-y\right) \cdot \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}}\right) \cdot 1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (* t t) 1.1652898637328667e+167)
  (* 1.4142135623730951 (* (sqrt z) (- (* 0.5 x) y)))
  (* (* (- y) (sqrt (sqrt (* (* z z) 4.0)))) 1.0)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 1.1652898637328667e+167) {
		tmp = 1.4142135623730951 * (sqrt(z) * ((0.5 * x) - y));
	} else {
		tmp = (-y * sqrt(sqrt(((z * z) * 4.0)))) * 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((t * t) <= 1.1652898637328667d+167) then
        tmp = 1.4142135623730951d0 * (sqrt(z) * ((0.5d0 * x) - y))
    else
        tmp = (-y * sqrt(sqrt(((z * z) * 4.0d0)))) * 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((t * t) <= 1.1652898637328667e+167) {
		tmp = 1.4142135623730951 * (Math.sqrt(z) * ((0.5 * x) - y));
	} else {
		tmp = (-y * Math.sqrt(Math.sqrt(((z * z) * 4.0)))) * 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t * t) <= 1.1652898637328667e+167:
		tmp = 1.4142135623730951 * (math.sqrt(z) * ((0.5 * x) - y))
	else:
		tmp = (-y * math.sqrt(math.sqrt(((z * z) * 4.0)))) * 1.0
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(t * t) <= 1.1652898637328667e+167)
		tmp = Float64(1.4142135623730951 * Float64(sqrt(z) * Float64(Float64(0.5 * x) - y)));
	else
		tmp = Float64(Float64(Float64(-y) * sqrt(sqrt(Float64(Float64(z * z) * 4.0)))) * 1.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t * t) <= 1.1652898637328667e+167)
		tmp = 1.4142135623730951 * (sqrt(z) * ((0.5 * x) - y));
	else
		tmp = (-y * sqrt(sqrt(((z * z) * 4.0)))) * 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(t * t), $MachinePrecision], 1.1652898637328667e+167], N[(1.4142135623730951 * N[(N[Sqrt[z], $MachinePrecision] * N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-y) * N[Sqrt[N[Sqrt[N[(N[(z * z), $MachinePrecision] * 4.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp = IF ((t * t) <= (116528986373286667645434902668930469067624713088215015284674062671375562904270526939051615766700361413096545033328718937887685622303893359407657585676198595368463630336)) THEN ((14142135623730951454746218587388284504413604736328125e-52) * ((sqrt(z)) * (((5e-1) * x) - y))) ELSE (((- y) * (sqrt((sqrt(((z * z) * (4))))))) * (1)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 t t) < 1.1652898637328667e167

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   if 1.1652898637328667e167 < (*.f64 t t)

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]

   2. Taylor expanded in t around 0

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   3. Step-by-step derivation

   4. Applied rewrites 57.1%

      \[\leadsto \left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]

   5. Taylor expanded in x around 0

      \[\leadsto \left(\left(-1 \cdot y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   6. Step-by-step derivation

   7. Applied rewrites 29.7%

      \[\leadsto \left(\left(-1 \cdot y\right) \cdot \sqrt{z \cdot 2}\right) \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 29.7%

      \[\leadsto \left(\left(-y\right) \cdot \sqrt{z + z}\right) \cdot 1 \]
   10. Step-by-step derivation

   11. Applied rewrites 27.7%

       \[\leadsto \left(\left(-y\right) \cdot \sqrt{\sqrt{\left(z \cdot z\right) \cdot 4}}\right) \cdot 1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 57.1% accurate, 2.4× speedup

Math

\[1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* 1.4142135623730951 (* (sqrt z) (- (* 0.5 x) y))))

C

double code(double x, double y, double z, double t) {
	return 1.4142135623730951 * (sqrt(z) * ((0.5 * x) - y));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = 1.4142135623730951d0 * (sqrt(z) * ((0.5d0 * x) - y))
end function

Java

public static double code(double x, double y, double z, double t) {
	return 1.4142135623730951 * (Math.sqrt(z) * ((0.5 * x) - y));
}

Python

def code(x, y, z, t):
	return 1.4142135623730951 * (math.sqrt(z) * ((0.5 * x) - y))

Julia

function code(x, y, z, t)
	return Float64(1.4142135623730951 * Float64(sqrt(z) * Float64(Float64(0.5 * x) - y)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = 1.4142135623730951 * (sqrt(z) * ((0.5 * x) - y));
end

Wolfram

code[x_, y_, z_, t_] := N[(1.4142135623730951 * N[(N[Sqrt[z], $MachinePrecision] * N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(14142135623730951454746218587388284504413604736328125e-52) * ((sqrt(z)) * (((5e-1) * x) - y))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.2%

   \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

4. Taylor expanded in t around 0

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
5. Step-by-step derivation

6. Applied rewrites 57.0%

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

7. Evaluated real constant 57.0%

   \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
8. Add Preprocessing

Alternative 15: 57.0% accurate, 2.5× speedup

Math

\[\sqrt{z + z} \cdot \left(0.5 \cdot x - y\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* (sqrt (+ z z)) (- (* 0.5 x) y)))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = sqrt((z + z)) * ((0.5d0 * x) - y)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(sqrt((z + z))) * (((5e-1) * x) - y)
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.2%

   \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

4. Taylor expanded in t around 0

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
5. Step-by-step derivation

6. Applied rewrites 57.0%

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]
7. Step-by-step derivation

8. Applied rewrites 57.1%

   \[\leadsto \sqrt{z + z} \cdot \left(0.5 \cdot x - y\right) \]
9. Add Preprocessing

Alternative 16: 43.5% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_1 := x \cdot \left(0.5 \cdot \sqrt{z + z}\right)\\ \mathbf{if}\;x \cdot 0.5 \leq -1 \cdot 10^{+44}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot 0.5 \leq 2 \cdot 10^{+38}:\\ \;\;\;\;-1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* x (* 0.5 (sqrt (+ z z))))))
  (if (<= (* x 0.5) -1e+44)
    t_1
    (if (<= (* x 0.5) 2e+38)
      (* -1.4142135623730951 (* y (sqrt z)))
      t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * (0.5 * sqrt((z + z)));
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = t_1;
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * sqrt(z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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 = x * (0.5d0 * sqrt((z + z)))
    if ((x * 0.5d0) <= (-1d+44)) then
        tmp = t_1
    else if ((x * 0.5d0) <= 2d+38) then
        tmp = (-1.4142135623730951d0) * (y * sqrt(z))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x * (0.5 * Math.sqrt((z + z)));
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = t_1;
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * Math.sqrt(z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x * (0.5 * math.sqrt((z + z)))
	tmp = 0
	if (x * 0.5) <= -1e+44:
		tmp = t_1
	elif (x * 0.5) <= 2e+38:
		tmp = -1.4142135623730951 * (y * math.sqrt(z))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x * Float64(0.5 * sqrt(Float64(z + z))))
	tmp = 0.0
	if (Float64(x * 0.5) <= -1e+44)
		tmp = t_1;
	elseif (Float64(x * 0.5) <= 2e+38)
		tmp = Float64(-1.4142135623730951 * Float64(y * sqrt(z)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x * (0.5 * sqrt((z + z)));
	tmp = 0.0;
	if ((x * 0.5) <= -1e+44)
		tmp = t_1;
	elseif ((x * 0.5) <= 2e+38)
		tmp = -1.4142135623730951 * (y * sqrt(z));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(0.5 * N[Sqrt[N[(z + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * 0.5), $MachinePrecision], -1e+44], t$95$1, If[LessEqual[N[(x * 0.5), $MachinePrecision], 2e+38], N[(-1.4142135623730951 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (x * ((5e-1) * (sqrt((z + z))))) IN
		LET tmp_1 = IF ((x * (5e-1)) <= (199999999999999995497619646912068059136)) THEN ((-14142135623730951454746218587388284504413604736328125e-52) * (y * (sqrt(z)))) ELSE t_1 ENDIF IN
		LET tmp = IF ((x * (5e-1)) <= (-100000000000000008821361405306422640701865984)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 x #s(literal 1/2 binary64)) < -1.0000000000000001e44 or 2e38 < (*.f64 x #s(literal 1/2 binary64))

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Taylor expanded in x around inf

      \[\leadsto \frac{1}{2} \cdot \left(x \cdot \left(\sqrt{2} \cdot \sqrt{z}\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 30.3%

      \[\leadsto 0.5 \cdot \left(x \cdot \left(\sqrt{2} \cdot \sqrt{z}\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 30.4%

       \[\leadsto x \cdot \left(0.5 \cdot \sqrt{z + z}\right) \]

   if -1.0000000000000001e44 < (*.f64 x #s(literal 1/2 binary64)) < 2e38

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   8. Taylor expanded in x around 0

      \[\leadsto \frac{-6369051672525773}{4503599627370496} \cdot \left(y \cdot \sqrt{z}\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 29.6%

       \[\leadsto -1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 43.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \cdot 0.5 \leq -1 \cdot 10^{+44}:\\ \;\;\;\;x \cdot \left(\sqrt{0.5} \cdot \sqrt{z}\right)\\ \mathbf{elif}\;x \cdot 0.5 \leq 2 \cdot 10^{+38}:\\ \;\;\;\;-1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right)\\ \mathbf{else}:\\ \;\;\;\;0.7071067811865476 \cdot \left(x \cdot \sqrt{z}\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (* x 0.5) -1e+44)
  (* x (* (sqrt 0.5) (sqrt z)))
  (if (<= (* x 0.5) 2e+38)
    (* -1.4142135623730951 (* y (sqrt z)))
    (* 0.7071067811865476 (* x (sqrt z))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = x * (sqrt(0.5) * sqrt(z));
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * sqrt(z));
	} else {
		tmp = 0.7071067811865476 * (x * sqrt(z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((x * 0.5d0) <= (-1d+44)) then
        tmp = x * (sqrt(0.5d0) * sqrt(z))
    else if ((x * 0.5d0) <= 2d+38) then
        tmp = (-1.4142135623730951d0) * (y * sqrt(z))
    else
        tmp = 0.7071067811865476d0 * (x * sqrt(z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = x * (Math.sqrt(0.5) * Math.sqrt(z));
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * Math.sqrt(z));
	} else {
		tmp = 0.7071067811865476 * (x * Math.sqrt(z));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (x * 0.5) <= -1e+44:
		tmp = x * (math.sqrt(0.5) * math.sqrt(z))
	elif (x * 0.5) <= 2e+38:
		tmp = -1.4142135623730951 * (y * math.sqrt(z))
	else:
		tmp = 0.7071067811865476 * (x * math.sqrt(z))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(x * 0.5) <= -1e+44)
		tmp = Float64(x * Float64(sqrt(0.5) * sqrt(z)));
	elseif (Float64(x * 0.5) <= 2e+38)
		tmp = Float64(-1.4142135623730951 * Float64(y * sqrt(z)));
	else
		tmp = Float64(0.7071067811865476 * Float64(x * sqrt(z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((x * 0.5) <= -1e+44)
		tmp = x * (sqrt(0.5) * sqrt(z));
	elseif ((x * 0.5) <= 2e+38)
		tmp = -1.4142135623730951 * (y * sqrt(z));
	else
		tmp = 0.7071067811865476 * (x * sqrt(z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(x * 0.5), $MachinePrecision], -1e+44], N[(x * N[(N[Sqrt[0.5], $MachinePrecision] * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * 0.5), $MachinePrecision], 2e+38], N[(-1.4142135623730951 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.7071067811865476 * N[(x * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_1 = IF ((x * (5e-1)) <= (199999999999999995497619646912068059136)) THEN ((-14142135623730951454746218587388284504413604736328125e-52) * (y * (sqrt(z)))) ELSE ((70710678118654757273731092936941422522068023681640625e-53) * (x * (sqrt(z)))) ENDIF IN
	LET tmp = IF ((x * (5e-1)) <= (-100000000000000008821361405306422640701865984)) THEN (x * ((sqrt((5e-1))) * (sqrt(z)))) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 x #s(literal 1/2 binary64)) < -1.0000000000000001e44

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Taylor expanded in x around inf

      \[\leadsto \frac{1}{2} \cdot \left(x \cdot \left(\sqrt{2} \cdot \sqrt{z}\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 30.3%

      \[\leadsto 0.5 \cdot \left(x \cdot \left(\sqrt{2} \cdot \sqrt{z}\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 30.3%

       \[\leadsto x \cdot \left(\sqrt{0.5} \cdot \sqrt{z}\right) \]

   if -1.0000000000000001e44 < (*.f64 x #s(literal 1/2 binary64)) < 2e38

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   8. Taylor expanded in x around 0

      \[\leadsto \frac{-6369051672525773}{4503599627370496} \cdot \left(y \cdot \sqrt{z}\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 29.6%

       \[\leadsto -1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right) \]

   if 2e38 < (*.f64 x #s(literal 1/2 binary64))

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   8. Taylor expanded in x around inf

      \[\leadsto \frac{6369051672525773}{9007199254740992} \cdot \left(x \cdot \sqrt{z}\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 30.3%

       \[\leadsto 0.7071067811865476 \cdot \left(x \cdot \sqrt{z}\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 18: 43.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} t_1 := 0.7071067811865476 \cdot \left(x \cdot \sqrt{z}\right)\\ \mathbf{if}\;x \cdot 0.5 \leq -1 \cdot 10^{+44}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot 0.5 \leq 2 \cdot 10^{+38}:\\ \;\;\;\;-1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* 0.7071067811865476 (* x (sqrt z)))))
  (if (<= (* x 0.5) -1e+44)
    t_1
    (if (<= (* x 0.5) 2e+38)
      (* -1.4142135623730951 (* y (sqrt z)))
      t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = 0.7071067811865476 * (x * sqrt(z));
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = t_1;
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * sqrt(z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    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.7071067811865476d0 * (x * sqrt(z))
    if ((x * 0.5d0) <= (-1d+44)) then
        tmp = t_1
    else if ((x * 0.5d0) <= 2d+38) then
        tmp = (-1.4142135623730951d0) * (y * sqrt(z))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = 0.7071067811865476 * (x * Math.sqrt(z));
	double tmp;
	if ((x * 0.5) <= -1e+44) {
		tmp = t_1;
	} else if ((x * 0.5) <= 2e+38) {
		tmp = -1.4142135623730951 * (y * Math.sqrt(z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = 0.7071067811865476 * (x * math.sqrt(z))
	tmp = 0
	if (x * 0.5) <= -1e+44:
		tmp = t_1
	elif (x * 0.5) <= 2e+38:
		tmp = -1.4142135623730951 * (y * math.sqrt(z))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(0.7071067811865476 * Float64(x * sqrt(z)))
	tmp = 0.0
	if (Float64(x * 0.5) <= -1e+44)
		tmp = t_1;
	elseif (Float64(x * 0.5) <= 2e+38)
		tmp = Float64(-1.4142135623730951 * Float64(y * sqrt(z)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = 0.7071067811865476 * (x * sqrt(z));
	tmp = 0.0;
	if ((x * 0.5) <= -1e+44)
		tmp = t_1;
	elseif ((x * 0.5) <= 2e+38)
		tmp = -1.4142135623730951 * (y * sqrt(z));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(0.7071067811865476 * N[(x * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * 0.5), $MachinePrecision], -1e+44], t$95$1, If[LessEqual[N[(x * 0.5), $MachinePrecision], 2e+38], N[(-1.4142135623730951 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = ((70710678118654757273731092936941422522068023681640625e-53) * (x * (sqrt(z)))) IN
		LET tmp_1 = IF ((x * (5e-1)) <= (199999999999999995497619646912068059136)) THEN ((-14142135623730951454746218587388284504413604736328125e-52) * (y * (sqrt(z)))) ELSE t_1 ENDIF IN
		LET tmp = IF ((x * (5e-1)) <= (-100000000000000008821361405306422640701865984)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (*.f64 x #s(literal 1/2 binary64)) < -1.0000000000000001e44 or 2e38 < (*.f64 x #s(literal 1/2 binary64))

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   8. Taylor expanded in x around inf

      \[\leadsto \frac{6369051672525773}{9007199254740992} \cdot \left(x \cdot \sqrt{z}\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 30.3%

       \[\leadsto 0.7071067811865476 \cdot \left(x \cdot \sqrt{z}\right) \]

   if -1.0000000000000001e44 < (*.f64 x #s(literal 1/2 binary64)) < 2e38

   1. Initial program 99.4%

      \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
   2. Step-by-step derivation

   3. Applied rewrites 99.2%

      \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

   4. Taylor expanded in t around 0

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 57.0%

      \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   7. Evaluated real constant 57.0%

      \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

   8. Taylor expanded in x around 0

      \[\leadsto \frac{-6369051672525773}{4503599627370496} \cdot \left(y \cdot \sqrt{z}\right) \]
   9. Step-by-step derivation

   10. Applied rewrites 29.6%

       \[\leadsto -1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 19: 29.6% accurate, 3.9× speedup

Math

\[-1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* -1.4142135623730951 (* y (sqrt z))))

C

double code(double x, double y, double z, double t) {
	return -1.4142135623730951 * (y * sqrt(z));
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (-1.4142135623730951d0) * (y * sqrt(z))
end function

Java

public static double code(double x, double y, double z, double t) {
	return -1.4142135623730951 * (y * Math.sqrt(z));
}

Python

def code(x, y, z, t):
	return -1.4142135623730951 * (y * math.sqrt(z))

Julia

function code(x, y, z, t)
	return Float64(-1.4142135623730951 * Float64(y * sqrt(z)))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = -1.4142135623730951 * (y * sqrt(z));
end

Wolfram

code[x_, y_, z_, t_] := N[(-1.4142135623730951 * N[(y * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(-14142135623730951454746218587388284504413604736328125e-52) * (y * (sqrt(z)))
END code

Derivation

1. Initial program 99.4%

   \[\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}} \]
2. Step-by-step derivation

3. Applied rewrites 99.2%

   \[\leadsto \left(\sqrt{e^{t \cdot t}} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right)\right) \cdot \sqrt{2} \]

4. Taylor expanded in t around 0

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(\frac{1}{2} \cdot x - y\right)\right) \]
5. Step-by-step derivation

6. Applied rewrites 57.0%

   \[\leadsto \sqrt{2} \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

7. Evaluated real constant 57.0%

   \[\leadsto 1.4142135623730951 \cdot \left(\sqrt{z} \cdot \left(0.5 \cdot x - y\right)\right) \]

8. Taylor expanded in x around 0

   \[\leadsto \frac{-6369051672525773}{4503599627370496} \cdot \left(y \cdot \sqrt{z}\right) \]
9. Step-by-step derivation

10. Applied rewrites 29.6%

    \[\leadsto -1.4142135623730951 \cdot \left(y \cdot \sqrt{z}\right) \]
11. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t)
  :name "Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A"
  :precision binary64
  (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))