Data.Colour.RGB:hslsv from colour-2.3.3, D

Percentage Accurate: 100.0% → 100.0%

Time: 3.7s

Alternatives: 5

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{x - y}{x + y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (+ x y)))

C

double code(double x, double y) {
	return (x - y) / (x + y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (x + y)
end function

Java

public static double code(double x, double y) {
	return (x - y) / (x + y);
}

Python

def code(x, y):
	return (x - y) / (x + y)

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(x + y))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (x + y);
end

Wolfram

code[x_, y_] := N[(N[(x - y), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{x + y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (+ x y)))

C

double code(double x, double y) {
	return (x - y) / (x + y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (x + y)
end function

Java

public static double code(double x, double y) {
	return (x - y) / (x + y);
}

Python

def code(x, y):
	return (x - y) / (x + y)

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(x + y))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (x + y);
end

Wolfram

code[x_, y_] := N[(N[(x - y), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{x + y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (+ x y)))

C

double code(double x, double y) {
	return (x - y) / (x + y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (x + y)
end function

Java

public static double code(double x, double y) {
	return (x - y) / (x + y);
}

Python

def code(x, y):
	return (x - y) / (x + y)

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(x + y))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (x + y);
end

Wolfram

code[x_, y_] := N[(N[(x - y), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{x - y}{x + y} \]

2. Final simplification 100.0%

   \[\leadsto \frac{x - y}{x + y} \]

Alternative 2: 72.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -4.6 \cdot 10^{+108} \lor \neg \left(y \leq -4.6 \cdot 10^{+38} \lor \neg \left(y \leq -4.6 \cdot 10^{-64}\right) \land \left(y \leq 3.7 \cdot 10^{-14} \lor \neg \left(y \leq 7.8 \cdot 10^{+28}\right) \land y \leq 4.2 \cdot 10^{+55}\right)\right):\\ \;\;\;\;2 \cdot \frac{x}{y} + -1\\ \mathbf{else}:\\ \;\;\;\;1 + -2 \cdot \frac{y}{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (or (<= y -4.6e+108)
         (not
          (or (<= y -4.6e+38)
              (and (not (<= y -4.6e-64))
                   (or (<= y 3.7e-14)
                       (and (not (<= y 7.8e+28)) (<= y 4.2e+55)))))))
   (+ (* 2.0 (/ x y)) -1.0)
   (+ 1.0 (* -2.0 (/ y x)))))

C

double code(double x, double y) {
	double tmp;
	if ((y <= -4.6e+108) || !((y <= -4.6e+38) || (!(y <= -4.6e-64) && ((y <= 3.7e-14) || (!(y <= 7.8e+28) && (y <= 4.2e+55)))))) {
		tmp = (2.0 * (x / y)) + -1.0;
	} else {
		tmp = 1.0 + (-2.0 * (y / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if ((y <= (-4.6d+108)) .or. (.not. (y <= (-4.6d+38)) .or. (.not. (y <= (-4.6d-64))) .and. (y <= 3.7d-14) .or. (.not. (y <= 7.8d+28)) .and. (y <= 4.2d+55))) then
        tmp = (2.0d0 * (x / y)) + (-1.0d0)
    else
        tmp = 1.0d0 + ((-2.0d0) * (y / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if ((y <= -4.6e+108) || !((y <= -4.6e+38) || (!(y <= -4.6e-64) && ((y <= 3.7e-14) || (!(y <= 7.8e+28) && (y <= 4.2e+55)))))) {
		tmp = (2.0 * (x / y)) + -1.0;
	} else {
		tmp = 1.0 + (-2.0 * (y / x));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if (y <= -4.6e+108) or not ((y <= -4.6e+38) or (not (y <= -4.6e-64) and ((y <= 3.7e-14) or (not (y <= 7.8e+28) and (y <= 4.2e+55))))):
		tmp = (2.0 * (x / y)) + -1.0
	else:
		tmp = 1.0 + (-2.0 * (y / x))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if ((y <= -4.6e+108) || !((y <= -4.6e+38) || (!(y <= -4.6e-64) && ((y <= 3.7e-14) || (!(y <= 7.8e+28) && (y <= 4.2e+55))))))
		tmp = Float64(Float64(2.0 * Float64(x / y)) + -1.0);
	else
		tmp = Float64(1.0 + Float64(-2.0 * Float64(y / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if ((y <= -4.6e+108) || ~(((y <= -4.6e+38) || (~((y <= -4.6e-64)) && ((y <= 3.7e-14) || (~((y <= 7.8e+28)) && (y <= 4.2e+55)))))))
		tmp = (2.0 * (x / y)) + -1.0;
	else
		tmp = 1.0 + (-2.0 * (y / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[Or[LessEqual[y, -4.6e+108], N[Not[Or[LessEqual[y, -4.6e+38], And[N[Not[LessEqual[y, -4.6e-64]], $MachinePrecision], Or[LessEqual[y, 3.7e-14], And[N[Not[LessEqual[y, 7.8e+28]], $MachinePrecision], LessEqual[y, 4.2e+55]]]]]], $MachinePrecision]], N[(N[(2.0 * N[(x / y), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(1.0 + N[(-2.0 * N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -4.5999999999999998e108 or -4.6000000000000002e38 < y < -4.6000000000000003e-64 or 3.70000000000000001e-14 < y < 7.7999999999999997e28 or 4.2000000000000001e55 < y

   1. Initial program 99.9%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in x around 0 83.0%

      \[\leadsto \color{blue}{2 \cdot \frac{x}{y} - 1} \]

   if -4.5999999999999998e108 < y < -4.6000000000000002e38 or -4.6000000000000003e-64 < y < 3.70000000000000001e-14 or 7.7999999999999997e28 < y < 4.2000000000000001e55

   1. Initial program 100.0%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in y around 0 82.7%

      \[\leadsto \color{blue}{1 + -2 \cdot \frac{y}{x}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 82.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.6 \cdot 10^{+108} \lor \neg \left(y \leq -4.6 \cdot 10^{+38} \lor \neg \left(y \leq -4.6 \cdot 10^{-64}\right) \land \left(y \leq 3.7 \cdot 10^{-14} \lor \neg \left(y \leq 7.8 \cdot 10^{+28}\right) \land y \leq 4.2 \cdot 10^{+55}\right)\right):\\ \;\;\;\;2 \cdot \frac{x}{y} + -1\\ \mathbf{else}:\\ \;\;\;\;1 + -2 \cdot \frac{y}{x}\\ \end{array} \]

Alternative 3: 72.4% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -4.6 \cdot 10^{+108}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq -5.8 \cdot 10^{+38} \lor \neg \left(y \leq -4.5 \cdot 10^{+17}\right) \land \left(y \leq 3.6 \cdot 10^{-12} \lor \neg \left(y \leq 6.8 \cdot 10^{+20}\right) \land y \leq 5.5 \cdot 10^{+53}\right):\\ \;\;\;\;1 + -2 \cdot \frac{y}{x}\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= y -4.6e+108)
   -1.0
   (if (or (<= y -5.8e+38)
           (and (not (<= y -4.5e+17))
                (or (<= y 3.6e-12) (and (not (<= y 6.8e+20)) (<= y 5.5e+53)))))
     (+ 1.0 (* -2.0 (/ y x)))
     -1.0)))

C

double code(double x, double y) {
	double tmp;
	if (y <= -4.6e+108) {
		tmp = -1.0;
	} else if ((y <= -5.8e+38) || (!(y <= -4.5e+17) && ((y <= 3.6e-12) || (!(y <= 6.8e+20) && (y <= 5.5e+53))))) {
		tmp = 1.0 + (-2.0 * (y / x));
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (y <= (-4.6d+108)) then
        tmp = -1.0d0
    else if ((y <= (-5.8d+38)) .or. (.not. (y <= (-4.5d+17))) .and. (y <= 3.6d-12) .or. (.not. (y <= 6.8d+20)) .and. (y <= 5.5d+53)) then
        tmp = 1.0d0 + ((-2.0d0) * (y / x))
    else
        tmp = -1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (y <= -4.6e+108) {
		tmp = -1.0;
	} else if ((y <= -5.8e+38) || (!(y <= -4.5e+17) && ((y <= 3.6e-12) || (!(y <= 6.8e+20) && (y <= 5.5e+53))))) {
		tmp = 1.0 + (-2.0 * (y / x));
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if y <= -4.6e+108:
		tmp = -1.0
	elif (y <= -5.8e+38) or (not (y <= -4.5e+17) and ((y <= 3.6e-12) or (not (y <= 6.8e+20) and (y <= 5.5e+53)))):
		tmp = 1.0 + (-2.0 * (y / x))
	else:
		tmp = -1.0
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (y <= -4.6e+108)
		tmp = -1.0;
	elseif ((y <= -5.8e+38) || (!(y <= -4.5e+17) && ((y <= 3.6e-12) || (!(y <= 6.8e+20) && (y <= 5.5e+53)))))
		tmp = Float64(1.0 + Float64(-2.0 * Float64(y / x)));
	else
		tmp = -1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (y <= -4.6e+108)
		tmp = -1.0;
	elseif ((y <= -5.8e+38) || (~((y <= -4.5e+17)) && ((y <= 3.6e-12) || (~((y <= 6.8e+20)) && (y <= 5.5e+53)))))
		tmp = 1.0 + (-2.0 * (y / x));
	else
		tmp = -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[y, -4.6e+108], -1.0, If[Or[LessEqual[y, -5.8e+38], And[N[Not[LessEqual[y, -4.5e+17]], $MachinePrecision], Or[LessEqual[y, 3.6e-12], And[N[Not[LessEqual[y, 6.8e+20]], $MachinePrecision], LessEqual[y, 5.5e+53]]]]], N[(1.0 + N[(-2.0 * N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]

Derivation

1. Split input into 2 regimes

2. if y < -4.5999999999999998e108 or -5.80000000000000013e38 < y < -4.5e17 or 3.6e-12 < y < 6.8e20 or 5.49999999999999975e53 < y

   1. Initial program 99.9%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in x around 0 85.3%

      \[\leadsto \color{blue}{-1} \]

   if -4.5999999999999998e108 < y < -5.80000000000000013e38 or -4.5e17 < y < 3.6e-12 or 6.8e20 < y < 5.49999999999999975e53

   1. Initial program 100.0%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in y around 0 80.1%

      \[\leadsto \color{blue}{1 + -2 \cdot \frac{y}{x}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 82.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.6 \cdot 10^{+108}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq -5.8 \cdot 10^{+38} \lor \neg \left(y \leq -4.5 \cdot 10^{+17}\right) \land \left(y \leq 3.6 \cdot 10^{-12} \lor \neg \left(y \leq 6.8 \cdot 10^{+20}\right) \land y \leq 5.5 \cdot 10^{+53}\right):\\ \;\;\;\;1 + -2 \cdot \frac{y}{x}\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \]

Alternative 4: 71.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -4.8 \cdot 10^{+108}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq -3.9 \cdot 10^{+38}:\\ \;\;\;\;1\\ \mathbf{elif}\;y \leq -1 \cdot 10^{-56}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq 5.5 \cdot 10^{-12}:\\ \;\;\;\;1\\ \mathbf{elif}\;y \leq 5 \cdot 10^{+28}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq 2 \cdot 10^{+57}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= y -4.8e+108)
   -1.0
   (if (<= y -3.9e+38)
     1.0
     (if (<= y -1e-56)
       -1.0
       (if (<= y 5.5e-12)
         1.0
         (if (<= y 5e+28) -1.0 (if (<= y 2e+57) 1.0 -1.0)))))))

C

double code(double x, double y) {
	double tmp;
	if (y <= -4.8e+108) {
		tmp = -1.0;
	} else if (y <= -3.9e+38) {
		tmp = 1.0;
	} else if (y <= -1e-56) {
		tmp = -1.0;
	} else if (y <= 5.5e-12) {
		tmp = 1.0;
	} else if (y <= 5e+28) {
		tmp = -1.0;
	} else if (y <= 2e+57) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (y <= (-4.8d+108)) then
        tmp = -1.0d0
    else if (y <= (-3.9d+38)) then
        tmp = 1.0d0
    else if (y <= (-1d-56)) then
        tmp = -1.0d0
    else if (y <= 5.5d-12) then
        tmp = 1.0d0
    else if (y <= 5d+28) then
        tmp = -1.0d0
    else if (y <= 2d+57) then
        tmp = 1.0d0
    else
        tmp = -1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (y <= -4.8e+108) {
		tmp = -1.0;
	} else if (y <= -3.9e+38) {
		tmp = 1.0;
	} else if (y <= -1e-56) {
		tmp = -1.0;
	} else if (y <= 5.5e-12) {
		tmp = 1.0;
	} else if (y <= 5e+28) {
		tmp = -1.0;
	} else if (y <= 2e+57) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if y <= -4.8e+108:
		tmp = -1.0
	elif y <= -3.9e+38:
		tmp = 1.0
	elif y <= -1e-56:
		tmp = -1.0
	elif y <= 5.5e-12:
		tmp = 1.0
	elif y <= 5e+28:
		tmp = -1.0
	elif y <= 2e+57:
		tmp = 1.0
	else:
		tmp = -1.0
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (y <= -4.8e+108)
		tmp = -1.0;
	elseif (y <= -3.9e+38)
		tmp = 1.0;
	elseif (y <= -1e-56)
		tmp = -1.0;
	elseif (y <= 5.5e-12)
		tmp = 1.0;
	elseif (y <= 5e+28)
		tmp = -1.0;
	elseif (y <= 2e+57)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (y <= -4.8e+108)
		tmp = -1.0;
	elseif (y <= -3.9e+38)
		tmp = 1.0;
	elseif (y <= -1e-56)
		tmp = -1.0;
	elseif (y <= 5.5e-12)
		tmp = 1.0;
	elseif (y <= 5e+28)
		tmp = -1.0;
	elseif (y <= 2e+57)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[y, -4.8e+108], -1.0, If[LessEqual[y, -3.9e+38], 1.0, If[LessEqual[y, -1e-56], -1.0, If[LessEqual[y, 5.5e-12], 1.0, If[LessEqual[y, 5e+28], -1.0, If[LessEqual[y, 2e+57], 1.0, -1.0]]]]]]

Derivation

1. Split input into 2 regimes

2. if y < -4.80000000000000037e108 or -3.90000000000000023e38 < y < -1e-56 or 5.5000000000000004e-12 < y < 4.99999999999999957e28 or 2.0000000000000001e57 < y

   1. Initial program 99.9%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in x around 0 82.4%

      \[\leadsto \color{blue}{-1} \]

   if -4.80000000000000037e108 < y < -3.90000000000000023e38 or -1e-56 < y < 5.5000000000000004e-12 or 4.99999999999999957e28 < y < 2.0000000000000001e57

   1. Initial program 100.0%

      \[\frac{x - y}{x + y} \]

   2. Taylor expanded in x around inf 81.4%

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

4. Final simplification 81.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.8 \cdot 10^{+108}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq -3.9 \cdot 10^{+38}:\\ \;\;\;\;1\\ \mathbf{elif}\;y \leq -1 \cdot 10^{-56}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq 5.5 \cdot 10^{-12}:\\ \;\;\;\;1\\ \mathbf{elif}\;y \leq 5 \cdot 10^{+28}:\\ \;\;\;\;-1\\ \mathbf{elif}\;y \leq 2 \cdot 10^{+57}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \]

Alternative 5: 49.4% accurate, 7.0× speedup

Math

\[\begin{array}{l} \\ -1 \end{array} \]

FPCore

(FPCore (x y) :precision binary64 -1.0)

C

double code(double x, double y) {
	return -1.0;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = -1.0d0
end function

Java

public static double code(double x, double y) {
	return -1.0;
}

Python

def code(x, y):
	return -1.0

Julia

function code(x, y)
	return -1.0
end

MATLAB

function tmp = code(x, y)
	tmp = -1.0;
end

Wolfram

code[x_, y_] := -1.0

Derivation

1. Initial program 100.0%

   \[\frac{x - y}{x + y} \]

2. Taylor expanded in x around 0 49.1%

   \[\leadsto \color{blue}{-1} \]

3. Final simplification 49.1%

   \[\leadsto -1 \]

Developer target: 100.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \frac{x}{x + y} - \frac{y}{x + y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- (/ x (+ x y)) (/ y (+ x y))))

C

double code(double x, double y) {
	return (x / (x + y)) - (y / (x + y));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x / (x + y)) - (y / (x + y))
end function

Java

public static double code(double x, double y) {
	return (x / (x + y)) - (y / (x + y));
}

Python

def code(x, y):
	return (x / (x + y)) - (y / (x + y))

Julia

function code(x, y)
	return Float64(Float64(x / Float64(x + y)) - Float64(y / Float64(x + y)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x / (x + y)) - (y / (x + y));
end

Wolfram

code[x_, y_] := N[(N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision] - N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2023199 
(FPCore (x y)
  :name "Data.Colour.RGB:hslsv from colour-2.3.3, D"
  :precision binary64

  :herbie-target
  (- (/ x (+ x y)) (/ y (+ x y)))

  (/ (- x y) (+ x y)))