Toniolo and Linder, Equation (3b), real

Percentage Accurate: 93.7% → 99.7%

Time: 15.4s

Alternatives: 13

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.7% 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: 73.1% accurate, 1.2× speedup

Math

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

FPCore

(FPCore (kx ky th)
 :precision binary64
 (let* ((t_1 (/ 1.0 (hypot (sin kx) (sin ky)))))
   (if (<= (sin ky) -0.02)
     (* t_1 (* (sin ky) th))
     (if (<= (sin ky) 1e-5) (* t_1 (* ky (sin th))) (sin th)))))

C

double code(double kx, double ky, double th) {
	double t_1 = 1.0 / hypot(sin(kx), sin(ky));
	double tmp;
	if (sin(ky) <= -0.02) {
		tmp = t_1 * (sin(ky) * th);
	} else if (sin(ky) <= 1e-5) {
		tmp = t_1 * (ky * sin(th));
	} else {
		tmp = sin(th);
	}
	return tmp;
}

Java

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

Python

def code(kx, ky, th):
	t_1 = 1.0 / math.hypot(math.sin(kx), math.sin(ky))
	tmp = 0
	if math.sin(ky) <= -0.02:
		tmp = t_1 * (math.sin(ky) * th)
	elif math.sin(ky) <= 1e-5:
		tmp = t_1 * (ky * math.sin(th))
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	t_1 = Float64(1.0 / hypot(sin(kx), sin(ky)))
	tmp = 0.0
	if (sin(ky) <= -0.02)
		tmp = Float64(t_1 * Float64(sin(ky) * th));
	elseif (sin(ky) <= 1e-5)
		tmp = Float64(t_1 * Float64(ky * sin(th)));
	else
		tmp = sin(th);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	t_1 = 1.0 / hypot(sin(kx), sin(ky));
	tmp = 0.0;
	if (sin(ky) <= -0.02)
		tmp = t_1 * (sin(ky) * th);
	elseif (sin(ky) <= 1e-5)
		tmp = t_1 * (ky * sin(th));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 3: 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 4: 31.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;kx \leq 1.35 \cdot 10^{-117}:\\ \;\;\;\;\sin th\\ \mathbf{elif}\;kx \leq 8.5 \cdot 10^{-60}:\\ \;\;\;\;\sin ky \cdot \frac{\sin th}{kx}\\ \mathbf{elif}\;kx \leq 1.05 \cdot 10^{-25}:\\ \;\;\;\;\sin th\\ \mathbf{else}:\\ \;\;\;\;\sin th \cdot \left|\frac{\sin ky}{\sin kx}\right|\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= kx 1.35e-117)
   (sin th)
   (if (<= kx 8.5e-60)
     (* (sin ky) (/ (sin th) kx))
     (if (<= kx 1.05e-25)
       (sin th)
       (* (sin th) (fabs (/ (sin ky) (sin kx))))))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (kx <= 1.35e-117) {
		tmp = sin(th);
	} else if (kx <= 8.5e-60) {
		tmp = sin(ky) * (sin(th) / kx);
	} else if (kx <= 1.05e-25) {
		tmp = sin(th);
	} else {
		tmp = sin(th) * fabs((sin(ky) / sin(kx)));
	}
	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 (kx <= 1.35d-117) then
        tmp = sin(th)
    else if (kx <= 8.5d-60) then
        tmp = sin(ky) * (sin(th) / kx)
    else if (kx <= 1.05d-25) then
        tmp = sin(th)
    else
        tmp = sin(th) * abs((sin(ky) / sin(kx)))
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (kx <= 1.35e-117) {
		tmp = Math.sin(th);
	} else if (kx <= 8.5e-60) {
		tmp = Math.sin(ky) * (Math.sin(th) / kx);
	} else if (kx <= 1.05e-25) {
		tmp = Math.sin(th);
	} else {
		tmp = Math.sin(th) * Math.abs((Math.sin(ky) / Math.sin(kx)));
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if kx <= 1.35e-117:
		tmp = math.sin(th)
	elif kx <= 8.5e-60:
		tmp = math.sin(ky) * (math.sin(th) / kx)
	elif kx <= 1.05e-25:
		tmp = math.sin(th)
	else:
		tmp = math.sin(th) * math.fabs((math.sin(ky) / math.sin(kx)))
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (kx <= 1.35e-117)
		tmp = sin(th);
	elseif (kx <= 8.5e-60)
		tmp = Float64(sin(ky) * Float64(sin(th) / kx));
	elseif (kx <= 1.05e-25)
		tmp = sin(th);
	else
		tmp = Float64(sin(th) * abs(Float64(sin(ky) / sin(kx))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (kx <= 1.35e-117)
		tmp = sin(th);
	elseif (kx <= 8.5e-60)
		tmp = sin(ky) * (sin(th) / kx);
	elseif (kx <= 1.05e-25)
		tmp = sin(th);
	else
		tmp = sin(th) * abs((sin(ky) / sin(kx)));
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[kx, 1.35e-117], N[Sin[th], $MachinePrecision], If[LessEqual[kx, 8.5e-60], N[(N[Sin[ky], $MachinePrecision] * N[(N[Sin[th], $MachinePrecision] / kx), $MachinePrecision]), $MachinePrecision], If[LessEqual[kx, 1.05e-25], N[Sin[th], $MachinePrecision], N[(N[Sin[th], $MachinePrecision] * N[Abs[N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 5: 54.0% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 6: 40.2% accurate, 2.3× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[ky], $MachinePrecision], 4e-101], N[(N[Sin[th], $MachinePrecision] / N[(N[(0.5 * N[(ky / 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 7: 31.7% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq 5.8 \cdot 10^{-50}:\\ \;\;\;\;\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 5.8e-50) (* (sin th) (fabs (/ ky (sin kx)))) (sin th)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 5.8e-50) {
		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 <= 5.8d-50) 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 <= 5.8e-50) {
		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 <= 5.8e-50:
		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 <= 5.8e-50)
		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 <= 5.8e-50)
		tmp = sin(th) * abs((ky / sin(kx)));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 5.8e-50], 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 6.5 \cdot 10^{-100}:\\ \;\;\;\;\sin th \cdot \frac{ky}{\sin kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

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

C

double code(double kx, double ky, double th) {
	double tmp;
	if (ky <= 6.5e-100) {
		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 <= 6.5d-100) 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 <= 6.5e-100) {
		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 <= 6.5e-100:
		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 <= 6.5e-100)
		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 <= 6.5e-100)
		tmp = sin(th) * (ky / sin(kx));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, 6.5e-100], 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: 32.5% accurate, 3.4× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 10: 26.7% accurate, 6.6× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

Wolfram

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

Derivation

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

Alternative 11: 24.0% accurate, 6.9× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= 1.4e-174)
		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.4e-174)
		tmp = ky / (kx / th);
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 12: 11.8% accurate, 141.8× speedup

Math

\[\begin{array}{l} \\ \frac{0}{kx \cdot 2} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 13: 13.0% 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 2023342 
(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)))