Toniolo and Linder, Equation (3b), real

Percentage Accurate: 93.6% → 99.7%

Time: 19.3s

Alternatives: 9

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.6% 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

1. Initial program 95.0%

   \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
2. Step-by-step derivation

   1. +-commutative 95.0%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

   2. unpow2 95.0%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

   3. unpow2 95.0%

      \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

   4. hypot-def 99.7%

      \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

3. Simplified 99.7%

   \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

4. Final simplification 99.7%

   \[\leadsto \frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th \]

Alternative 2: 56.4% accurate, 1.4× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (sin.f64 ky) < 1e-30

   1. Initial program 93.5%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. unpow2 93.5%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin kx \cdot \sin kx} + {\sin ky}^{2}}} \cdot \sin th \]

      2. sin-mult 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\frac{\cos \left(kx - kx\right) - \cos \left(kx + kx\right)}{2}} + {\sin ky}^{2}}} \cdot \sin th \]

   3. Applied egg-rr 80.3%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\frac{\cos \left(kx - kx\right) - \cos \left(kx + kx\right)}{2}} + {\sin ky}^{2}}} \cdot \sin th \]
   4. Step-by-step derivation

      1. div-sub 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\left(\frac{\cos \left(kx - kx\right)}{2} - \frac{\cos \left(kx + kx\right)}{2}\right)} + {\sin ky}^{2}}} \cdot \sin th \]

      2. +-inverses 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\frac{\cos \color{blue}{0}}{2} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      3. cos-0 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\frac{\color{blue}{1}}{2} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      4. metadata-eval 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\color{blue}{0.5} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      5. count-2 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(0.5 - \frac{\cos \color{blue}{\left(2 \cdot kx\right)}}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      6. *-commutative 80.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(0.5 - \frac{\cos \color{blue}{\left(kx \cdot 2\right)}}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

   5. Simplified 80.3%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\left(0.5 - \frac{\cos \left(kx \cdot 2\right)}{2}\right)} + {\sin ky}^{2}}} \cdot \sin th \]

   6. Taylor expanded in ky around 0 37.6%

      \[\leadsto \frac{\sin ky}{\color{blue}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}}} \cdot \sin th \]
   7. Step-by-step derivation

      1. sqr-sin-a 51.6%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      2. rem-sqrt-square 55.7%

         \[\leadsto \frac{\sin ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]

   8. Applied egg-rr 55.7%

      \[\leadsto \frac{\sin ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]

   if 1e-30 < (sin.f64 ky)

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 60.4%

      \[\leadsto \color{blue}{\sin th} \]
3. Recombined 2 regimes into one program.

4. Final simplification 56.9%

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

Alternative 3: 69.3% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if kx < 0.025000000000000001

   1. Initial program 93.5%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 93.5%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 93.5%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 93.5%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 71.3%

      \[\leadsto \frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \color{blue}{kx}\right)} \cdot \sin th \]

   if 0.025000000000000001 < kx

   1. Initial program 99.4%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. unpow2 99.4%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin kx \cdot \sin kx} + {\sin ky}^{2}}} \cdot \sin th \]

      2. sin-mult 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\frac{\cos \left(kx - kx\right) - \cos \left(kx + kx\right)}{2}} + {\sin ky}^{2}}} \cdot \sin th \]

   3. Applied egg-rr 99.3%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\frac{\cos \left(kx - kx\right) - \cos \left(kx + kx\right)}{2}} + {\sin ky}^{2}}} \cdot \sin th \]
   4. Step-by-step derivation

      1. div-sub 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\left(\frac{\cos \left(kx - kx\right)}{2} - \frac{\cos \left(kx + kx\right)}{2}\right)} + {\sin ky}^{2}}} \cdot \sin th \]

      2. +-inverses 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\frac{\cos \color{blue}{0}}{2} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      3. cos-0 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\frac{\color{blue}{1}}{2} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      4. metadata-eval 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(\color{blue}{0.5} - \frac{\cos \left(kx + kx\right)}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      5. count-2 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(0.5 - \frac{\cos \color{blue}{\left(2 \cdot kx\right)}}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

      6. *-commutative 99.3%

         \[\leadsto \frac{\sin ky}{\sqrt{\left(0.5 - \frac{\cos \color{blue}{\left(kx \cdot 2\right)}}{2}\right) + {\sin ky}^{2}}} \cdot \sin th \]

   5. Simplified 99.3%

      \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\left(0.5 - \frac{\cos \left(kx \cdot 2\right)}{2}\right)} + {\sin ky}^{2}}} \cdot \sin th \]

   6. Taylor expanded in ky around 0 59.9%

      \[\leadsto \frac{\sin ky}{\color{blue}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}}} \cdot \sin th \]
   7. Step-by-step derivation

      1. sqr-sin-a 60.1%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      2. rem-sqrt-square 60.1%

         \[\leadsto \frac{\sin ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]

   8. Applied egg-rr 60.1%

      \[\leadsto \frac{\sin ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]
3. Recombined 2 regimes into one program.

4. Final simplification 68.4%

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

Alternative 4: 54.0% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (sin.f64 ky) < 1e-30

   1. Initial program 93.5%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 30.4%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]
   3. Step-by-step derivation

      1. add-sqr-sqrt 25.1%

         \[\leadsto \frac{ky}{\color{blue}{\sqrt{\sin kx} \cdot \sqrt{\sin kx}}} \cdot \sin th \]

      2. sqrt-prod 48.4%

         \[\leadsto \frac{ky}{\color{blue}{\sqrt{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      3. rem-sqrt-square 52.4%

         \[\leadsto \frac{ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]

   4. Applied egg-rr 52.4%

      \[\leadsto \frac{ky}{\color{blue}{\left|\sin kx\right|}} \cdot \sin th \]

   if 1e-30 < (sin.f64 ky)

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 60.4%

      \[\leadsto \color{blue}{\sin th} \]
3. Recombined 2 regimes into one program.

4. Final simplification 54.4%

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

Alternative 5: 40.0% accurate, 2.3× speedup

Math

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

FPCore

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

C

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

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(ky) <= 2e-117:
		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 (sin(ky) <= 2e-117)
		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 (sin(ky) <= 2e-117)
		tmp = sin(th) * (ky / sin(kx));
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (sin.f64 ky) < 2.00000000000000006e-117

   1. Initial program 92.8%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 30.2%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

   if 2.00000000000000006e-117 < (sin.f64 ky)

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 56.5%

      \[\leadsto \color{blue}{\sin th} \]
3. Recombined 2 regimes into one program.

4. Final simplification 38.7%

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

Alternative 6: 33.8% accurate, 6.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq -0.95:\\ \;\;\;\;\sin th\\ \mathbf{elif}\;ky \leq -5.5 \cdot 10^{-117}:\\ \;\;\;\;\frac{ky}{\frac{\sin kx}{th}}\\ \mathbf{elif}\;ky \leq 2.3 \cdot 10^{-125}:\\ \;\;\;\;\sin th \cdot \frac{ky}{kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= ky -0.95)
   (sin th)
   (if (<= ky -5.5e-117)
     (/ ky (/ (sin kx) th))
     (if (<= ky 2.3e-125) (* (sin th) (/ ky kx)) (sin th)))))

C

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

Python

def code(kx, ky, th):
	tmp = 0
	if ky <= -0.95:
		tmp = math.sin(th)
	elif ky <= -5.5e-117:
		tmp = ky / (math.sin(kx) / th)
	elif ky <= 2.3e-125:
		tmp = math.sin(th) * (ky / kx)
	else:
		tmp = math.sin(th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (ky <= -0.95)
		tmp = sin(th);
	elseif (ky <= -5.5e-117)
		tmp = Float64(ky / Float64(sin(kx) / th));
	elseif (ky <= 2.3e-125)
		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 <= -0.95)
		tmp = sin(th);
	elseif (ky <= -5.5e-117)
		tmp = ky / (sin(kx) / th);
	elseif (ky <= 2.3e-125)
		tmp = sin(th) * (ky / kx);
	else
		tmp = sin(th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[ky, -0.95], N[Sin[th], $MachinePrecision], If[LessEqual[ky, -5.5e-117], N[(ky / N[(N[Sin[kx], $MachinePrecision] / th), $MachinePrecision]), $MachinePrecision], If[LessEqual[ky, 2.3e-125], N[(N[Sin[th], $MachinePrecision] * N[(ky / kx), $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if ky < -0.94999999999999996 or 2.2999999999999999e-125 < ky

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 32.8%

      \[\leadsto \color{blue}{\sin th} \]

   if -0.94999999999999996 < ky < -5.50000000000000025e-117

   1. Initial program 99.8%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 34.3%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

   3. Taylor expanded in th around 0 21.6%

      \[\leadsto \color{blue}{\frac{ky \cdot th}{\sin kx}} \]
   4. Step-by-step derivation

      1. associate-/l* 21.5%

         \[\leadsto \color{blue}{\frac{ky}{\frac{\sin kx}{th}}} \]

   5. Simplified 21.5%

      \[\leadsto \color{blue}{\frac{ky}{\frac{\sin kx}{th}}} \]

   if -5.50000000000000025e-117 < ky < 2.2999999999999999e-125

   1. Initial program 83.3%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 55.7%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

   3. Taylor expanded in kx around 0 35.7%

      \[\leadsto \color{blue}{\frac{ky}{kx}} \cdot \sin th \]
3. Recombined 3 regimes into one program.

4. Final simplification 32.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;ky \leq -0.95:\\ \;\;\;\;\sin th\\ \mathbf{elif}\;ky \leq -5.5 \cdot 10^{-117}:\\ \;\;\;\;\frac{ky}{\frac{\sin kx}{th}}\\ \mathbf{elif}\;ky \leq 2.3 \cdot 10^{-125}:\\ \;\;\;\;\sin th \cdot \frac{ky}{kx}\\ \mathbf{else}:\\ \;\;\;\;\sin th\\ \end{array} \]

Alternative 7: 33.3% accurate, 6.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq -0.95 \lor \neg \left(ky \leq 1.1 \cdot 10^{-123}\right):\\ \;\;\;\;\sin th\\ \mathbf{else}:\\ \;\;\;\;\sin th \cdot \frac{ky}{kx}\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (or (<= ky -0.95) (not (<= ky 1.1e-123)))
   (sin th)
   (* (sin th) (/ ky kx))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if ((ky <= -0.95) || !(ky <= 1.1e-123)) {
		tmp = sin(th);
	} else {
		tmp = sin(th) * (ky / 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 ((ky <= (-0.95d0)) .or. (.not. (ky <= 1.1d-123))) then
        tmp = sin(th)
    else
        tmp = sin(th) * (ky / kx)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if ((ky <= -0.95) || !(ky <= 1.1e-123)) {
		tmp = Math.sin(th);
	} else {
		tmp = Math.sin(th) * (ky / kx);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if (ky <= -0.95) or not (ky <= 1.1e-123):
		tmp = math.sin(th)
	else:
		tmp = math.sin(th) * (ky / kx)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if ((ky <= -0.95) || !(ky <= 1.1e-123))
		tmp = sin(th);
	else
		tmp = Float64(sin(th) * Float64(ky / kx));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if ((ky <= -0.95) || ~((ky <= 1.1e-123)))
		tmp = sin(th);
	else
		tmp = sin(th) * (ky / kx);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[Or[LessEqual[ky, -0.95], N[Not[LessEqual[ky, 1.1e-123]], $MachinePrecision]], N[Sin[th], $MachinePrecision], N[(N[Sin[th], $MachinePrecision] * N[(ky / kx), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if ky < -0.94999999999999996 or 1.10000000000000003e-123 < ky

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 32.8%

      \[\leadsto \color{blue}{\sin th} \]

   if -0.94999999999999996 < ky < 1.10000000000000003e-123

   1. Initial program 87.8%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 49.8%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

   3. Taylor expanded in kx around 0 28.9%

      \[\leadsto \color{blue}{\frac{ky}{kx}} \cdot \sin th \]
3. Recombined 2 regimes into one program.

4. Final simplification 31.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;ky \leq -0.95 \lor \neg \left(ky \leq 1.1 \cdot 10^{-123}\right):\\ \;\;\;\;\sin th\\ \mathbf{else}:\\ \;\;\;\;\sin th \cdot \frac{ky}{kx}\\ \end{array} \]

Alternative 8: 30.3% accurate, 6.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;ky \leq -0.95 \lor \neg \left(ky \leq 1.35 \cdot 10^{-126}\right):\\ \;\;\;\;\sin th\\ \mathbf{else}:\\ \;\;\;\;\frac{ky}{\frac{kx}{th}}\\ \end{array} \end{array} \]

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (or (<= ky -0.95) (not (<= ky 1.35e-126))) (sin th) (/ ky (/ kx th))))

C

double code(double kx, double ky, double th) {
	double tmp;
	if ((ky <= -0.95) || !(ky <= 1.35e-126)) {
		tmp = sin(th);
	} else {
		tmp = ky / (kx / 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 <= (-0.95d0)) .or. (.not. (ky <= 1.35d-126))) then
        tmp = sin(th)
    else
        tmp = ky / (kx / th)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if ((ky <= -0.95) || !(ky <= 1.35e-126)) {
		tmp = Math.sin(th);
	} else {
		tmp = ky / (kx / th);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if (ky <= -0.95) or not (ky <= 1.35e-126):
		tmp = math.sin(th)
	else:
		tmp = ky / (kx / th)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if ((ky <= -0.95) || !(ky <= 1.35e-126))
		tmp = sin(th);
	else
		tmp = Float64(ky / Float64(kx / th));
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if ((ky <= -0.95) || ~((ky <= 1.35e-126)))
		tmp = sin(th);
	else
		tmp = ky / (kx / th);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[Or[LessEqual[ky, -0.95], N[Not[LessEqual[ky, 1.35e-126]], $MachinePrecision]], N[Sin[th], $MachinePrecision], N[(ky / N[(kx / th), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if ky < -0.94999999999999996 or 1.34999999999999998e-126 < ky

   1. Initial program 99.7%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
   2. Step-by-step derivation

      1. +-commutative 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{{\sin ky}^{2} + {\sin kx}^{2}}}} \cdot \sin th \]

      2. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\color{blue}{\sin ky \cdot \sin ky} + {\sin kx}^{2}}} \cdot \sin th \]

      3. unpow2 99.7%

         \[\leadsto \frac{\sin ky}{\sqrt{\sin ky \cdot \sin ky + \color{blue}{\sin kx \cdot \sin kx}}} \cdot \sin th \]

      4. hypot-def 99.8%

         \[\leadsto \frac{\sin ky}{\color{blue}{\mathsf{hypot}\left(\sin ky, \sin kx\right)}} \cdot \sin th \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th} \]

   4. Taylor expanded in kx around 0 32.8%

      \[\leadsto \color{blue}{\sin th} \]

   if -0.94999999999999996 < ky < 1.34999999999999998e-126

   1. Initial program 87.8%

      \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

   2. Taylor expanded in ky around 0 49.8%

      \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

   3. Taylor expanded in kx around 0 28.9%

      \[\leadsto \color{blue}{\frac{ky}{kx}} \cdot \sin th \]

   4. Taylor expanded in th around 0 17.4%

      \[\leadsto \color{blue}{\frac{ky \cdot th}{kx}} \]
   5. Step-by-step derivation

      1. associate-/l* 20.7%

         \[\leadsto \color{blue}{\frac{ky}{\frac{kx}{th}}} \]

   6. Simplified 20.7%

      \[\leadsto \color{blue}{\frac{ky}{\frac{kx}{th}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 28.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;ky \leq -0.95 \lor \neg \left(ky \leq 1.35 \cdot 10^{-126}\right):\\ \;\;\;\;\sin th\\ \mathbf{else}:\\ \;\;\;\;\frac{ky}{\frac{kx}{th}}\\ \end{array} \]

Alternative 9: 13.4% 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

1. Initial program 95.0%

   \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]

2. Taylor expanded in ky around 0 23.6%

   \[\leadsto \color{blue}{\frac{ky}{\sin kx}} \cdot \sin th \]

3. Taylor expanded in kx around 0 14.2%

   \[\leadsto \color{blue}{\frac{ky}{kx}} \cdot \sin th \]

4. Taylor expanded in th around 0 8.9%

   \[\leadsto \color{blue}{\frac{ky \cdot th}{kx}} \]
5. Step-by-step derivation

   1. associate-/l* 10.3%

      \[\leadsto \color{blue}{\frac{ky}{\frac{kx}{th}}} \]

6. Simplified 10.3%

   \[\leadsto \color{blue}{\frac{ky}{\frac{kx}{th}}} \]

7. Final simplification 10.3%

   \[\leadsto \frac{ky}{\frac{kx}{th}} \]

Reproduce

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