Toniolo and Linder, Equation (3b), real

Percentage Accurate: 94.3% → 94.3%

Time: 2.9s

Alternatives: 5

Speedup: 1.0×

Specification

\[\mathsf{TRUE}\left(\right)\]

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.3% 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: 94.3% 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]

Derivation

1. Initial program 92.7%

   \[\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 13.9% accurate, 2.1× speedup

Math

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

FPCore

(FPCore (kx ky th)
 :precision binary64
 (if (<= (sin th) 1.15e-50) (pow (sin ky) 2.0) (sin ky)))

C

double code(double kx, double ky, double th) {
	double tmp;
	if (sin(th) <= 1.15e-50) {
		tmp = pow(sin(ky), 2.0);
	} else {
		tmp = sin(ky);
	}
	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(th) <= 1.15d-50) then
        tmp = sin(ky) ** 2.0d0
    else
        tmp = sin(ky)
    end if
    code = tmp
end function

Java

public static double code(double kx, double ky, double th) {
	double tmp;
	if (Math.sin(th) <= 1.15e-50) {
		tmp = Math.pow(Math.sin(ky), 2.0);
	} else {
		tmp = Math.sin(ky);
	}
	return tmp;
}

Python

def code(kx, ky, th):
	tmp = 0
	if math.sin(th) <= 1.15e-50:
		tmp = math.pow(math.sin(ky), 2.0)
	else:
		tmp = math.sin(ky)
	return tmp

Julia

function code(kx, ky, th)
	tmp = 0.0
	if (sin(th) <= 1.15e-50)
		tmp = sin(ky) ^ 2.0;
	else
		tmp = sin(ky);
	end
	return tmp
end

MATLAB

function tmp_2 = code(kx, ky, th)
	tmp = 0.0;
	if (sin(th) <= 1.15e-50)
		tmp = sin(ky) ^ 2.0;
	else
		tmp = sin(ky);
	end
	tmp_2 = tmp;
end

Wolfram

code[kx_, ky_, th_] := If[LessEqual[N[Sin[th], $MachinePrecision], 1.15e-50], N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision], N[Sin[ky], $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (sin.f64 th) < 1.1500000000000001e-50

   1. Initial program 94.2%

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

   3. Taylor expanded in kx around 0

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

   5. Applied rewrites 19.0%

      \[\leadsto \color{blue}{{\sin ky}^{2}} \cdot \sin th \]

   6. Taylor expanded in kx around 0

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

   8. Applied rewrites 13.2%

      \[\leadsto \color{blue}{{\sin ky}^{2}} \]

   if 1.1500000000000001e-50 < (sin.f64 th)

   1. Initial program 88.7%

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

   3. Taylor expanded in kx around 0

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

   5. Applied rewrites 14.2%

      \[\leadsto \color{blue}{\sin ky} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 24.1% accurate, 3.1× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 92.7%

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

3. Taylor expanded in kx around 0

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

5. Applied rewrites 16.1%

   \[\leadsto \color{blue}{{\sin ky}^{2}} \cdot \sin th \]

6. Taylor expanded in kx around 0

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

8. Applied rewrites 23.8%

   \[\leadsto \color{blue}{\sin ky} \cdot \sin th \]
9. Add Preprocessing

Alternative 4: 7.2% accurate, 6.3× speedup

Math

\[\begin{array}{l} \\ \sin ky \end{array} \]

FPCore

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

C

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

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)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[kx_, ky_, th_] := N[Sin[ky], $MachinePrecision]

Derivation

1. Initial program 92.7%

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

3. Taylor expanded in kx around 0

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

5. Applied rewrites 6.6%

   \[\leadsto \color{blue}{\sin ky} \]
6. Add Preprocessing

Alternative 5: 4.8% accurate, 6.3× speedup

Math

\[\begin{array}{l} \\ \sin kx \end{array} \]

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[kx_, ky_, th_] := N[Sin[kx], $MachinePrecision]

Derivation

1. Initial program 92.7%

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

3. Taylor expanded in kx around 0

   \[\leadsto \color{blue}{\sin th + {kx}^{2} \cdot \left(\frac{-1}{2} \cdot \frac{\sin th}{{\sin ky}^{2}} + {kx}^{2} \cdot \left(\frac{-1}{2} \cdot \left({kx}^{2} \cdot \left({\sin ky}^{2} \cdot \left(\sin th \cdot \left(\frac{-1}{2} \cdot \frac{\frac{1}{3} \cdot \frac{1}{{\sin ky}^{4}} + \frac{3}{4} \cdot \frac{1}{{\sin ky}^{6}}}{{\sin ky}^{2}} + \left(\frac{2}{45} \cdot \frac{1}{{\sin ky}^{4}} + \left(\frac{2}{3} \cdot \frac{1}{{\sin ky}^{6}} + \frac{1}{{\sin ky}^{8}}\right)\right)\right)\right)\right)\right) + \frac{1}{2} \cdot \left({\sin ky}^{2} \cdot \left(\sin th \cdot \left(\frac{1}{3} \cdot \frac{1}{{\sin ky}^{4}} + \frac{3}{4} \cdot \frac{1}{{\sin ky}^{6}}\right)\right)\right)\right)\right)} \]

5. Applied rewrites 5.4%

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

6. Taylor expanded in kx around 0

   \[\leadsto \sqrt{{kx}^{2} + {\sin ky}^{2}} \]

8. Applied rewrites 3.6%

   \[\leadsto \sqrt{\sin kx + {\sin ky}^{2}} \]

9. Taylor expanded in kx around 0

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

11. Applied rewrites 4.6%

    \[\leadsto \sin kx \]
12. Add Preprocessing

Reproduce

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