Graphics.Rasterific.Svg.PathConverter:segmentToBezier from rasterific-svg-0.2.3.1, A

Percentage Accurate: 76.5% → 99.6%

Time: 16.3s

Alternatives: 17

Speedup: 1.5×

Specification

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \left(x \cdot 0.5\right)\\ \frac{\left(\frac{8}{3} \cdot t_0\right) \cdot t_0}{\sin x} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (sin (* x 0.5)))) (/ (* (* (/ 8.0 3.0) t_0) t_0) (sin x))))

C

double code(double x) {
	double t_0 = sin((x * 0.5));
	return (((8.0 / 3.0) * t_0) * t_0) / sin(x);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = sin((x * 0.5d0))
    code = (((8.0d0 / 3.0d0) * t_0) * t_0) / sin(x)
end function

Java

public static double code(double x) {
	double t_0 = Math.sin((x * 0.5));
	return (((8.0 / 3.0) * t_0) * t_0) / Math.sin(x);
}

Python

def code(x):
	t_0 = math.sin((x * 0.5))
	return (((8.0 / 3.0) * t_0) * t_0) / math.sin(x)

Julia

function code(x)
	t_0 = sin(Float64(x * 0.5))
	return Float64(Float64(Float64(Float64(8.0 / 3.0) * t_0) * t_0) / sin(x))
end

MATLAB

function tmp = code(x)
	t_0 = sin((x * 0.5));
	tmp = (((8.0 / 3.0) * t_0) * t_0) / sin(x);
end

Wolfram

code[x_] := Block[{t$95$0 = N[Sin[N[(x * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(N[(N[(N[(8.0 / 3.0), $MachinePrecision] * t$95$0), $MachinePrecision] * t$95$0), $MachinePrecision] / N[Sin[x], $MachinePrecision]), $MachinePrecision]]

Initial Program: 76.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \left(x \cdot 0.5\right)\\ \frac{\left(\frac{8}{3} \cdot t_0\right) \cdot t_0}{\sin x} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (sin (* x 0.5)))) (/ (* (* (/ 8.0 3.0) t_0) t_0) (sin x))))

C

double code(double x) {
	double t_0 = sin((x * 0.5));
	return (((8.0 / 3.0) * t_0) * t_0) / sin(x);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = sin((x * 0.5d0))
    code = (((8.0d0 / 3.0d0) * t_0) * t_0) / sin(x)
end function

Java

public static double code(double x) {
	double t_0 = Math.sin((x * 0.5));
	return (((8.0 / 3.0) * t_0) * t_0) / Math.sin(x);
}

Python

def code(x):
	t_0 = math.sin((x * 0.5))
	return (((8.0 / 3.0) * t_0) * t_0) / math.sin(x)

Julia

function code(x)
	t_0 = sin(Float64(x * 0.5))
	return Float64(Float64(Float64(Float64(8.0 / 3.0) * t_0) * t_0) / sin(x))
end

MATLAB

function tmp = code(x)
	t_0 = sin((x * 0.5));
	tmp = (((8.0 / 3.0) * t_0) * t_0) / sin(x);
end

Wolfram

code[x_] := Block[{t$95$0 = N[Sin[N[(x * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(N[(N[(N[(8.0 / 3.0), $MachinePrecision] * t$95$0), $MachinePrecision] * t$95$0), $MachinePrecision] / N[Sin[x], $MachinePrecision]), $MachinePrecision]]

Alternative 1: 99.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.0004:\\ \;\;\;\;\frac{t_0}{0.75 + -0.09375 \cdot {x_m}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{{t_0}^{2}}{0.375}}{\sin x_m}\\ \end{array} \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (*
    x_s
    (if (<= x_m 0.0004)
      (/ t_0 (+ 0.75 (* -0.09375 (pow x_m 2.0))))
      (/ (/ (pow t_0 2.0) 0.375) (sin x_m))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	double tmp;
	if (x_m <= 0.0004) {
		tmp = t_0 / (0.75 + (-0.09375 * pow(x_m, 2.0)));
	} else {
		tmp = (pow(t_0, 2.0) / 0.375) / sin(x_m);
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sin((x_m * 0.5d0))
    if (x_m <= 0.0004d0) then
        tmp = t_0 / (0.75d0 + ((-0.09375d0) * (x_m ** 2.0d0)))
    else
        tmp = ((t_0 ** 2.0d0) / 0.375d0) / sin(x_m)
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	double tmp;
	if (x_m <= 0.0004) {
		tmp = t_0 / (0.75 + (-0.09375 * Math.pow(x_m, 2.0)));
	} else {
		tmp = (Math.pow(t_0, 2.0) / 0.375) / Math.sin(x_m);
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	tmp = 0
	if x_m <= 0.0004:
		tmp = t_0 / (0.75 + (-0.09375 * math.pow(x_m, 2.0)))
	else:
		tmp = (math.pow(t_0, 2.0) / 0.375) / math.sin(x_m)
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	tmp = 0.0
	if (x_m <= 0.0004)
		tmp = Float64(t_0 / Float64(0.75 + Float64(-0.09375 * (x_m ^ 2.0))));
	else
		tmp = Float64(Float64((t_0 ^ 2.0) / 0.375) / sin(x_m));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = 0.0;
	if (x_m <= 0.0004)
		tmp = t_0 / (0.75 + (-0.09375 * (x_m ^ 2.0)));
	else
		tmp = ((t_0 ^ 2.0) / 0.375) / sin(x_m);
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * If[LessEqual[x$95$m, 0.0004], N[(t$95$0 / N[(0.75 + N[(-0.09375 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[t$95$0, 2.0], $MachinePrecision] / 0.375), $MachinePrecision] / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]

Derivation

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

Alternative 2: 99.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \frac{t_0}{0.375 \cdot \frac{\sin x_m}{t_0}} \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5)))) (* x_s (/ t_0 (* 0.375 (/ (sin x_m) t_0))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	return x_s * (t_0 / (0.375 * (sin(x_m) / t_0)));
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    t_0 = sin((x_m * 0.5d0))
    code = x_s * (t_0 / (0.375d0 * (sin(x_m) / t_0)))
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	return x_s * (t_0 / (0.375 * (Math.sin(x_m) / t_0)));
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	return x_s * (t_0 / (0.375 * (math.sin(x_m) / t_0)))

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	return Float64(x_s * Float64(t_0 / Float64(0.375 * Float64(sin(x_m) / t_0))))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = x_s * (t_0 / (0.375 * (sin(x_m) / t_0)));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * N[(t$95$0 / N[(0.375 * N[(N[Sin[x$95$m], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 3: 99.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \left(2.6666666666666665 \cdot \left(t_0 \cdot \frac{t_0}{\sin x_m}\right)\right) \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (* x_s (* 2.6666666666666665 (* t_0 (/ t_0 (sin x_m)))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	return x_s * (2.6666666666666665 * (t_0 * (t_0 / sin(x_m))));
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    t_0 = sin((x_m * 0.5d0))
    code = x_s * (2.6666666666666665d0 * (t_0 * (t_0 / sin(x_m))))
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	return x_s * (2.6666666666666665 * (t_0 * (t_0 / Math.sin(x_m))));
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	return x_s * (2.6666666666666665 * (t_0 * (t_0 / math.sin(x_m))))

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	return Float64(x_s * Float64(2.6666666666666665 * Float64(t_0 * Float64(t_0 / sin(x_m)))))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = x_s * (2.6666666666666665 * (t_0 * (t_0 / sin(x_m))));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * N[(2.6666666666666665 * N[(t$95$0 * N[(t$95$0 / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 4: 99.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \left(\frac{t_0}{\sin x_m} \cdot \left(t_0 \cdot 2.6666666666666665\right)\right) \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (* x_s (* (/ t_0 (sin x_m)) (* t_0 2.6666666666666665)))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	return x_s * ((t_0 / sin(x_m)) * (t_0 * 2.6666666666666665));
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    t_0 = sin((x_m * 0.5d0))
    code = x_s * ((t_0 / sin(x_m)) * (t_0 * 2.6666666666666665d0))
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	return x_s * ((t_0 / Math.sin(x_m)) * (t_0 * 2.6666666666666665));
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	return x_s * ((t_0 / math.sin(x_m)) * (t_0 * 2.6666666666666665))

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	return Float64(x_s * Float64(Float64(t_0 / sin(x_m)) * Float64(t_0 * 2.6666666666666665)))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = x_s * ((t_0 / sin(x_m)) * (t_0 * 2.6666666666666665));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * N[(N[(t$95$0 / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * 2.6666666666666665), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 5: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \left(\frac{t_0}{\sin x_m} \cdot \frac{t_0}{0.375}\right) \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5)))) (* x_s (* (/ t_0 (sin x_m)) (/ t_0 0.375)))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	return x_s * ((t_0 / sin(x_m)) * (t_0 / 0.375));
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    t_0 = sin((x_m * 0.5d0))
    code = x_s * ((t_0 / sin(x_m)) * (t_0 / 0.375d0))
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	return x_s * ((t_0 / Math.sin(x_m)) * (t_0 / 0.375));
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	return x_s * ((t_0 / math.sin(x_m)) * (t_0 / 0.375))

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	return Float64(x_s * Float64(Float64(t_0 / sin(x_m)) * Float64(t_0 / 0.375)))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = x_s * ((t_0 / sin(x_m)) * (t_0 / 0.375));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * N[(N[(t$95$0 / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision] * N[(t$95$0 / 0.375), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 6: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.0004:\\ \;\;\;\;\frac{t_0}{0.75 + -0.09375 \cdot {x_m}^{2}}\\ \mathbf{else}:\\ \;\;\;\;{t_0}^{2} \cdot \frac{2.6666666666666665}{\sin x_m}\\ \end{array} \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (*
    x_s
    (if (<= x_m 0.0004)
      (/ t_0 (+ 0.75 (* -0.09375 (pow x_m 2.0))))
      (* (pow t_0 2.0) (/ 2.6666666666666665 (sin x_m)))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	double tmp;
	if (x_m <= 0.0004) {
		tmp = t_0 / (0.75 + (-0.09375 * pow(x_m, 2.0)));
	} else {
		tmp = pow(t_0, 2.0) * (2.6666666666666665 / sin(x_m));
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sin((x_m * 0.5d0))
    if (x_m <= 0.0004d0) then
        tmp = t_0 / (0.75d0 + ((-0.09375d0) * (x_m ** 2.0d0)))
    else
        tmp = (t_0 ** 2.0d0) * (2.6666666666666665d0 / sin(x_m))
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	double tmp;
	if (x_m <= 0.0004) {
		tmp = t_0 / (0.75 + (-0.09375 * Math.pow(x_m, 2.0)));
	} else {
		tmp = Math.pow(t_0, 2.0) * (2.6666666666666665 / Math.sin(x_m));
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	tmp = 0
	if x_m <= 0.0004:
		tmp = t_0 / (0.75 + (-0.09375 * math.pow(x_m, 2.0)))
	else:
		tmp = math.pow(t_0, 2.0) * (2.6666666666666665 / math.sin(x_m))
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	tmp = 0.0
	if (x_m <= 0.0004)
		tmp = Float64(t_0 / Float64(0.75 + Float64(-0.09375 * (x_m ^ 2.0))));
	else
		tmp = Float64((t_0 ^ 2.0) * Float64(2.6666666666666665 / sin(x_m)));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = 0.0;
	if (x_m <= 0.0004)
		tmp = t_0 / (0.75 + (-0.09375 * (x_m ^ 2.0)));
	else
		tmp = (t_0 ^ 2.0) * (2.6666666666666665 / sin(x_m));
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * If[LessEqual[x$95$m, 0.0004], N[(t$95$0 / N[(0.75 + N[(-0.09375 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[t$95$0, 2.0], $MachinePrecision] * N[(2.6666666666666665 / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]

Derivation

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

Alternative 7: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 2 \cdot 10^{-6}:\\ \;\;\;\;\frac{t_0}{0.75 + -0.09375 \cdot {x_m}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{2.6666666666666665}{\sin x_m \cdot {t_0}^{-2}}\\ \end{array} \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (*
    x_s
    (if (<= x_m 2e-6)
      (/ t_0 (+ 0.75 (* -0.09375 (pow x_m 2.0))))
      (/ 2.6666666666666665 (* (sin x_m) (pow t_0 -2.0)))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	double tmp;
	if (x_m <= 2e-6) {
		tmp = t_0 / (0.75 + (-0.09375 * pow(x_m, 2.0)));
	} else {
		tmp = 2.6666666666666665 / (sin(x_m) * pow(t_0, -2.0));
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sin((x_m * 0.5d0))
    if (x_m <= 2d-6) then
        tmp = t_0 / (0.75d0 + ((-0.09375d0) * (x_m ** 2.0d0)))
    else
        tmp = 2.6666666666666665d0 / (sin(x_m) * (t_0 ** (-2.0d0)))
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	double tmp;
	if (x_m <= 2e-6) {
		tmp = t_0 / (0.75 + (-0.09375 * Math.pow(x_m, 2.0)));
	} else {
		tmp = 2.6666666666666665 / (Math.sin(x_m) * Math.pow(t_0, -2.0));
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	tmp = 0
	if x_m <= 2e-6:
		tmp = t_0 / (0.75 + (-0.09375 * math.pow(x_m, 2.0)))
	else:
		tmp = 2.6666666666666665 / (math.sin(x_m) * math.pow(t_0, -2.0))
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	tmp = 0.0
	if (x_m <= 2e-6)
		tmp = Float64(t_0 / Float64(0.75 + Float64(-0.09375 * (x_m ^ 2.0))));
	else
		tmp = Float64(2.6666666666666665 / Float64(sin(x_m) * (t_0 ^ -2.0)));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = 0.0;
	if (x_m <= 2e-6)
		tmp = t_0 / (0.75 + (-0.09375 * (x_m ^ 2.0)));
	else
		tmp = 2.6666666666666665 / (sin(x_m) * (t_0 ^ -2.0));
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * If[LessEqual[x$95$m, 2e-6], N[(t$95$0 / N[(0.75 + N[(-0.09375 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.6666666666666665 / N[(N[Sin[x$95$m], $MachinePrecision] * N[Power[t$95$0, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]

Derivation

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

Alternative 8: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ \begin{array}{l} t_0 := \sin \left(x_m \cdot 0.5\right)\\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 2 \cdot 10^{-6}:\\ \;\;\;\;\frac{t_0}{0.75 + -0.09375 \cdot {x_m}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{2.6666666666666665}{\frac{\sin x_m}{{t_0}^{2}}}\\ \end{array} \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (let* ((t_0 (sin (* x_m 0.5))))
   (*
    x_s
    (if (<= x_m 2e-6)
      (/ t_0 (+ 0.75 (* -0.09375 (pow x_m 2.0))))
      (/ 2.6666666666666665 (/ (sin x_m) (pow t_0 2.0)))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double t_0 = sin((x_m * 0.5));
	double tmp;
	if (x_m <= 2e-6) {
		tmp = t_0 / (0.75 + (-0.09375 * pow(x_m, 2.0)));
	} else {
		tmp = 2.6666666666666665 / (sin(x_m) / pow(t_0, 2.0));
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sin((x_m * 0.5d0))
    if (x_m <= 2d-6) then
        tmp = t_0 / (0.75d0 + ((-0.09375d0) * (x_m ** 2.0d0)))
    else
        tmp = 2.6666666666666665d0 / (sin(x_m) / (t_0 ** 2.0d0))
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double t_0 = Math.sin((x_m * 0.5));
	double tmp;
	if (x_m <= 2e-6) {
		tmp = t_0 / (0.75 + (-0.09375 * Math.pow(x_m, 2.0)));
	} else {
		tmp = 2.6666666666666665 / (Math.sin(x_m) / Math.pow(t_0, 2.0));
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	t_0 = math.sin((x_m * 0.5))
	tmp = 0
	if x_m <= 2e-6:
		tmp = t_0 / (0.75 + (-0.09375 * math.pow(x_m, 2.0)))
	else:
		tmp = 2.6666666666666665 / (math.sin(x_m) / math.pow(t_0, 2.0))
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	t_0 = sin(Float64(x_m * 0.5))
	tmp = 0.0
	if (x_m <= 2e-6)
		tmp = Float64(t_0 / Float64(0.75 + Float64(-0.09375 * (x_m ^ 2.0))));
	else
		tmp = Float64(2.6666666666666665 / Float64(sin(x_m) / (t_0 ^ 2.0)));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	t_0 = sin((x_m * 0.5));
	tmp = 0.0;
	if (x_m <= 2e-6)
		tmp = t_0 / (0.75 + (-0.09375 * (x_m ^ 2.0)));
	else
		tmp = 2.6666666666666665 / (sin(x_m) / (t_0 ^ 2.0));
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := Block[{t$95$0 = N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(x$95$s * If[LessEqual[x$95$m, 2e-6], N[(t$95$0 / N[(0.75 + N[(-0.09375 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.6666666666666665 / N[(N[Sin[x$95$m], $MachinePrecision] / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]

Derivation

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

Alternative 9: 99.3% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.0048:\\ \;\;\;\;\frac{\sin \left(x_m \cdot 0.5\right)}{0.75 + -0.09375 \cdot {x_m}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{0.5 - \frac{\cos x_m}{2}}{0.375}}{\sin x_m}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (if (<= x_m 0.0048)
    (/ (sin (* x_m 0.5)) (+ 0.75 (* -0.09375 (pow x_m 2.0))))
    (/ (/ (- 0.5 (/ (cos x_m) 2.0)) 0.375) (sin x_m)))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.0048) {
		tmp = sin((x_m * 0.5)) / (0.75 + (-0.09375 * pow(x_m, 2.0)));
	} else {
		tmp = ((0.5 - (cos(x_m) / 2.0)) / 0.375) / sin(x_m);
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: tmp
    if (x_m <= 0.0048d0) then
        tmp = sin((x_m * 0.5d0)) / (0.75d0 + ((-0.09375d0) * (x_m ** 2.0d0)))
    else
        tmp = ((0.5d0 - (cos(x_m) / 2.0d0)) / 0.375d0) / sin(x_m)
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.0048) {
		tmp = Math.sin((x_m * 0.5)) / (0.75 + (-0.09375 * Math.pow(x_m, 2.0)));
	} else {
		tmp = ((0.5 - (Math.cos(x_m) / 2.0)) / 0.375) / Math.sin(x_m);
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	tmp = 0
	if x_m <= 0.0048:
		tmp = math.sin((x_m * 0.5)) / (0.75 + (-0.09375 * math.pow(x_m, 2.0)))
	else:
		tmp = ((0.5 - (math.cos(x_m) / 2.0)) / 0.375) / math.sin(x_m)
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	tmp = 0.0
	if (x_m <= 0.0048)
		tmp = Float64(sin(Float64(x_m * 0.5)) / Float64(0.75 + Float64(-0.09375 * (x_m ^ 2.0))));
	else
		tmp = Float64(Float64(Float64(0.5 - Float64(cos(x_m) / 2.0)) / 0.375) / sin(x_m));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	tmp = 0.0;
	if (x_m <= 0.0048)
		tmp = sin((x_m * 0.5)) / (0.75 + (-0.09375 * (x_m ^ 2.0)));
	else
		tmp = ((0.5 - (cos(x_m) / 2.0)) / 0.375) / sin(x_m);
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * If[LessEqual[x$95$m, 0.0048], N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / N[(0.75 + N[(-0.09375 * N[Power[x$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.5 - N[(N[Cos[x$95$m], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision] / 0.375), $MachinePrecision] / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 10: 99.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.000102:\\ \;\;\;\;\frac{\sin \left(x_m \cdot 0.5\right)}{0.75}\\ \mathbf{else}:\\ \;\;\;\;2.6666666666666665 \cdot \frac{0.5 + \cos x_m \cdot -0.5}{\sin x_m}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (if (<= x_m 0.000102)
    (/ (sin (* x_m 0.5)) 0.75)
    (* 2.6666666666666665 (/ (+ 0.5 (* (cos x_m) -0.5)) (sin x_m))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = 2.6666666666666665 * ((0.5 + (cos(x_m) * -0.5)) / sin(x_m));
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: tmp
    if (x_m <= 0.000102d0) then
        tmp = sin((x_m * 0.5d0)) / 0.75d0
    else
        tmp = 2.6666666666666665d0 * ((0.5d0 + (cos(x_m) * (-0.5d0))) / sin(x_m))
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = Math.sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = 2.6666666666666665 * ((0.5 + (Math.cos(x_m) * -0.5)) / Math.sin(x_m));
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	tmp = 0
	if x_m <= 0.000102:
		tmp = math.sin((x_m * 0.5)) / 0.75
	else:
		tmp = 2.6666666666666665 * ((0.5 + (math.cos(x_m) * -0.5)) / math.sin(x_m))
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	tmp = 0.0
	if (x_m <= 0.000102)
		tmp = Float64(sin(Float64(x_m * 0.5)) / 0.75);
	else
		tmp = Float64(2.6666666666666665 * Float64(Float64(0.5 + Float64(cos(x_m) * -0.5)) / sin(x_m)));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	tmp = 0.0;
	if (x_m <= 0.000102)
		tmp = sin((x_m * 0.5)) / 0.75;
	else
		tmp = 2.6666666666666665 * ((0.5 + (cos(x_m) * -0.5)) / sin(x_m));
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * If[LessEqual[x$95$m, 0.000102], N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / 0.75), $MachinePrecision], N[(2.6666666666666665 * N[(N[(0.5 + N[(N[Cos[x$95$m], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 11: 99.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.000102:\\ \;\;\;\;\frac{\sin \left(x_m \cdot 0.5\right)}{0.75}\\ \mathbf{else}:\\ \;\;\;\;\frac{0.5 - \frac{\cos x_m}{2}}{0.375 \cdot \sin x_m}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (if (<= x_m 0.000102)
    (/ (sin (* x_m 0.5)) 0.75)
    (/ (- 0.5 (/ (cos x_m) 2.0)) (* 0.375 (sin x_m))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = (0.5 - (cos(x_m) / 2.0)) / (0.375 * sin(x_m));
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: tmp
    if (x_m <= 0.000102d0) then
        tmp = sin((x_m * 0.5d0)) / 0.75d0
    else
        tmp = (0.5d0 - (cos(x_m) / 2.0d0)) / (0.375d0 * sin(x_m))
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = Math.sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = (0.5 - (Math.cos(x_m) / 2.0)) / (0.375 * Math.sin(x_m));
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	tmp = 0
	if x_m <= 0.000102:
		tmp = math.sin((x_m * 0.5)) / 0.75
	else:
		tmp = (0.5 - (math.cos(x_m) / 2.0)) / (0.375 * math.sin(x_m))
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	tmp = 0.0
	if (x_m <= 0.000102)
		tmp = Float64(sin(Float64(x_m * 0.5)) / 0.75);
	else
		tmp = Float64(Float64(0.5 - Float64(cos(x_m) / 2.0)) / Float64(0.375 * sin(x_m)));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	tmp = 0.0;
	if (x_m <= 0.000102)
		tmp = sin((x_m * 0.5)) / 0.75;
	else
		tmp = (0.5 - (cos(x_m) / 2.0)) / (0.375 * sin(x_m));
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * If[LessEqual[x$95$m, 0.000102], N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / 0.75), $MachinePrecision], N[(N[(0.5 - N[(N[Cos[x$95$m], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision] / N[(0.375 * N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 12: 99.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.000102:\\ \;\;\;\;\frac{\sin \left(x_m \cdot 0.5\right)}{0.75}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{0.5 - \frac{\cos x_m}{2}}{0.375}}{\sin x_m}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (if (<= x_m 0.000102)
    (/ (sin (* x_m 0.5)) 0.75)
    (/ (/ (- 0.5 (/ (cos x_m) 2.0)) 0.375) (sin x_m)))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = ((0.5 - (cos(x_m) / 2.0)) / 0.375) / sin(x_m);
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: tmp
    if (x_m <= 0.000102d0) then
        tmp = sin((x_m * 0.5d0)) / 0.75d0
    else
        tmp = ((0.5d0 - (cos(x_m) / 2.0d0)) / 0.375d0) / sin(x_m)
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.000102) {
		tmp = Math.sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = ((0.5 - (Math.cos(x_m) / 2.0)) / 0.375) / Math.sin(x_m);
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	tmp = 0
	if x_m <= 0.000102:
		tmp = math.sin((x_m * 0.5)) / 0.75
	else:
		tmp = ((0.5 - (math.cos(x_m) / 2.0)) / 0.375) / math.sin(x_m)
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	tmp = 0.0
	if (x_m <= 0.000102)
		tmp = Float64(sin(Float64(x_m * 0.5)) / 0.75);
	else
		tmp = Float64(Float64(Float64(0.5 - Float64(cos(x_m) / 2.0)) / 0.375) / sin(x_m));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	tmp = 0.0;
	if (x_m <= 0.000102)
		tmp = sin((x_m * 0.5)) / 0.75;
	else
		tmp = ((0.5 - (cos(x_m) / 2.0)) / 0.375) / sin(x_m);
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * If[LessEqual[x$95$m, 0.000102], N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / 0.75), $MachinePrecision], N[(N[(N[(0.5 - N[(N[Cos[x$95$m], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision] / 0.375), $MachinePrecision] / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 13: 99.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \begin{array}{l} \mathbf{if}\;x_m \leq 0.00014:\\ \;\;\;\;\frac{\sin \left(x_m \cdot 0.5\right)}{0.75}\\ \mathbf{else}:\\ \;\;\;\;\frac{1.3333333333333333 + \cos x_m \cdot -1.3333333333333333}{\sin x_m}\\ \end{array} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (if (<= x_m 0.00014)
    (/ (sin (* x_m 0.5)) 0.75)
    (/ (+ 1.3333333333333333 (* (cos x_m) -1.3333333333333333)) (sin x_m)))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.00014) {
		tmp = sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = (1.3333333333333333 + (cos(x_m) * -1.3333333333333333)) / sin(x_m);
	}
	return x_s * tmp;
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    real(8) :: tmp
    if (x_m <= 0.00014d0) then
        tmp = sin((x_m * 0.5d0)) / 0.75d0
    else
        tmp = (1.3333333333333333d0 + (cos(x_m) * (-1.3333333333333333d0))) / sin(x_m)
    end if
    code = x_s * tmp
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	double tmp;
	if (x_m <= 0.00014) {
		tmp = Math.sin((x_m * 0.5)) / 0.75;
	} else {
		tmp = (1.3333333333333333 + (Math.cos(x_m) * -1.3333333333333333)) / Math.sin(x_m);
	}
	return x_s * tmp;
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	tmp = 0
	if x_m <= 0.00014:
		tmp = math.sin((x_m * 0.5)) / 0.75
	else:
		tmp = (1.3333333333333333 + (math.cos(x_m) * -1.3333333333333333)) / math.sin(x_m)
	return x_s * tmp

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	tmp = 0.0
	if (x_m <= 0.00014)
		tmp = Float64(sin(Float64(x_m * 0.5)) / 0.75);
	else
		tmp = Float64(Float64(1.3333333333333333 + Float64(cos(x_m) * -1.3333333333333333)) / sin(x_m));
	end
	return Float64(x_s * tmp)
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp_2 = code(x_s, x_m)
	tmp = 0.0;
	if (x_m <= 0.00014)
		tmp = sin((x_m * 0.5)) / 0.75;
	else
		tmp = (1.3333333333333333 + (cos(x_m) * -1.3333333333333333)) / sin(x_m);
	end
	tmp_2 = x_s * tmp;
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * If[LessEqual[x$95$m, 0.00014], N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / 0.75), $MachinePrecision], N[(N[(1.3333333333333333 + N[(N[Cos[x$95$m], $MachinePrecision] * -1.3333333333333333), $MachinePrecision]), $MachinePrecision] / N[Sin[x$95$m], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 14: 55.3% accurate, 3.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \left(\sin \left(x_m \cdot 0.5\right) \cdot 1.3333333333333333\right) \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (* x_s (* (sin (* x_m 0.5)) 1.3333333333333333)))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	return x_s * (sin((x_m * 0.5)) * 1.3333333333333333);
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    code = x_s * (sin((x_m * 0.5d0)) * 1.3333333333333333d0)
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	return x_s * (Math.sin((x_m * 0.5)) * 1.3333333333333333);
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	return x_s * (math.sin((x_m * 0.5)) * 1.3333333333333333)

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	return Float64(x_s * Float64(sin(Float64(x_m * 0.5)) * 1.3333333333333333))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	tmp = x_s * (sin((x_m * 0.5)) * 1.3333333333333333);
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] * 1.3333333333333333), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 15: 55.6% accurate, 3.0× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \frac{\sin \left(x_m \cdot 0.5\right)}{0.75} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m) :precision binary64 (* x_s (/ (sin (* x_m 0.5)) 0.75)))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	return x_s * (sin((x_m * 0.5)) / 0.75);
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    code = x_s * (sin((x_m * 0.5d0)) / 0.75d0)
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	return x_s * (Math.sin((x_m * 0.5)) / 0.75);
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	return x_s * (math.sin((x_m * 0.5)) / 0.75)

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	return Float64(x_s * Float64(sin(Float64(x_m * 0.5)) / 0.75))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	tmp = x_s * (sin((x_m * 0.5)) / 0.75);
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * N[(N[Sin[N[(x$95$m * 0.5), $MachinePrecision]], $MachinePrecision] / 0.75), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 16: 51.7% accurate, 28.5× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \frac{2.6666666666666665}{x_m \cdot -0.3333333333333333 + 4 \cdot \frac{1}{x_m}} \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m)
 :precision binary64
 (*
  x_s
  (/ 2.6666666666666665 (+ (* x_m -0.3333333333333333) (* 4.0 (/ 1.0 x_m))))))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	return x_s * (2.6666666666666665 / ((x_m * -0.3333333333333333) + (4.0 * (1.0 / x_m))));
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    code = x_s * (2.6666666666666665d0 / ((x_m * (-0.3333333333333333d0)) + (4.0d0 * (1.0d0 / x_m))))
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	return x_s * (2.6666666666666665 / ((x_m * -0.3333333333333333) + (4.0 * (1.0 / x_m))));
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	return x_s * (2.6666666666666665 / ((x_m * -0.3333333333333333) + (4.0 * (1.0 / x_m))))

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	return Float64(x_s * Float64(2.6666666666666665 / Float64(Float64(x_m * -0.3333333333333333) + Float64(4.0 * Float64(1.0 / x_m)))))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	tmp = x_s * (2.6666666666666665 / ((x_m * -0.3333333333333333) + (4.0 * (1.0 / x_m))));
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * N[(2.6666666666666665 / N[(N[(x$95$m * -0.3333333333333333), $MachinePrecision] + N[(4.0 * N[(1.0 / x$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 17: 51.2% accurate, 104.3× speedup

Math

\[\begin{array}{l} x_m = \left|x\right| \\ x_s = \mathsf{copysign}\left(1, x\right) \\ x_s \cdot \left(x_m \cdot 0.6666666666666666\right) \end{array} \]

FPCore

x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
(FPCore (x_s x_m) :precision binary64 (* x_s (* x_m 0.6666666666666666)))

C

x_m = fabs(x);
x_s = copysign(1.0, x);
double code(double x_s, double x_m) {
	return x_s * (x_m * 0.6666666666666666);
}

Fortran

x_m = abs(x)
x_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m)
    real(8), intent (in) :: x_s
    real(8), intent (in) :: x_m
    code = x_s * (x_m * 0.6666666666666666d0)
end function

Java

x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m) {
	return x_s * (x_m * 0.6666666666666666);
}

Python

x_m = math.fabs(x)
x_s = math.copysign(1.0, x)
def code(x_s, x_m):
	return x_s * (x_m * 0.6666666666666666)

Julia

x_m = abs(x)
x_s = copysign(1.0, x)
function code(x_s, x_m)
	return Float64(x_s * Float64(x_m * 0.6666666666666666))
end

MATLAB

x_m = abs(x);
x_s = sign(x) * abs(1.0);
function tmp = code(x_s, x_m)
	tmp = x_s * (x_m * 0.6666666666666666);
end

Wolfram

x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_] := N[(x$95$s * N[(x$95$m * 0.6666666666666666), $MachinePrecision]), $MachinePrecision]

Derivation

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

Developer target: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \left(x \cdot 0.5\right)\\ \frac{\frac{8 \cdot t_0}{3}}{\frac{\sin x}{t_0}} \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (sin (* x 0.5)))) (/ (/ (* 8.0 t_0) 3.0) (/ (sin x) t_0))))

C

double code(double x) {
	double t_0 = sin((x * 0.5));
	return ((8.0 * t_0) / 3.0) / (sin(x) / t_0);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = sin((x * 0.5d0))
    code = ((8.0d0 * t_0) / 3.0d0) / (sin(x) / t_0)
end function

Java

public static double code(double x) {
	double t_0 = Math.sin((x * 0.5));
	return ((8.0 * t_0) / 3.0) / (Math.sin(x) / t_0);
}

Python

def code(x):
	t_0 = math.sin((x * 0.5))
	return ((8.0 * t_0) / 3.0) / (math.sin(x) / t_0)

Julia

function code(x)
	t_0 = sin(Float64(x * 0.5))
	return Float64(Float64(Float64(8.0 * t_0) / 3.0) / Float64(sin(x) / t_0))
end

MATLAB

function tmp = code(x)
	t_0 = sin((x * 0.5));
	tmp = ((8.0 * t_0) / 3.0) / (sin(x) / t_0);
end

Wolfram

code[x_] := Block[{t$95$0 = N[Sin[N[(x * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(N[(N[(8.0 * t$95$0), $MachinePrecision] / 3.0), $MachinePrecision] / N[(N[Sin[x], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]

Reproduce

herbie shell --seed 2023347 
(FPCore (x)
  :name "Graphics.Rasterific.Svg.PathConverter:segmentToBezier from rasterific-svg-0.2.3.1, A"
  :precision binary64

  :herbie-target
  (/ (/ (* 8.0 (sin (* x 0.5))) 3.0) (/ (sin x) (sin (* x 0.5))))

  (/ (* (* (/ 8.0 3.0) (sin (* x 0.5))) (sin (* x 0.5))) (sin x)))