SynthBasics:moogVCF from YampaSynth-0.2

Percentage Accurate: 93.4% → 98.1%

Time: 12.9s

Alternatives: 13

Speedup: 0.7×

Specification

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (+ x (* (* y z) (- (tanh (/ t y)) (tanh (/ x y))))))

C

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

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 * z) * (tanh((t / y)) - tanh((x / y))))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 93.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (+ x (* (* y z) (- (tanh (/ t y)) (tanh (/ x y))))))

C

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

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 * z) * (tanh((t / y)) - tanh((x / y))))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 98.1% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (fma z (* y (- (tanh (/ t y)) (tanh (/ x y)))) x))

C

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

Julia

function code(x, y, z, t)
	return fma(z, Float64(y * Float64(tanh(Float64(t / y)) - tanh(Float64(x / y)))), x)
end

Wolfram

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

Derivation

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

Alternative 2: 96.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(\tanh \left(\frac{t}{y}\right) - \tanh \left(\frac{x}{y}\right)\right) \cdot \left(z \cdot y\right)\\ \mathbf{if}\;t_1 \leq 2 \cdot 10^{+300}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(t - x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (* (- (tanh (/ t y)) (tanh (/ x y))) (* z y)))))
   (if (<= t_1 2e+300) t_1 (+ x (* z (- t x))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + ((tanh((t / y)) - tanh((x / y))) * (z * y));
	double tmp;
	if (t_1 <= 2e+300) {
		tmp = t_1;
	} else {
		tmp = x + (z * (t - x));
	}
	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 = x + ((tanh((t / y)) - tanh((x / y))) * (z * y))
    if (t_1 <= 2d+300) then
        tmp = t_1
    else
        tmp = x + (z * (t - x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x + ((Math.tanh((t / y)) - Math.tanh((x / y))) * (z * y));
	double tmp;
	if (t_1 <= 2e+300) {
		tmp = t_1;
	} else {
		tmp = x + (z * (t - x));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + ((math.tanh((t / y)) - math.tanh((x / y))) * (z * y))
	tmp = 0
	if t_1 <= 2e+300:
		tmp = t_1
	else:
		tmp = x + (z * (t - x))
	return tmp

Julia

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

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + ((tanh((t / y)) - tanh((x / y))) * (z * y));
	tmp = 0.0;
	if (t_1 <= 2e+300)
		tmp = t_1;
	else
		tmp = x + (z * (t - x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(N[Tanh[N[(t / y), $MachinePrecision]], $MachinePrecision] - N[Tanh[N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e+300], t$95$1, N[(x + N[(z * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 3: 88.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \tanh \left(\frac{t}{y}\right)\\ \mathbf{if}\;t \leq -1.8 \cdot 10^{+72}:\\ \;\;\;\;x + z \cdot t_1\\ \mathbf{elif}\;t \leq 1.5 \cdot 10^{-106}:\\ \;\;\;\;\mathsf{fma}\left(z, t - y \cdot \tanh \left(\frac{x}{y}\right), x\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(z, t_1, x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* y (tanh (/ t y)))))
   (if (<= t -1.8e+72)
     (+ x (* z t_1))
     (if (<= t 1.5e-106) (fma z (- t (* y (tanh (/ x y)))) x) (fma z t_1 x)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = y * tanh((t / y));
	double tmp;
	if (t <= -1.8e+72) {
		tmp = x + (z * t_1);
	} else if (t <= 1.5e-106) {
		tmp = fma(z, (t - (y * tanh((x / y)))), x);
	} else {
		tmp = fma(z, t_1, x);
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(y * tanh(Float64(t / y)))
	tmp = 0.0
	if (t <= -1.8e+72)
		tmp = Float64(x + Float64(z * t_1));
	elseif (t <= 1.5e-106)
		tmp = fma(z, Float64(t - Float64(y * tanh(Float64(x / y)))), x);
	else
		tmp = fma(z, t_1, x);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y * N[Tanh[N[(t / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.8e+72], N[(x + N[(z * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.5e-106], N[(z * N[(t - N[(y * N[Tanh[N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(z * t$95$1 + x), $MachinePrecision]]]]

Derivation

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

Alternative 4: 83.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \tanh \left(\frac{t}{y}\right)\\ \mathbf{if}\;y \leq 3.55 \cdot 10^{+19}:\\ \;\;\;\;\mathsf{fma}\left(z, y \cdot t_1, x\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(x, 1 - z, y \cdot \left(z \cdot t_1\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (tanh (/ t y))))
   (if (<= y 3.55e+19) (fma z (* y t_1) x) (fma x (- 1.0 z) (* y (* z t_1))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = tanh((t / y));
	double tmp;
	if (y <= 3.55e+19) {
		tmp = fma(z, (y * t_1), x);
	} else {
		tmp = fma(x, (1.0 - z), (y * (z * t_1)));
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = tanh(Float64(t / y))
	tmp = 0.0
	if (y <= 3.55e+19)
		tmp = fma(z, Float64(y * t_1), x);
	else
		tmp = fma(x, Float64(1.0 - z), Float64(y * Float64(z * t_1)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[Tanh[N[(t / y), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, 3.55e+19], N[(z * N[(y * t$95$1), $MachinePrecision] + x), $MachinePrecision], N[(x * N[(1.0 - z), $MachinePrecision] + N[(y * N[(z * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 5: 88.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \tanh \left(\frac{t}{y}\right)\\ \mathbf{if}\;t \leq -1.8 \cdot 10^{+72}:\\ \;\;\;\;x + z \cdot t_1\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{-106}:\\ \;\;\;\;x + z \cdot \left(t - y \cdot \tanh \left(\frac{x}{y}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(z, t_1, x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* y (tanh (/ t y)))))
   (if (<= t -1.8e+72)
     (+ x (* z t_1))
     (if (<= t 1.4e-106)
       (+ x (* z (- t (* y (tanh (/ x y))))))
       (fma z t_1 x)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = y * tanh((t / y));
	double tmp;
	if (t <= -1.8e+72) {
		tmp = x + (z * t_1);
	} else if (t <= 1.4e-106) {
		tmp = x + (z * (t - (y * tanh((x / y)))));
	} else {
		tmp = fma(z, t_1, x);
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(y * tanh(Float64(t / y)))
	tmp = 0.0
	if (t <= -1.8e+72)
		tmp = Float64(x + Float64(z * t_1));
	elseif (t <= 1.4e-106)
		tmp = Float64(x + Float64(z * Float64(t - Float64(y * tanh(Float64(x / y))))));
	else
		tmp = fma(z, t_1, x);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y * N[Tanh[N[(t / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.8e+72], N[(x + N[(z * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.4e-106], N[(x + N[(z * N[(t - N[(y * N[Tanh[N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * t$95$1 + x), $MachinePrecision]]]]

Derivation

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

Alternative 6: 88.5% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.6 \cdot 10^{+72} \lor \neg \left(t \leq 2.6 \cdot 10^{-108}\right):\\ \;\;\;\;x + z \cdot \left(y \cdot \tanh \left(\frac{t}{y}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(t - y \cdot \tanh \left(\frac{x}{y}\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -2.6e+72) (not (<= t 2.6e-108)))
   (+ x (* z (* y (tanh (/ t y)))))
   (+ x (* z (- t (* y (tanh (/ x y))))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -2.6e+72) || !(t <= 2.6e-108)) {
		tmp = x + (z * (y * tanh((t / y))));
	} else {
		tmp = x + (z * (t - (y * tanh((x / y)))));
	}
	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 ((t <= (-2.6d+72)) .or. (.not. (t <= 2.6d-108))) then
        tmp = x + (z * (y * tanh((t / y))))
    else
        tmp = x + (z * (t - (y * tanh((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 <= -2.6e+72) || !(t <= 2.6e-108)) {
		tmp = x + (z * (y * Math.tanh((t / y))));
	} else {
		tmp = x + (z * (t - (y * Math.tanh((x / y)))));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -2.6e+72) or not (t <= 2.6e-108):
		tmp = x + (z * (y * math.tanh((t / y))))
	else:
		tmp = x + (z * (t - (y * math.tanh((x / y)))))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -2.6e+72) || !(t <= 2.6e-108))
		tmp = Float64(x + Float64(z * Float64(y * tanh(Float64(t / y)))));
	else
		tmp = Float64(x + Float64(z * Float64(t - Float64(y * tanh(Float64(x / y))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t <= -2.6e+72) || ~((t <= 2.6e-108)))
		tmp = x + (z * (y * tanh((t / y))));
	else
		tmp = x + (z * (t - (y * tanh((x / y)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -2.6e+72], N[Not[LessEqual[t, 2.6e-108]], $MachinePrecision]], N[(x + N[(z * N[(y * N[Tanh[N[(t / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(z * N[(t - N[(y * N[Tanh[N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 7: 83.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 4.5 \cdot 10^{+129}:\\ \;\;\;\;x + y \cdot \left(z \cdot \tanh \left(\frac{t}{y}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(t - x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y 4.5e+129) (+ x (* y (* z (tanh (/ t y))))) (+ x (* z (- t x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 4.5e+129) {
		tmp = x + (y * (z * tanh((t / y))));
	} else {
		tmp = x + (z * (t - x));
	}
	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 <= 4.5d+129) then
        tmp = x + (y * (z * tanh((t / y))))
    else
        tmp = x + (z * (t - x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 4.5e+129) {
		tmp = x + (y * (z * Math.tanh((t / y))));
	} else {
		tmp = x + (z * (t - x));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= 4.5e+129:
		tmp = x + (y * (z * math.tanh((t / y))))
	else:
		tmp = x + (z * (t - x))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 8: 83.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 1.16 \cdot 10^{+129}:\\ \;\;\;\;x + z \cdot \left(y \cdot \tanh \left(\frac{t}{y}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(t - x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y 1.16e+129) (+ x (* z (* y (tanh (/ t y))))) (+ x (* z (- t x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 1.16e+129) {
		tmp = x + (z * (y * tanh((t / y))));
	} else {
		tmp = x + (z * (t - x));
	}
	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 <= 1.16d+129) then
        tmp = x + (z * (y * tanh((t / y))))
    else
        tmp = x + (z * (t - x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 1.16e+129) {
		tmp = x + (z * (y * Math.tanh((t / y))));
	} else {
		tmp = x + (z * (t - x));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= 1.16e+129:
		tmp = x + (z * (y * math.tanh((t / y))))
	else:
		tmp = x + (z * (t - x))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 9: 62.1% accurate, 23.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -8.5 \cdot 10^{-138}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.4 \cdot 10^{-198}:\\ \;\;\;\;z \cdot \left(t - x\right)\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= x -8.5e-138) x (if (<= x 1.4e-198) (* z (- t x)) x)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -8.5e-138) {
		tmp = x;
	} else if (x <= 1.4e-198) {
		tmp = z * (t - x);
	} else {
		tmp = x;
	}
	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 (x <= (-8.5d-138)) then
        tmp = x
    else if (x <= 1.4d-198) then
        tmp = z * (t - x)
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -8.5e-138) {
		tmp = x;
	} else if (x <= 1.4e-198) {
		tmp = z * (t - x);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if x <= -8.5e-138:
		tmp = x
	elif x <= 1.4e-198:
		tmp = z * (t - x)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -8.5e-138)
		tmp = x;
	elseif (x <= 1.4e-198)
		tmp = Float64(z * Float64(t - x));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (x <= -8.5e-138)
		tmp = x;
	elseif (x <= 1.4e-198)
		tmp = z * (t - x);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -8.5e-138], x, If[LessEqual[x, 1.4e-198], N[(z * N[(t - x), $MachinePrecision]), $MachinePrecision], x]]

Derivation

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

Alternative 10: 69.6% accurate, 23.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 7.4 \cdot 10^{+18}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(t - x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y 7.4e+18) x (+ x (* z (- t x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 7.4e+18) {
		tmp = x;
	} else {
		tmp = x + (z * (t - x));
	}
	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 <= 7.4d+18) then
        tmp = x
    else
        tmp = x + (z * (t - x))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 11: 61.9% accurate, 29.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.52 \cdot 10^{-254}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.28 \cdot 10^{-197}:\\ \;\;\;\;z \cdot t\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= x -1.52e-254) x (if (<= x 1.28e-197) (* z t) x)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.52e-254) {
		tmp = x;
	} else if (x <= 1.28e-197) {
		tmp = z * t;
	} else {
		tmp = x;
	}
	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 (x <= (-1.52d-254)) then
        tmp = x
    else if (x <= 1.28d-197) then
        tmp = z * t
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.52e-254) {
		tmp = x;
	} else if (x <= 1.28e-197) {
		tmp = z * t;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if x <= -1.52e-254:
		tmp = x
	elif x <= 1.28e-197:
		tmp = z * t
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -1.52e-254)
		tmp = x;
	elseif (x <= 1.28e-197)
		tmp = Float64(z * t);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (x <= -1.52e-254)
		tmp = x;
	elseif (x <= 1.28e-197)
		tmp = z * t;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -1.52e-254], x, If[LessEqual[x, 1.28e-197], N[(z * t), $MachinePrecision], x]]

Derivation

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

Alternative 12: 65.7% accurate, 30.2× speedup

Math

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

FPCore

(FPCore (x y z t) :precision binary64 (if (<= y 7.2e-75) x (+ x (* z t))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 7.2e-75) {
		tmp = x;
	} else {
		tmp = x + (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 (y <= 7.2d-75) then
        tmp = x
    else
        tmp = x + (z * t)
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 13: 60.4% accurate, 213.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: 97.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (+ x (* y (* z (- (tanh (/ t y)) (tanh (/ x y)))))))

C

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

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 * (z * (tanh((t / y)) - tanh((x / y)))))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023350 
(FPCore (x y z t)
  :name "SynthBasics:moogVCF from YampaSynth-0.2"
  :precision binary64

  :herbie-target
  (+ x (* y (* z (- (tanh (/ t y)) (tanh (/ x y))))))

  (+ x (* (* y z) (- (tanh (/ t y)) (tanh (/ x y))))))