Toniolo and Linder, Equation (3b), real

Percentage Accurate: 93.8% → 99.7%

Time: 14.5s

Alternatives: 12

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: 93.8% 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 ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th \end{array} \]

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 2: 55.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \mathsf{hypot}\left(\sin kx, \sin ky\right)\\ \mathbf{if}\;\sin ky \leq -0.005:\\ \;\;\;\;\sin ky \cdot \frac{th}{t_1}\\ \mathbf{elif}\;\sin ky \leq 5 \cdot 10^{-202}:\\ \;\;\;\;\sin th \cdot \left|\frac{ky}{\sin kx}\right|\\ \mathbf{elif}\;\sin ky \leq 0.001:\\ \;\;\;\;\frac{ky \cdot \sin th}{t_1}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (let* ((t_1 (hypot (sin kx) (sin ky))))
   (if (<= (sin ky) -0.005)
     (* (sin ky) (/ th t_1))
     (if (<= (sin ky) 5e-202)
       (* (sin th) (fabs (/ ky (sin kx))))
       (if (<= (sin ky) 0.001) (/ (* ky (sin th)) t_1) (sin th))))))

C

double code(double kx, double ky, double th) {
	double t_1 = hypot(sin(kx), sin(ky));
	double tmp;
	if (sin(ky) <= -0.005) {
		tmp = sin(ky) * (th / t_1);
	} else if (sin(ky) <= 5e-202) {
		tmp = sin(th) * fabs((ky / sin(kx)));
	} else if (sin(ky) <= 0.001) {
		tmp = (ky * sin(th)) / t_1;
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double t_1 = Math.hypot(Math.sin(kx), Math.sin(ky));
	double tmp;
	if (Math.sin(ky) <= -0.005) {
		tmp = Math.sin(ky) * (th / t_1);
	} else if (Math.sin(ky) <= 5e-202) {
		tmp = Math.sin(th) * Math.abs((ky / Math.sin(kx)));
	} else if (Math.sin(ky) <= 0.001) {
		tmp = (ky * Math.sin(th)) / t_1;
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	t_1 = math.hypot(math.sin(kx), math.sin(ky))
	tmp = 0
	if math.sin(ky) <= -0.005:
		tmp = math.sin(ky) * (th / t_1)
	elif math.sin(ky) <= 5e-202:
		tmp = math.sin(th) * math.fabs((ky / math.sin(kx)))
	elif math.sin(ky) <= 0.001:
		tmp = (ky * math.sin(th)) / t_1
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	t_1 = hypot(sin(kx), sin(ky))
	tmp = 0.0
	if (sin(ky) <= -0.005)
		tmp = Float64(sin(ky) * Float64(th / t_1));
	elseif (sin(ky) <= 5e-202)
		tmp = Float64(sin(th) * abs(Float64(ky / sin(kx))));
	elseif (sin(ky) <= 0.001)
		tmp = Float64(Float64(ky * sin(th)) / t_1);
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	t_1 = hypot(sin(kx), sin(ky));
	tmp = 0.0;
	if (sin(ky) <= -0.005)
		tmp = sin(ky) * (th / t_1);
	elseif (sin(ky) <= 5e-202)
		tmp = sin(th) * abs((ky / sin(kx)));
	elseif (sin(ky) <= 0.001)
		tmp = (ky * sin(th)) / t_1;
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := Block[{t$95$1 = N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[N[Sin[ky], $MachinePrecision], -0.005], N[(N[Sin[ky], $MachinePrecision] * N[(th / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[ky], $MachinePrecision], 5e-202], N[(N[Sin[th], $MachinePrecision] * N[Abs[N[(ky / N[Sin[kx], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[ky], $MachinePrecision], 0.001], N[(N[(ky * N[Sin[th], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[Sin[th], $MachinePrecision]]]]]

Derivation

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

Alternative 3: 55.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \mathsf{hypot}\left(\sin kx, \sin ky\right)\\ \mathbf{if}\;\sin ky \leq -0.005:\\ \;\;\;\;\frac{\sin ky}{t_1 \cdot \left(\frac{1}{th} + th \cdot 0.16666666666666666\right)}\\ \mathbf{elif}\;\sin ky \leq 5 \cdot 10^{-202}:\\ \;\;\;\;\sin th \cdot \left|\frac{ky}{\sin kx}\right|\\ \mathbf{elif}\;\sin ky \leq 0.001:\\ \;\;\;\;\frac{ky \cdot \sin th}{t_1}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (let* ((t_1 (hypot (sin kx) (sin ky))))
   (if (<= (sin ky) -0.005)
     (/ (sin ky) (* t_1 (+ (/ 1.0 th) (* th 0.16666666666666666))))
     (if (<= (sin ky) 5e-202)
       (* (sin th) (fabs (/ ky (sin kx))))
       (if (<= (sin ky) 0.001) (/ (* ky (sin th)) t_1) (sin th))))))

C

double code(double kx, double ky, double th) {
	double t_1 = hypot(sin(kx), sin(ky));
	double tmp;
	if (sin(ky) <= -0.005) {
		tmp = sin(ky) / (t_1 * ((1.0 / th) + (th * 0.16666666666666666)));
	} else if (sin(ky) <= 5e-202) {
		tmp = sin(th) * fabs((ky / sin(kx)));
	} else if (sin(ky) <= 0.001) {
		tmp = (ky * sin(th)) / t_1;
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Java

public static double code(double kx, double ky, double th) {
	double t_1 = Math.hypot(Math.sin(kx), Math.sin(ky));
	double tmp;
	if (Math.sin(ky) <= -0.005) {
		tmp = Math.sin(ky) / (t_1 * ((1.0 / th) + (th * 0.16666666666666666)));
	} else if (Math.sin(ky) <= 5e-202) {
		tmp = Math.sin(th) * Math.abs((ky / Math.sin(kx)));
	} else if (Math.sin(ky) <= 0.001) {
		tmp = (ky * Math.sin(th)) / t_1;
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	t_1 = math.hypot(math.sin(kx), math.sin(ky))
	tmp = 0
	if math.sin(ky) <= -0.005:
		tmp = math.sin(ky) / (t_1 * ((1.0 / th) + (th * 0.16666666666666666)))
	elif math.sin(ky) <= 5e-202:
		tmp = math.sin(th) * math.fabs((ky / math.sin(kx)))
	elif math.sin(ky) <= 0.001:
		tmp = (ky * math.sin(th)) / t_1
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	t_1 = hypot(sin(kx), sin(ky))
	tmp = 0.0
	if (sin(ky) <= -0.005)
		tmp = Float64(sin(ky) / Float64(t_1 * Float64(Float64(1.0 / th) + Float64(th * 0.16666666666666666))));
	elseif (sin(ky) <= 5e-202)
		tmp = Float64(sin(th) * abs(Float64(ky / sin(kx))));
	elseif (sin(ky) <= 0.001)
		tmp = Float64(Float64(ky * sin(th)) / t_1);
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	t_1 = hypot(sin(kx), sin(ky));
	tmp = 0.0;
	if (sin(ky) <= -0.005)
		tmp = sin(ky) / (t_1 * ((1.0 / th) + (th * 0.16666666666666666)));
	elseif (sin(ky) <= 5e-202)
		tmp = sin(th) * abs((ky / sin(kx)));
	elseif (sin(ky) <= 0.001)
		tmp = (ky * sin(th)) / t_1;
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := Block[{t$95$1 = N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[N[Sin[ky], $MachinePrecision], -0.005], N[(N[Sin[ky], $MachinePrecision] / N[(t$95$1 * N[(N[(1.0 / th), $MachinePrecision] + N[(th * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[ky], $MachinePrecision], 5e-202], N[(N[Sin[th], $MachinePrecision] * N[Abs[N[(ky / N[Sin[kx], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[ky], $MachinePrecision], 0.001], N[(N[(ky * N[Sin[th], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[Sin[th], $MachinePrecision]]]]]

Derivation

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

Alternative 4: 51.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq -0.005:\\ \;\;\;\;th \cdot \frac{\sin ky}{\mathsf{hypot}\left(\sin kx, \sin ky\right)}\\ \mathbf{elif}\;\sin ky \leq 2 \cdot 10^{-43}:\\ \;\;\;\;\sin th \cdot \left|\frac{ky}{\sin kx}\right|\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) -0.005)
   (* th (/ (sin ky) (hypot (sin kx) (sin ky))))
   (if (<= (sin ky) 2e-43) (* (sin th) (fabs (/ ky (sin kx)))) (sin th))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= -0.005) {
		tmp = th * (sin(ky) / hypot(sin(kx), sin(ky)));
	} else if (sin(ky) <= 2e-43) {
		tmp = sin(th) * fabs((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.005) {
		tmp = th * (Math.sin(ky) / Math.hypot(Math.sin(kx), Math.sin(ky)));
	} else if (Math.sin(ky) <= 2e-43) {
		tmp = Math.sin(th) * Math.abs((ky / Math.sin(kx)));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= -0.005:
		tmp = th * (math.sin(ky) / math.hypot(math.sin(kx), math.sin(ky)))
	elif math.sin(ky) <= 2e-43:
		tmp = math.sin(th) * math.fabs((ky / math.sin(kx)))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= -0.005)
		tmp = Float64(th * Float64(sin(ky) / hypot(sin(kx), sin(ky))));
	elseif (sin(ky) <= 2e-43)
		tmp = Float64(sin(th) * abs(Float64(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.005)
		tmp = th * (sin(ky) / hypot(sin(kx), sin(ky)));
	elseif (sin(ky) <= 2e-43)
		tmp = sin(th) * abs((ky / sin(kx)));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 5: 51.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\sin ky \leq -0.005:\\ \;\;\;\;\sin ky \cdot \frac{th}{\mathsf{hypot}\left(\sin kx, \sin ky\right)}\\ \mathbf{elif}\;\sin ky \leq 2 \cdot 10^{-43}:\\ \;\;\;\;\sin th \cdot \left|\frac{ky}{\sin kx}\right|\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin ky) -0.005)
   (* (sin ky) (/ th (hypot (sin kx) (sin ky))))
   (if (<= (sin ky) 2e-43) (* (sin th) (fabs (/ ky (sin kx)))) (sin th))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(ky) <= -0.005) {
		tmp = sin(ky) * (th / hypot(sin(kx), sin(ky)));
	} else if (sin(ky) <= 2e-43) {
		tmp = sin(th) * fabs((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.005) {
		tmp = Math.sin(ky) * (th / Math.hypot(Math.sin(kx), Math.sin(ky)));
	} else if (Math.sin(ky) <= 2e-43) {
		tmp = Math.sin(th) * Math.abs((ky / Math.sin(kx)));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= -0.005:
		tmp = math.sin(ky) * (th / math.hypot(math.sin(kx), math.sin(ky)))
	elif math.sin(ky) <= 2e-43:
		tmp = math.sin(th) * math.fabs((ky / math.sin(kx)))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(ky) <= -0.005)
		tmp = Float64(sin(ky) * Float64(th / hypot(sin(kx), sin(ky))));
	elseif (sin(ky) <= 2e-43)
		tmp = Float64(sin(th) * abs(Float64(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.005)
		tmp = sin(ky) * (th / hypot(sin(kx), sin(ky)));
	elseif (sin(ky) <= 2e-43)
		tmp = sin(th) * abs((ky / sin(kx)));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 6: 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 7: 31.9% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 9.5 \cdot 10^{-41}:\\ \;\;\;\;\sin th \cdot \left|\frac{ky}{\sin kx}\right|\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 9.5e-41) (* (sin th) (fabs (/ ky (sin kx)))) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 9.5e-41) {
		tmp = sin(th) * fabs((ky / 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 <= 9.5d-41) then
        tmp = sin(th) * abs((ky / 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 <= 9.5e-41) {
		tmp = Math.sin(th) * Math.abs((ky / Math.sin(kx)));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 8: 32.4% accurate, 3.4× speedup

Math

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

FPCore

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

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 7e-95) {
		tmp = sin(th) * (ky / 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 <= 7d-95) then
        tmp = sin(th) * (ky / 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 <= 7e-95) {
		tmp = Math.sin(th) * (ky / Math.sin(kx));
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 9: 25.9% accurate, 6.6× speedup

Math

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

FPCore

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

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 8e-172) {
		tmp = sin(th) * (ky / 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 <= 8d-172) then
        tmp = sin(th) * (ky / 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 <= 8e-172) {
		tmp = Math.sin(th) * (ky / kx);
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 10: 23.6% accurate, 6.9× speedup

Math

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

FPCore

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

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.75e-186) {
		tmp = ky / (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-186) then
        tmp = ky / (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-186) {
		tmp = ky / (kx / th);
	} else {
		tmp = Math.sin(th);
	}
	return tmp;
}

Python

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

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 1.75e-186)
		tmp = Float64(ky / 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-186)
		tmp = ky / (kx / th);
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 11: 18.2% accurate, 100.4× speedup

Math

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

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky 1.05e-93) (/ ky (/ kx th)) th))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.05e-93) {
		tmp = ky / (kx / th);
	} else {
		tmp = 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.05d-93) then
        tmp = ky / (kx / th)
    else
        tmp = th
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 1.05e-93) {
		tmp = ky / (kx / th);
	} else {
		tmp = th;
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= 1.05e-93:
		tmp = ky / (kx / th)
	else:
		tmp = th
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 12: 13.7% accurate, 709.0× speedup

Math

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

FPCore

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

C

double code(double kx, double ky, double th) {
	return 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 = th
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[kx_, ky_, th_] := th

Derivation

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

Reproduce

herbie shell --seed 2023343 
(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)))