Toniolo and Linder, Equation (3b), real

Percentage Accurate: 94.1% → 99.7%

Time: 17.2s

Alternatives: 19

Speedup: 1.4×

Specification

Math

\[\begin{array}{l} \\ \frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))

C

double code(double kx, double ky, double th) {
	return (sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) * sin(th);
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = (sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) * sin(th)
end function

Java

public static double code(double kx, double ky, double th) {
	return (Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) * Math.sin(th);
}

Python

def code(kx, ky, th):
	return (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) * math.sin(th)

Julia

function code(kx, ky, th)
	return Float64(Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = (sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th);
end

Wolfram

code[kx_, ky_, th_] := N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]

Initial Program: 94.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))

C

double code(double kx, double ky, double th) {
	return (sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) * sin(th);
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = (sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) * sin(th)
end function

Java

public static double code(double kx, double ky, double th) {
	return (Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) * Math.sin(th);
}

Python

def code(kx, ky, th):
	return (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) * math.sin(th)

Julia

function code(kx, ky, th)
	return Float64(Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = (sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th);
end

Wolfram

code[kx_, ky_, th_] := N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.7% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \frac{\sin th}{\frac{\mathsf{hypot}\left(\sin kx, \sin ky\right)}{\sin ky}} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (/ (sin th) (/ (hypot (sin kx) (sin ky)) (sin ky))))

C

double code(double kx, double ky, double th) {
	return sin(th) / (hypot(sin(kx), sin(ky)) / sin(ky));
}

Java

public static double code(double kx, double ky, double th) {
	return Math.sin(th) / (Math.hypot(Math.sin(kx), Math.sin(ky)) / Math.sin(ky));
}

Python

def code(kx, ky, th):
	return math.sin(th) / (math.hypot(math.sin(kx), math.sin(ky)) / math.sin(ky))

Julia

function code(kx, ky, th)
	return Float64(sin(th) / Float64(hypot(sin(kx), sin(ky)) / sin(ky)))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = sin(th) / (hypot(sin(kx), sin(ky)) / sin(ky));
end

Wolfram

code[kx_, ky_, th_] := N[(N[Sin[th], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision] / N[Sin[ky], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 2: 66.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq 0.0002:\\ \;\;\;\;\sin ky \cdot \frac{\sin th}{\mathsf{hypot}\left(ky, \sin kx\right)}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) 0.0002)
   (* (sin ky) (/ (sin th) (hypot ky (sin kx))))
   (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= 0.0002) {
		tmp = sin(ky) * (sin(th) / hypot(ky, sin(kx)));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (Math.sin(ky) <= 0.0002) {
		tmp = Math.sin(ky) * (Math.sin(th) / Math.hypot(ky, Math.sin(kx)));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= 0.0002:
		tmp = math.sin(ky) * (math.sin(th) / math.hypot(ky, math.sin(kx)))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= 0.0002)
		tmp = Float64(sin(ky) * Float64(sin(th) / hypot(ky, sin(kx))));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (sin(ky) <= 0.0002)
		tmp = sin(ky) * (sin(th) / hypot(ky, sin(kx)));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[ky], $MachinePrecision], 0.0002], N[(N[Sin[ky], $MachinePrecision] * N[(N[Sin[th], $MachinePrecision] / N[Sqrt[ky ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 3: 66.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq 0.0002:\\ \;\;\;\;\sin th \cdot \frac{\sin ky}{\mathsf{hypot}\left(ky, \sin kx\right)}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) 0.0002)
   (* (sin th) (/ (sin ky) (hypot ky (sin kx))))
   (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= 0.0002) {
		tmp = sin(th) * (sin(ky) / hypot(ky, sin(kx)));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (Math.sin(ky) <= 0.0002) {
		tmp = Math.sin(th) * (Math.sin(ky) / Math.hypot(ky, Math.sin(kx)));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= 0.0002:
		tmp = math.sin(th) * (math.sin(ky) / math.hypot(ky, math.sin(kx)))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= 0.0002)
		tmp = Float64(sin(th) * Float64(sin(ky) / hypot(ky, sin(kx))));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (sin(ky) <= 0.0002)
		tmp = sin(th) * (sin(ky) / hypot(ky, sin(kx)));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[ky], $MachinePrecision], 0.0002], N[(N[Sin[th], $MachinePrecision] * N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[ky ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 4: 99.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \sin ky \cdot \frac{\sin th}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (* (sin ky) (/ (sin th) (hypot (sin ky) (sin kx)))))

C

double code(double kx, double ky, double th) {
	return sin(ky) * (sin(th) / hypot(sin(ky), sin(kx)));
}

Java

public static double code(double kx, double ky, double th) {
	return Math.sin(ky) * (Math.sin(th) / Math.hypot(Math.sin(ky), Math.sin(kx)));
}

Python

def code(kx, ky, th):
	return math.sin(ky) * (math.sin(th) / math.hypot(math.sin(ky), math.sin(kx)))

Julia

function code(kx, ky, th)
	return Float64(sin(ky) * Float64(sin(th) / hypot(sin(ky), sin(kx))))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = sin(ky) * (sin(th) / hypot(sin(ky), sin(kx)));
end

Wolfram

code[kx_, ky_, th_] := N[(N[Sin[ky], $MachinePrecision] * N[(N[Sin[th], $MachinePrecision] / N[Sqrt[N[Sin[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 5: 99.7% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \sin th \cdot \frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (* (sin th) (/ (sin ky) (hypot (sin ky) (sin kx)))))

C

double code(double kx, double ky, double th) {
	return sin(th) * (sin(ky) / hypot(sin(ky), sin(kx)));
}

Java

public static double code(double kx, double ky, double th) {
	return Math.sin(th) * (Math.sin(ky) / Math.hypot(Math.sin(ky), Math.sin(kx)));
}

Python

def code(kx, ky, th):
	return math.sin(th) * (math.sin(ky) / math.hypot(math.sin(ky), math.sin(kx)))

Julia

function code(kx, ky, th)
	return Float64(sin(th) * Float64(sin(ky) / hypot(sin(ky), sin(kx))))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = sin(th) * (sin(ky) / hypot(sin(ky), sin(kx)));
end

Wolfram

code[kx_, ky_, th_] := N[(N[Sin[th], $MachinePrecision] * N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[Sin[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 6: 63.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;th \leq 0.029:\\ \;\;\;\;\frac{\sin ky}{\mathsf{hypot}\left(\sin kx, \sin ky\right) \cdot \left(\frac{1}{th} + th \cdot 0.16666666666666666\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\sin th}{\frac{\mathsf{hypot}\left(\sin kx, ky\right)}{\sin ky}}\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= th 0.029)
   (/
    (sin ky)
    (* (hypot (sin kx) (sin ky)) (+ (/ 1.0 th) (* th 0.16666666666666666))))
   (/ (sin th) (/ (hypot (sin kx) ky) (sin ky)))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.029) {
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) * ((1.0 / th) + (th * 0.16666666666666666)));
	} else {
		tmp = sin(th) / (hypot(sin(kx), ky) / sin(ky));
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.029) {
		tmp = Math.sin(ky) / (Math.hypot(Math.sin(kx), Math.sin(ky)) * ((1.0 / th) + (th * 0.16666666666666666)));
	} else {
		tmp = Math.sin(th) / (Math.hypot(Math.sin(kx), ky) / Math.sin(ky));
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if th <= 0.029:
		tmp = math.sin(ky) / (math.hypot(math.sin(kx), math.sin(ky)) * ((1.0 / th) + (th * 0.16666666666666666)))
	else:
		tmp = math.sin(th) / (math.hypot(math.sin(kx), ky) / math.sin(ky))
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (th <= 0.029)
		tmp = Float64(sin(ky) / Float64(hypot(sin(kx), sin(ky)) * Float64(Float64(1.0 / th) + Float64(th * 0.16666666666666666))));
	else
		tmp = Float64(sin(th) / Float64(hypot(sin(kx), ky) / sin(ky)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (th <= 0.029)
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) * ((1.0 / th) + (th * 0.16666666666666666)));
	else
		tmp = sin(th) / (hypot(sin(kx), ky) / sin(ky));
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[th, 0.029], N[(N[Sin[ky], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision] * N[(N[(1.0 / th), $MachinePrecision] + N[(th * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sin[th], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + ky ^ 2], $MachinePrecision] / N[Sin[ky], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 7: 62.9% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;th \leq 0.0145:\\ \;\;\;\;\frac{\sin ky}{\frac{\mathsf{hypot}\left(\sin kx, \sin ky\right)}{th}}\\ \mathbf{else}:\\ \;\;\;\;\sin th \cdot \frac{\sin ky}{\mathsf{hypot}\left(ky, \sin kx\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= th 0.0145)
   (/ (sin ky) (/ (hypot (sin kx) (sin ky)) th))
   (* (sin th) (/ (sin ky) (hypot ky (sin kx))))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.0145) {
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) / th);
	} else {
		tmp = sin(th) * (sin(ky) / hypot(ky, sin(kx)));
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.0145) {
		tmp = Math.sin(ky) / (Math.hypot(Math.sin(kx), Math.sin(ky)) / th);
	} else {
		tmp = Math.sin(th) * (Math.sin(ky) / Math.hypot(ky, Math.sin(kx)));
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if th <= 0.0145:
		tmp = math.sin(ky) / (math.hypot(math.sin(kx), math.sin(ky)) / th)
	else:
		tmp = math.sin(th) * (math.sin(ky) / math.hypot(ky, math.sin(kx)))
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (th <= 0.0145)
		tmp = Float64(sin(ky) / Float64(hypot(sin(kx), sin(ky)) / th));
	else
		tmp = Float64(sin(th) * Float64(sin(ky) / hypot(ky, sin(kx))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (th <= 0.0145)
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) / th);
	else
		tmp = sin(th) * (sin(ky) / hypot(ky, sin(kx)));
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[th, 0.0145], N[(N[Sin[ky], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision] / th), $MachinePrecision]), $MachinePrecision], N[(N[Sin[th], $MachinePrecision] * N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[ky ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 8: 62.9% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;th \leq 0.00087:\\ \;\;\;\;\frac{\sin ky}{\frac{\mathsf{hypot}\left(\sin kx, \sin ky\right)}{th}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\sin th}{\frac{\mathsf{hypot}\left(\sin kx, ky\right)}{\sin ky}}\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= th 0.00087)
   (/ (sin ky) (/ (hypot (sin kx) (sin ky)) th))
   (/ (sin th) (/ (hypot (sin kx) ky) (sin ky)))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.00087) {
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) / th);
	} else {
		tmp = sin(th) / (hypot(sin(kx), ky) / sin(ky));
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (th <= 0.00087) {
		tmp = Math.sin(ky) / (Math.hypot(Math.sin(kx), Math.sin(ky)) / th);
	} else {
		tmp = Math.sin(th) / (Math.hypot(Math.sin(kx), ky) / Math.sin(ky));
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if th <= 0.00087:
		tmp = math.sin(ky) / (math.hypot(math.sin(kx), math.sin(ky)) / th)
	else:
		tmp = math.sin(th) / (math.hypot(math.sin(kx), ky) / math.sin(ky))
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (th <= 0.00087)
		tmp = Float64(sin(ky) / Float64(hypot(sin(kx), sin(ky)) / th));
	else
		tmp = Float64(sin(th) / Float64(hypot(sin(kx), ky) / sin(ky)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (th <= 0.00087)
		tmp = sin(ky) / (hypot(sin(kx), sin(ky)) / th);
	else
		tmp = sin(th) / (hypot(sin(kx), ky) / sin(ky));
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[th, 0.00087], N[(N[Sin[ky], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision] / th), $MachinePrecision]), $MachinePrecision], N[(N[Sin[th], $MachinePrecision] / N[(N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + ky ^ 2], $MachinePrecision] / N[Sin[ky], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 9: 42.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq 5 \cdot 10^{-82}:\\ \;\;\;\;\sin ky \cdot \frac{\sin th}{\sin kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) 5e-82) (* (sin ky) (/ (sin th) (sin kx))) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= 5e-82) {
		tmp = sin(ky) * (sin(th) / sin(kx));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (sin(ky) <= 5d-82) then
        tmp = sin(ky) * (sin(th) / sin(kx))
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (Math.sin(ky) <= 5e-82) {
		tmp = Math.sin(ky) * (Math.sin(th) / Math.sin(kx));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= 5e-82:
		tmp = math.sin(ky) * (math.sin(th) / math.sin(kx))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= 5e-82)
		tmp = Float64(sin(ky) * Float64(sin(th) / sin(kx)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (sin(ky) <= 5e-82)
		tmp = sin(ky) * (sin(th) / sin(kx));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[ky], $MachinePrecision], 5e-82], N[(N[Sin[ky], $MachinePrecision] * N[(N[Sin[th], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 10: 42.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq 5 \cdot 10^{-82}:\\ \;\;\;\;\frac{\sin th}{\frac{\sin kx}{\sin ky}}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) 5e-82) (/ (sin th) (/ (sin kx) (sin ky))) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= 5e-82) {
		tmp = sin(th) / (sin(kx) / sin(ky));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (sin(ky) <= 5d-82) then
        tmp = sin(th) / (sin(kx) / sin(ky))
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (Math.sin(ky) <= 5e-82) {
		tmp = Math.sin(th) / (Math.sin(kx) / Math.sin(ky));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= 5e-82:
		tmp = math.sin(th) / (math.sin(kx) / math.sin(ky))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= 5e-82)
		tmp = Float64(sin(th) / Float64(sin(kx) / sin(ky)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (sin(ky) <= 5e-82)
		tmp = sin(th) / (sin(kx) / sin(ky));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[ky], $MachinePrecision], 5e-82], N[(N[Sin[th], $MachinePrecision] / N[(N[Sin[kx], $MachinePrecision] / N[Sin[ky], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 11: 34.2% accurate, 3.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 5.8 \cdot 10^{-53}:\\ \;\;\;\;\frac{\sin th}{ky \cdot \frac{0.5}{kx} + \frac{\sin kx}{ky}}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 5.8e-53)
   (/ (sin th) (+ (* ky (/ 0.5 kx)) (/ (sin kx) ky)))
   (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 5.8e-53) {
		tmp = sin(th) / ((ky * (0.5 / kx)) + (sin(kx) / ky));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (ky <= 5.8d-53) then
        tmp = sin(th) / ((ky * (0.5d0 / kx)) + (sin(kx) / ky))
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 5.8e-53) {
		tmp = Math.sin(th) / ((ky * (0.5 / kx)) + (Math.sin(kx) / ky));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 5.8e-53:
		tmp = math.sin(th) / ((ky * (0.5 / kx)) + (math.sin(kx) / ky))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 5.8e-53)
		tmp = Float64(sin(th) / Float64(Float64(ky * Float64(0.5 / kx)) + Float64(sin(kx) / ky)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (ky <= 5.8e-53)
		tmp = sin(th) / ((ky * (0.5 / kx)) + (sin(kx) / ky));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 5.8e-53], N[(N[Sin[th], $MachinePrecision] / N[(N[(ky * N[(0.5 / kx), $MachinePrecision]), $MachinePrecision] + N[(N[Sin[kx], $MachinePrecision] / ky), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 12: 34.0% accurate, 3.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 1.9 \cdot 10^{-78}:\\ \;\;\;\;ky \cdot \frac{\sin th}{\sin kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 1.9e-78) (* ky (/ (sin th) (sin kx))) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.9e-78) {
		tmp = ky * (sin(th) / sin(kx));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (ky <= 1.9d-78) then
        tmp = ky * (sin(th) / sin(kx))
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.9e-78) {
		tmp = ky * (Math.sin(th) / Math.sin(kx));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 1.9e-78:
		tmp = ky * (math.sin(th) / math.sin(kx))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 1.9e-78)
		tmp = Float64(ky * Float64(sin(th) / sin(kx)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (ky <= 1.9e-78)
		tmp = ky * (sin(th) / sin(kx));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 1.9e-78], N[(ky * N[(N[Sin[th], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 13: 34.0% accurate, 3.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 1.55 \cdot 10^{-74}:\\ \;\;\;\;\frac{\sin th}{\frac{\sin kx}{ky}}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 1.55e-74) (/ (sin th) (/ (sin kx) ky)) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.55e-74) {
		tmp = sin(th) / (sin(kx) / ky);
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (ky <= 1.55d-74) then
        tmp = sin(th) / (sin(kx) / ky)
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.55e-74) {
		tmp = Math.sin(th) / (Math.sin(kx) / ky);
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 1.55e-74:
		tmp = math.sin(th) / (math.sin(kx) / ky)
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 1.55e-74)
		tmp = Float64(sin(th) / Float64(sin(kx) / ky));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (ky <= 1.55e-74)
		tmp = sin(th) / (sin(kx) / ky);
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 1.55e-74], N[(N[Sin[th], $MachinePrecision] / N[(N[Sin[kx], $MachinePrecision] / ky), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 14: 27.2% accurate, 6.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 6.5 \cdot 10^{-154}:\\ \;\;\;\;ky \cdot \frac{\sin th}{kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 6.5e-154) (* ky (/ (sin th) kx)) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 6.5e-154) {
		tmp = ky * (sin(th) / kx);
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (ky <= 6.5d-154) then
        tmp = ky * (sin(th) / kx)
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 6.5e-154) {
		tmp = ky * (Math.sin(th) / kx);
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 6.5e-154:
		tmp = ky * (math.sin(th) / kx)
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 6.5e-154)
		tmp = Float64(ky * Float64(sin(th) / kx));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (ky <= 6.5e-154)
		tmp = ky * (sin(th) / kx);
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 6.5e-154], N[(ky * N[(N[Sin[th], $MachinePrecision] / kx), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 15: 24.4% accurate, 6.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 1.75 \cdot 10^{-204}:\\ \;\;\;\;\frac{ky}{0.16666666666666666 \cdot \left(th \cdot kx\right) + \frac{kx}{th}}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 1.75e-204)
   (/ ky (+ (* 0.16666666666666666 (* th kx)) (/ kx th)))
   (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.75e-204) {
		tmp = ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    real(8) :: tmp
    if (ky <= 1.75d-204) then
        tmp = ky / ((0.16666666666666666d0 * (th * kx)) + (kx / th))
    else
        tmp = sin(th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.75e-204) {
		tmp = ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 1.75e-204:
		tmp = ky / ((0.16666666666666666 * (th * kx)) + (kx / th))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 1.75e-204)
		tmp = Float64(ky / Float64(Float64(0.16666666666666666 * Float64(th * kx)) + Float64(kx / th)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (ky <= 1.75e-204)
		tmp = ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 1.75e-204], N[(ky / N[(N[(0.16666666666666666 * N[(th * kx), $MachinePrecision]), $MachinePrecision] + N[(kx / th), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]

Derivation

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

Alternative 16: 13.9% accurate, 64.5× speedup

Math

\[\begin{array}{l} \\ \frac{ky}{0.16666666666666666 \cdot \left(th \cdot kx\right) + \frac{kx}{th}} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (/ ky (+ (* 0.16666666666666666 (* th kx)) (/ kx th))))

C

double code(double kx, double ky, double th) {
	return ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = ky / ((0.16666666666666666d0 * (th * kx)) + (kx / th))
end function

Java

public static double code(double kx, double ky, double th) {
	return ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
}

Python

def code(kx, ky, th):
	return ky / ((0.16666666666666666 * (th * kx)) + (kx / th))

Julia

function code(kx, ky, th)
	return Float64(ky / Float64(Float64(0.16666666666666666 * Float64(th * kx)) + Float64(kx / th)))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = ky / ((0.16666666666666666 * (th * kx)) + (kx / th));
end

Wolfram

code[kx_, ky_, th_] := N[(ky / N[(N[(0.16666666666666666 * N[(th * kx), $MachinePrecision]), $MachinePrecision] + N[(kx / th), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 17: 13.5% accurate, 141.8× speedup

Math

\[\begin{array}{l} \\ ky \cdot \frac{th}{kx} \end{array} \]

FPCore

(FPCore (kx ky th) :precision binary64 (* ky (/ th kx)))

C

double code(double kx, double ky, double th) {
	return ky * (th / kx);
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = ky * (th / kx)
end function

Java

public static double code(double kx, double ky, double th) {
	return ky * (th / kx);
}

Python

def code(kx, ky, th):
	return ky * (th / kx)

Julia

function code(kx, ky, th)
	return Float64(ky * Float64(th / kx))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = ky * (th / kx);
end

Wolfram

code[kx_, ky_, th_] := N[(ky * N[(th / kx), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 18: 13.5% accurate, 141.8× speedup

Math

\[\begin{array}{l} \\ th \cdot \frac{ky}{kx} \end{array} \]

FPCore

(FPCore (kx ky th) :precision binary64 (* th (/ ky kx)))

C

double code(double kx, double ky, double th) {
	return th * (ky / kx);
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = th * (ky / kx)
end function

Java

public static double code(double kx, double ky, double th) {
	return th * (ky / kx);
}

Python

def code(kx, ky, th):
	return th * (ky / kx)

Julia

function code(kx, ky, th)
	return Float64(th * Float64(ky / kx))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = th * (ky / kx);
end

Wolfram

code[kx_, ky_, th_] := N[(th * N[(ky / kx), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 19: 13.5% accurate, 141.8× speedup

Math

\[\begin{array}{l} \\ \frac{ky}{\frac{kx}{th}} \end{array} \]

FPCore

(FPCore (kx ky th) :precision binary64 (/ ky (/ kx th)))

C

double code(double kx, double ky, double th) {
	return ky / (kx / th);
}

Fortran

real(8) function code(kx, ky, th)
    real(8), intent (in) :: kx
    real(8), intent (in) :: ky
    real(8), intent (in) :: th
    code = ky / (kx / th)
end function

Java

public static double code(double kx, double ky, double th) {
	return ky / (kx / th);
}

Python

def code(kx, ky, th):
	return ky / (kx / th)

Julia

function code(kx, ky, th)
	return Float64(ky / Float64(kx / th))
end

MATLAB

function tmp = code(kx, ky, th)
	tmp = ky / (kx / th);
end

Wolfram

code[kx_, ky_, th_] := N[(ky / N[(kx / th), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2024008 
(FPCore (kx ky th)
  :name "Toniolo and Linder, Equation (3b), real"
  :precision binary64
  (* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))