Linear.Quaternion:$ccos from linear-1.19.1.3

Percentage Accurate: 100.0% → 100.0%

Time: 3.1s

Alternatives: 3

Speedup: 1.0×

• 49.7% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \sin x \cdot \frac{\sinh y}{y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* (sin x) (/ (sinh y) y)))

C

double code(double x, double y) {
	return sin(x) * (sinh(y) / y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = sin(x) * (sinh(y) / y)
end function

Java

public static double code(double x, double y) {
	return Math.sin(x) * (Math.sinh(y) / y);
}

Python

def code(x, y):
	return math.sin(x) * (math.sinh(y) / y)

Julia

function code(x, y)
	return Float64(sin(x) * Float64(sinh(y) / y))
end

MATLAB

function tmp = code(x, y)
	tmp = sin(x) * (sinh(y) / y);
end

Wolfram

code[x_, y_] := N[(N[Sin[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \sin x \cdot \frac{\sinh y}{y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* (sin x) (/ (sinh y) y)))

C

double code(double x, double y) {
	return sin(x) * (sinh(y) / y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = sin(x) * (sinh(y) / y)
end function

Java

public static double code(double x, double y) {
	return Math.sin(x) * (Math.sinh(y) / y);
}

Python

def code(x, y):
	return math.sin(x) * (math.sinh(y) / y)

Julia

function code(x, y)
	return Float64(sin(x) * Float64(sinh(y) / y))
end

MATLAB

function tmp = code(x, y)
	tmp = sin(x) * (sinh(y) / y);
end

Wolfram

code[x_, y_] := N[(N[Sin[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \sin x \cdot \frac{0.5}{\frac{y}{2 \cdot \sinh y}} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* (sin x) (/ 0.5 (/ y (* 2.0 (sinh y))))))

C

double code(double x, double y) {
	return sin(x) * (0.5 / (y / (2.0 * sinh(y))));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = sin(x) * (0.5d0 / (y / (2.0d0 * sinh(y))))
end function

Java

public static double code(double x, double y) {
	return Math.sin(x) * (0.5 / (y / (2.0 * Math.sinh(y))));
}

Python

def code(x, y):
	return math.sin(x) * (0.5 / (y / (2.0 * math.sinh(y))))

Julia

function code(x, y)
	return Float64(sin(x) * Float64(0.5 / Float64(y / Float64(2.0 * sinh(y)))))
end

MATLAB

function tmp = code(x, y)
	tmp = sin(x) * (0.5 / (y / (2.0 * sinh(y))));
end

Wolfram

code[x_, y_] := N[(N[Sin[x], $MachinePrecision] * N[(0.5 / N[(y / N[(2.0 * N[Sinh[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\sin x \cdot \frac{\sinh y}{y} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. clear-num 100.0%

      \[\leadsto \sin x \cdot \color{blue}{\frac{1}{\frac{y}{\sinh y}}} \]

   2. inv-pow 100.0%

      \[\leadsto \sin x \cdot \color{blue}{{\left(\frac{y}{\sinh y}\right)}^{-1}} \]

   3. sinh-def 50.1%

      \[\leadsto \sin x \cdot {\left(\frac{y}{\color{blue}{\frac{e^{y} - e^{-y}}{2}}}\right)}^{-1} \]

   4. associate-/r/ 50.1%

      \[\leadsto \sin x \cdot {\color{blue}{\left(\frac{y}{e^{y} - e^{-y}} \cdot 2\right)}}^{-1} \]

   5. unpow-prod-down 50.1%

      \[\leadsto \sin x \cdot \color{blue}{\left({\left(\frac{y}{e^{y} - e^{-y}}\right)}^{-1} \cdot {2}^{-1}\right)} \]

   6. sinh-undef 100.0%

      \[\leadsto \sin x \cdot \left({\left(\frac{y}{\color{blue}{2 \cdot \sinh y}}\right)}^{-1} \cdot {2}^{-1}\right) \]

   7. metadata-eval 100.0%

      \[\leadsto \sin x \cdot \left({\left(\frac{y}{2 \cdot \sinh y}\right)}^{-1} \cdot \color{blue}{0.5}\right) \]

4. Applied egg-rr 100.0%

   \[\leadsto \sin x \cdot \color{blue}{\left({\left(\frac{y}{2 \cdot \sinh y}\right)}^{-1} \cdot 0.5\right)} \]
5. Step-by-step derivation

   1. unpow-1 100.0%

      \[\leadsto \sin x \cdot \left(\color{blue}{\frac{1}{\frac{y}{2 \cdot \sinh y}}} \cdot 0.5\right) \]

   2. associate-*l/ 100.0%

      \[\leadsto \sin x \cdot \color{blue}{\frac{1 \cdot 0.5}{\frac{y}{2 \cdot \sinh y}}} \]

   3. metadata-eval 100.0%

      \[\leadsto \sin x \cdot \frac{\color{blue}{0.5}}{\frac{y}{2 \cdot \sinh y}} \]

6. Simplified 100.0%

   \[\leadsto \sin x \cdot \color{blue}{\frac{0.5}{\frac{y}{2 \cdot \sinh y}}} \]

7. Final simplification 100.0%

   \[\leadsto \sin x \cdot \frac{0.5}{\frac{y}{2 \cdot \sinh y}} \]
8. Add Preprocessing

Alternative 2: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \sin x \cdot \frac{\sinh y}{y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* (sin x) (/ (sinh y) y)))

C

double code(double x, double y) {
	return sin(x) * (sinh(y) / y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = sin(x) * (sinh(y) / y)
end function

Java

public static double code(double x, double y) {
	return Math.sin(x) * (Math.sinh(y) / y);
}

Python

def code(x, y):
	return math.sin(x) * (math.sinh(y) / y)

Julia

function code(x, y)
	return Float64(sin(x) * Float64(sinh(y) / y))
end

MATLAB

function tmp = code(x, y)
	tmp = sin(x) * (sinh(y) / y);
end

Wolfram

code[x_, y_] := N[(N[Sin[x], $MachinePrecision] * N[(N[Sinh[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\sin x \cdot \frac{\sinh y}{y} \]
2. Add Preprocessing

3. Final simplification 100.0%

   \[\leadsto \sin x \cdot \frac{\sinh y}{y} \]
4. Add Preprocessing

Alternative 3: 50.7% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (sin x))

C

double code(double x, double y) {
	return sin(x);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = sin(x)
end function

Java

public static double code(double x, double y) {
	return Math.sin(x);
}

Python

def code(x, y):
	return math.sin(x)

Julia

function code(x, y)
	return sin(x)
end

MATLAB

function tmp = code(x, y)
	tmp = sin(x);
end

Wolfram

code[x_, y_] := N[Sin[x], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\sin x \cdot \frac{\sinh y}{y} \]
2. Add Preprocessing

3. Taylor expanded in y around 0 54.1%

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

4. Final simplification 54.1%

   \[\leadsto \sin x \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024020 
(FPCore (x y)
  :name "Linear.Quaternion:$ccos from linear-1.19.1.3"
  :precision binary64
  (* (sin x) (/ (sinh y) y)))