Data.Colour.RGBSpace.HSL:hsl from colour-2.3.3, C

Percentage Accurate: 100.0% → 100.0%

Time: 5.1s

Alternatives: 3

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ x \cdot 2 - y \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- (* x 2.0) y))

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return (x * 2.0) - y

Julia

function code(x, y)
	return Float64(Float64(x * 2.0) - y)
end

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x \cdot 2 - y \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- (* x 2.0) y))

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return (x * 2.0) - y

Julia

function code(x, y)
	return Float64(Float64(x * 2.0) - y)
end

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x \cdot 2 - y \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- (* x 2.0) y))

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return (x * 2.0) - y

Julia

function code(x, y)
	return Float64(Float64(x * 2.0) - y)
end

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

   \[x \cdot 2 - y \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 51.0% accurate, 2.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return -y

Julia

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

MATLAB

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

Wolfram

code[x_, y_] := (-y)

Derivation

1. Initial program 100.0%

   \[x \cdot 2 - y \]
2. Add Preprocessing

3. Taylor expanded in x around 0 51.2%

   \[\leadsto \color{blue}{-1 \cdot y} \]
4. Step-by-step derivation

   1. neg-mul-1 51.2%

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

5. Simplified 51.2%

   \[\leadsto \color{blue}{-y} \]
6. Add Preprocessing

Alternative 3: 2.7% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ 0 \end{array} \]

FPCore

(FPCore (x y) :precision binary64 0.0)

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return 0.0

Julia

function code(x, y)
	return 0.0
end

MATLAB

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

Wolfram

code[x_, y_] := 0.0

Derivation

1. Initial program 100.0%

   \[x \cdot 2 - y \]
2. Add Preprocessing

3. Taylor expanded in x around 0 51.2%

   \[\leadsto \color{blue}{-1 \cdot y} \]
4. Step-by-step derivation

   1. neg-mul-1 51.2%

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

5. Simplified 51.2%

   \[\leadsto \color{blue}{-y} \]
6. Step-by-step derivation

   1. add-sqr-sqrt 25.2%

      \[\leadsto \color{blue}{\sqrt{-y} \cdot \sqrt{-y}} \]

   2. sqrt-unprod 15.9%

      \[\leadsto \color{blue}{\sqrt{\left(-y\right) \cdot \left(-y\right)}} \]

   3. sqr-neg 15.9%

      \[\leadsto \sqrt{\color{blue}{y \cdot y}} \]

   4. sqrt-unprod 1.3%

      \[\leadsto \color{blue}{\sqrt{y} \cdot \sqrt{y}} \]

   5. add-log-exp 1.2%

      \[\leadsto \color{blue}{\log \left(e^{\sqrt{y} \cdot \sqrt{y}}\right)} \]

   6. add-sqr-sqrt 2.3%

      \[\leadsto \log \left(e^{\color{blue}{y}}\right) \]

   7. add-sqr-sqrt 2.3%

      \[\leadsto \log \color{blue}{\left(\sqrt{e^{y}} \cdot \sqrt{e^{y}}\right)} \]

   8. sqrt-unprod 2.3%

      \[\leadsto \log \color{blue}{\left(\sqrt{e^{y} \cdot e^{y}}\right)} \]

   9. add-sqr-sqrt 1.2%

      \[\leadsto \log \left(\sqrt{e^{y} \cdot e^{\color{blue}{\sqrt{y} \cdot \sqrt{y}}}}\right) \]

   10. sqrt-unprod 2.1%

       \[\leadsto \log \left(\sqrt{e^{y} \cdot e^{\color{blue}{\sqrt{y \cdot y}}}}\right) \]

   11. sqr-neg 2.1%

       \[\leadsto \log \left(\sqrt{e^{y} \cdot e^{\sqrt{\color{blue}{\left(-y\right) \cdot \left(-y\right)}}}}\right) \]

   12. sqrt-unprod 0.9%

       \[\leadsto \log \left(\sqrt{e^{y} \cdot e^{\color{blue}{\sqrt{-y} \cdot \sqrt{-y}}}}\right) \]

   13. add-sqr-sqrt 1.8%

       \[\leadsto \log \left(\sqrt{e^{y} \cdot e^{\color{blue}{-y}}}\right) \]

   14. exp-neg 1.8%

       \[\leadsto \log \left(\sqrt{e^{y} \cdot \color{blue}{\frac{1}{e^{y}}}}\right) \]

   15. rgt-mult-inverse 2.8%

       \[\leadsto \log \left(\sqrt{\color{blue}{1}}\right) \]

   16. metadata-eval 2.8%

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

   17. metadata-eval 2.8%

       \[\leadsto \color{blue}{0} \]

7. Applied egg-rr 2.8%

   \[\leadsto \color{blue}{0} \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2024157 
(FPCore (x y)
  :name "Data.Colour.RGBSpace.HSL:hsl from colour-2.3.3, C"
  :precision binary64
  (- (* x 2.0) y))